@haystackeditor/cli 0.15.26 → 0.15.27

package/dist/commands/production-source-deny-policy.d.ts

@@ -0,0 +1,15 @@
+export declare const CUSTOMER_REPLICA_PRODUCTION_SOURCE_DENY_POLICY: {
+    readonly schemaVersion: 2;
+    readonly policyId: "haystack-production-source-no-existing-tests-v2";
+    readonly deniedDirectoryNames: readonly [".git", ".haystack", ".nyc_output", ".pytest_cache", "__tests__", "acceptance-test", "acceptance-tests", "acceptance_test", "acceptance_tests", "cypress", "e2e", "integration-test", "integration-tests", "integration_test", "integration_tests", "playwright", "playwright-report", "system-test", "system-tests", "system_test", "system_tests", "test", "test-data", "test-results", "testdata", "tests"];
+    readonly conditionalDirectoryNames: readonly ["__fixtures__", "__mocks__", "__snapshots__", "fixtures", "mocks", "snapshots", "spec", "specs"];
+    readonly conditionalDirectoryRule: "exclude root spec/specs when a test framework is detected; exclude fixture/mock/snapshot components only below a detected test root";
+    readonly deniedFilePatterns: readonly ["*.test.{js,jsx,ts,tsx,mjs,cjs}", "*.spec.{js,jsx,ts,tsx,mjs,cjs,rb}", "*.e2e.{js,jsx,ts,tsx}", "*.e2e-spec.{js,jsx,ts,tsx}", "test-*.{js,jsx,ts,tsx,py,rb,go,rs}", "*-test.{js,jsx,ts,tsx,py,rb,go,rs}", "*_test.{py,go,rs,cc,cpp}", "*_tests.{py,rb}", "test_*.py", "*_unittest.{cc,cpp,py}", "*Test.{java,kt,kts,scala,groovy,cs,php,swift}", "*Tests.{java,kt,kts,scala,groovy,cs,php,swift}", "*ITCase.{java,kt,kts,scala,groovy,cs,php,swift}", "*.{snap,golden,approved}", "{jest,vitest,playwright,cypress}.config.*", "karma.conf.*", "mocha.config.*", "pytest.ini", "tox.ini", ".coveragerc", "junit*.xml"];
+    readonly inlineTestScan: {
+        readonly maximumTextFileBytes: number;
+        readonly oversizedTextFileAction: "reject";
+        readonly binaryFileAction: "retain";
+        readonly markerRuleIds: readonly ["rust-cfg-test", "zig-inline-test", "vitest-import-meta", "deno-inline-test", "bun-inline-test", "c-unit-test-conditional", "rust-test-attribute", "jvm-test-annotation", "dotnet-test-attribute", "xctest-case", "python-unittest-case", "python-test-function"];
+    };
+};
+export declare function isCustomerReplicaProductionSourceDeniedPath(path: string): boolean;

package/dist/commands/production-source-deny-policy.js

@@ -0,0 +1,100 @@
+// Which repository paths never reach a reviewer snapshot. Relocated verbatim
+// from the customer-replica connector protocol package when that customer-side
+// plumbing was removed: Haystack builds replicas itself, so the only consumer
+// left is `haystack skills prepare-universe-review`.
+export const CUSTOMER_REPLICA_PRODUCTION_SOURCE_DENY_POLICY = {
+    schemaVersion: 2,
+    policyId: 'haystack-production-source-no-existing-tests-v2',
+    deniedDirectoryNames: [
+        '.git', '.haystack', '.nyc_output', '.pytest_cache', '__tests__', 'acceptance-test',
+        'acceptance-tests', 'acceptance_test', 'acceptance_tests', 'cypress',
+        'e2e', 'integration-test', 'integration-tests',
+        'integration_test', 'integration_tests', 'playwright',
+        'playwright-report', 'system-test',
+        'system-tests', 'system_test', 'system_tests', 'test', 'test-data',
+        'test-results', 'testdata', 'tests',
+    ],
+    conditionalDirectoryNames: [
+        '__fixtures__', '__mocks__', '__snapshots__', 'fixtures', 'mocks',
+        'snapshots', 'spec', 'specs',
+    ],
+    conditionalDirectoryRule: 'exclude root spec/specs when a test framework is detected; exclude fixture/mock/snapshot components only below a detected test root',
+    deniedFilePatterns: [
+        '*.test.{js,jsx,ts,tsx,mjs,cjs}',
+        '*.spec.{js,jsx,ts,tsx,mjs,cjs,rb}',
+        '*.e2e.{js,jsx,ts,tsx}',
+        '*.e2e-spec.{js,jsx,ts,tsx}',
+        'test-*.{js,jsx,ts,tsx,py,rb,go,rs}',
+        '*-test.{js,jsx,ts,tsx,py,rb,go,rs}',
+        '*_test.{py,go,rs,cc,cpp}',
+        '*_tests.{py,rb}',
+        'test_*.py',
+        '*_unittest.{cc,cpp,py}',
+        '*Test.{java,kt,kts,scala,groovy,cs,php,swift}',
+        '*Tests.{java,kt,kts,scala,groovy,cs,php,swift}',
+        '*ITCase.{java,kt,kts,scala,groovy,cs,php,swift}',
+        '*.{snap,golden,approved}',
+        '{jest,vitest,playwright,cypress}.config.*',
+        'karma.conf.*', 'mocha.config.*', 'pytest.ini', 'tox.ini',
+        '.coveragerc', 'junit*.xml',
+    ],
+    inlineTestScan: {
+        maximumTextFileBytes: 2 * 1024 * 1024,
+        oversizedTextFileAction: 'reject',
+        binaryFileAction: 'retain',
+        markerRuleIds: [
+            'rust-cfg-test', 'zig-inline-test', 'vitest-import-meta',
+            'deno-inline-test', 'bun-inline-test', 'c-unit-test-conditional',
+            'rust-test-attribute', 'jvm-test-annotation',
+            'dotnet-test-attribute', 'xctest-case', 'python-unittest-case',
+            'python-test-function',
+        ],
+    },
+};
+export function isCustomerReplicaProductionSourceDeniedPath(path) {
+    const components = path.split('/');
+    if (components.slice(0, -1).some(component => CUSTOMER_REPLICA_PRODUCTION_SOURCE_DENY_POLICY.deniedDirectoryNames
+        .some(denied => denied === component.toLowerCase())))
+        return true;
+    const name = components[components.length - 1];
+    const lowerName = name.toLowerCase();
+    const dot = name.lastIndexOf('.');
+    const stem = dot > 0 && dot < name.length - 1 ? name.slice(0, dot) : name;
+    const extension = dot > 0 && dot < name.length - 1
+        ? name.slice(dot + 1).toLowerCase()
+        : '';
+    const lowerStem = stem.toLowerCase();
+    const js = new Set(['js', 'jsx', 'ts', 'tsx', 'mjs', 'cjs']);
+    if (js.has(extension) && /\.(?:test|e2e|e2e-spec)$/i.test(stem))
+        return true;
+    if ((js.has(extension) || extension === 'rb') && /\.spec$/i.test(stem)) {
+        return true;
+    }
+    if (new Set([...js, 'py', 'rb', 'go', 'rs']).has(extension)
+        && (lowerStem.startsWith('test-') || lowerStem.endsWith('-test')))
+        return true;
+    if (new Set(['py', 'go', 'rs', 'cc', 'cpp']).has(extension)
+        && lowerStem.endsWith('_test'))
+        return true;
+    if (new Set(['py', 'rb']).has(extension) && lowerStem.endsWith('_tests')) {
+        return true;
+    }
+    if (extension === 'py' && lowerStem.startsWith('test_'))
+        return true;
+    if (new Set(['cc', 'cpp', 'py']).has(extension)
+        && lowerStem.endsWith('_unittest'))
+        return true;
+    if (new Set(['java', 'kt', 'kts', 'scala', 'groovy', 'cs', 'php', 'swift'])
+        .has(extension)
+        && (stem.endsWith('Test') || stem.endsWith('Tests') || stem.endsWith('ITCase')))
+        return true;
+    if (new Set(['snap', 'golden', 'approved']).has(extension))
+        return true;
+    if (/^(?:jest|vitest|playwright|cypress)\.config\..+$/i.test(name))
+        return true;
+    if (/^karma\.conf\..+$/i.test(name) || /^mocha\.config\..+$/i.test(name)) {
+        return true;
+    }
+    return new Set(['.coveragerc', 'pytest.ini', 'tox.ini']).has(lowerName)
+        || /^junit.*\.xml$/i.test(name);
+}

package/dist/commands/scaffold-provisional-universe.d.ts

@@ -0,0 +1,468 @@
+import { z } from 'zod';
+declare const ARTIFACT_NAMES: readonly ["universe.yml", "evidence.yml", "review.yml"];
+export declare const TOPOLOGY_PRESENCE_SURFACE_KINDS: readonly ["runtime-entrypoints", "package-workspace-manifests", "container-descriptors", "deployment-descriptors", "structured-capability-indexes"];
+export declare const PROVISIONAL_UNIVERSE_INPUT_MAX_BYTES: number;
+export declare const PROVISIONAL_ACCESS_REQUEST_FIELDS: readonly ["selected-application-id-and-environment-id", "approved-replica-destination-policy-and-approval-ref", "bounded-resource-kinds-opaque-catalog-handles-and-dependency-edges", "artifact-runtime-and-non-secret-config-opaque-catalog-refs", "external-integration-kinds-and-secret-reference-names", "replica-capabilities-strategies-consistency-freshness-latency-and-cost-bounds", "replica-only-golden-descriptor-and-lease-reference-contract"];
+declare const provisionalUniverseScaffoldInputSchema: z.ZodObject<{
+    sourceCommit: z.ZodEffects<z.ZodString, string, string>;
+    application: z.ZodObject<{
+        id: z.ZodEffects<z.ZodString, string, string>;
+        requestedScope: z.ZodEffects<z.ZodString, string, string>;
+        evaluationMode: z.ZodLiteral<"real-production">;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        requestedScope: string;
+        evaluationMode: "real-production";
+    }, {
+        id: string;
+        requestedScope: string;
+        evaluationMode: "real-production";
+    }>;
+    repositoryTopology: z.ZodObject<{
+        id: z.ZodEffects<z.ZodString, string, string>;
+        environmentScope: z.ZodEnum<["hosted-production", "production-reference", "self-host-reference", "local-development", "example", "unknown"]>;
+        fidelityCeiling: z.ZodEnum<["production-reference-only", "self-host-reference-only", "local-development-only", "unknown"]>;
+        evidenceIds: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+        topologyPresenceCensus: z.ZodObject<{
+            status: z.ZodLiteral<"no-production-capable-topology">;
+            subjectId: z.ZodEffects<z.ZodString, string, string>;
+            inspectedSurfaceKinds: z.ZodTuple<[z.ZodLiteral<"runtime-entrypoints">, z.ZodLiteral<"package-workspace-manifests">, z.ZodLiteral<"container-descriptors">, z.ZodLiteral<"deployment-descriptors">, z.ZodLiteral<"structured-capability-indexes">], null>;
+            productionCapableSurfaceCount: z.ZodLiteral<0>;
+            evidenceIds: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+        }, "strict", z.ZodTypeAny, {
+            status: "no-production-capable-topology";
+            evidenceIds: string[];
+            subjectId: string;
+            inspectedSurfaceKinds: ["runtime-entrypoints", "package-workspace-manifests", "container-descriptors", "deployment-descriptors", "structured-capability-indexes"];
+            productionCapableSurfaceCount: 0;
+        }, {
+            status: "no-production-capable-topology";
+            evidenceIds: string[];
+            subjectId: string;
+            inspectedSurfaceKinds: ["runtime-entrypoints", "package-workspace-manifests", "container-descriptors", "deployment-descriptors", "structured-capability-indexes"];
+            productionCapableSurfaceCount: 0;
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        environmentScope: "unknown" | "hosted-production" | "production-reference" | "example" | "self-host-reference" | "local-development";
+        fidelityCeiling: "unknown" | "production-reference-only" | "self-host-reference-only" | "local-development-only";
+        evidenceIds: string[];
+        topologyPresenceCensus: {
+            status: "no-production-capable-topology";
+            evidenceIds: string[];
+            subjectId: string;
+            inspectedSurfaceKinds: ["runtime-entrypoints", "package-workspace-manifests", "container-descriptors", "deployment-descriptors", "structured-capability-indexes"];
+            productionCapableSurfaceCount: 0;
+        };
+    }, {
+        id: string;
+        environmentScope: "unknown" | "hosted-production" | "production-reference" | "example" | "self-host-reference" | "local-development";
+        fidelityCeiling: "unknown" | "production-reference-only" | "self-host-reference-only" | "local-development-only";
+        evidenceIds: string[];
+        topologyPresenceCensus: {
+            status: "no-production-capable-topology";
+            evidenceIds: string[];
+            subjectId: string;
+            inspectedSurfaceKinds: ["runtime-entrypoints", "package-workspace-manifests", "container-descriptors", "deployment-descriptors", "structured-capability-indexes"];
+            productionCapableSurfaceCount: 0;
+        };
+    }>;
+    missingAuthority: z.ZodObject<{
+        id: z.ZodEffects<z.ZodString, string, string>;
+        kind: z.ZodEffects<z.ZodString, string, string>;
+        requiredFor: z.ZodEffects<z.ZodString, string, string>;
+        status: z.ZodLiteral<"unavailable-in-repository">;
+        evidenceIds: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        status: "unavailable-in-repository";
+        id: string;
+        kind: string;
+        evidenceIds: string[];
+        requiredFor: string;
+    }, {
+        status: "unavailable-in-repository";
+        id: string;
+        kind: string;
+        evidenceIds: string[];
+        requiredFor: string;
+    }>;
+    accessRequest: z.ZodObject<{
+        id: z.ZodEffects<z.ZodString, string, string>;
+        source: z.ZodEffects<z.ZodString, string, string>;
+        reason: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        source: string;
+        id: string;
+        reason: string;
+    }, {
+        source: string;
+        id: string;
+        reason: string;
+    }>;
+    evidence: z.ZodArray<z.ZodObject<{
+        id: z.ZodEffects<z.ZodString, string, string>;
+        subjectIds: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+        assertion: z.ZodEffects<z.ZodString, string, string>;
+        environmentScope: z.ZodEnum<["hosted-production", "production-reference", "self-host-reference", "local-development", "example", "unknown"]>;
+        authority: z.ZodEnum<["authoritative", "indicative", "non-production"]>;
+        confidence: z.ZodEnum<["proven", "strong", "tentative"]>;
+        claimKind: z.ZodOptional<z.ZodLiteral<"topology-presence-census">>;
+        sources: z.ZodArray<z.ZodEffects<z.ZodObject<{
+            path: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+            anchor: z.ZodEffects<z.ZodString, string, string>;
+            kind: z.ZodEffects<z.ZodString, string, string>;
+            locatorKind: z.ZodEnum<["symbol", "exact-snippet", "line-span", "manifest-key", "config-key"]>;
+            lines: z.ZodOptional<z.ZodObject<{
+                start: z.ZodNumber;
+                end: z.ZodNumber;
+            }, "strict", z.ZodTypeAny, {
+                start: number;
+                end: number;
+            }, {
+                start: number;
+                end: number;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            path: string;
+            anchor: string;
+            kind: string;
+            locatorKind: "symbol" | "exact-snippet" | "line-span" | "manifest-key" | "config-key";
+            lines?: {
+                start: number;
+                end: number;
+            } | undefined;
+        }, {
+            path: string;
+            anchor: string;
+            kind: string;
+            locatorKind: "symbol" | "exact-snippet" | "line-span" | "manifest-key" | "config-key";
+            lines?: {
+                start: number;
+                end: number;
+            } | undefined;
+        }>, {
+            path: string;
+            anchor: string;
+            kind: string;
+            locatorKind: "symbol" | "exact-snippet" | "line-span" | "manifest-key" | "config-key";
+            lines?: {
+                start: number;
+                end: number;
+            } | undefined;
+        }, {
+            path: string;
+            anchor: string;
+            kind: string;
+            locatorKind: "symbol" | "exact-snippet" | "line-span" | "manifest-key" | "config-key";
+            lines?: {
+                start: number;
+                end: number;
+            } | undefined;
+        }>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        confidence: "proven" | "strong" | "tentative";
+        authority: "authoritative" | "indicative" | "non-production";
+        sources: {
+            path: string;
+            anchor: string;
+            kind: string;
+            locatorKind: "symbol" | "exact-snippet" | "line-span" | "manifest-key" | "config-key";
+            lines?: {
+                start: number;
+                end: number;
+            } | undefined;
+        }[];
+        assertion: string;
+        subjectIds: string[];
+        environmentScope: "unknown" | "hosted-production" | "production-reference" | "example" | "self-host-reference" | "local-development";
+        claimKind?: "topology-presence-census" | undefined;
+    }, {
+        id: string;
+        confidence: "proven" | "strong" | "tentative";
+        authority: "authoritative" | "indicative" | "non-production";
+        sources: {
+            path: string;
+            anchor: string;
+            kind: string;
+            locatorKind: "symbol" | "exact-snippet" | "line-span" | "manifest-key" | "config-key";
+            lines?: {
+                start: number;
+                end: number;
+            } | undefined;
+        }[];
+        assertion: string;
+        subjectIds: string[];
+        environmentScope: "unknown" | "hosted-production" | "production-reference" | "example" | "self-host-reference" | "local-development";
+        claimKind?: "topology-presence-census" | undefined;
+    }>, "many">;
+    coverage: z.ZodObject<{
+        scannedRoots: z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, "many">;
+        sourceKinds: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        scannedRoots: string[];
+        sourceKinds: string[];
+    }, {
+        scannedRoots: string[];
+        sourceKinds: string[];
+    }>;
+    budget: z.ZodObject<{
+        primaryDiscovery: z.ZodObject<{
+            repositoryInspectionCallsUsed: z.ZodNumber;
+            elapsedSeconds: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            repositoryInspectionCallsUsed: number;
+            elapsedSeconds: number;
+        }, {
+            repositoryInspectionCallsUsed: number;
+            elapsedSeconds: number;
+        }>;
+        authorityGate: z.ZodObject<{
+            repositoryInspectionCallsUsed: z.ZodNumber;
+            elapsedSeconds: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            repositoryInspectionCallsUsed: number;
+            elapsedSeconds: number;
+        }, {
+            repositoryInspectionCallsUsed: number;
+            elapsedSeconds: number;
+        }>;
+        overrunBlockerIds: z.ZodOptional<z.ZodObject<{
+            primaryDiscovery: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+            authorityGate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        }, "strict", z.ZodTypeAny, {
+            primaryDiscovery?: string | undefined;
+            authorityGate?: string | undefined;
+        }, {
+            primaryDiscovery?: string | undefined;
+            authorityGate?: string | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        primaryDiscovery: {
+            repositoryInspectionCallsUsed: number;
+            elapsedSeconds: number;
+        };
+        authorityGate: {
+            repositoryInspectionCallsUsed: number;
+            elapsedSeconds: number;
+        };
+        overrunBlockerIds?: {
+            primaryDiscovery?: string | undefined;
+            authorityGate?: string | undefined;
+        } | undefined;
+    }, {
+        primaryDiscovery: {
+            repositoryInspectionCallsUsed: number;
+            elapsedSeconds: number;
+        };
+        authorityGate: {
+            repositoryInspectionCallsUsed: number;
+            elapsedSeconds: number;
+        };
+        overrunBlockerIds?: {
+            primaryDiscovery?: string | undefined;
+            authorityGate?: string | undefined;
+        } | undefined;
+    }>;
+    authorityBlocker: z.ZodObject<{
+        id: z.ZodEffects<z.ZodString, string, string>;
+        kind: z.ZodEnum<["missing-authoritative-source", "production-authority-access-required"]>;
+        evidenceIds: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        kind: "missing-authoritative-source" | "production-authority-access-required";
+        evidenceIds: string[];
+    }, {
+        id: string;
+        kind: "missing-authoritative-source" | "production-authority-access-required";
+        evidenceIds: string[];
+    }>;
+}, "strict", z.ZodTypeAny, {
+    coverage: {
+        scannedRoots: string[];
+        sourceKinds: string[];
+    };
+    budget: {
+        primaryDiscovery: {
+            repositoryInspectionCallsUsed: number;
+            elapsedSeconds: number;
+        };
+        authorityGate: {
+            repositoryInspectionCallsUsed: number;
+            elapsedSeconds: number;
+        };
+        overrunBlockerIds?: {
+            primaryDiscovery?: string | undefined;
+            authorityGate?: string | undefined;
+        } | undefined;
+    };
+    application: {
+        id: string;
+        requestedScope: string;
+        evaluationMode: "real-production";
+    };
+    evidence: {
+        id: string;
+        confidence: "proven" | "strong" | "tentative";
+        authority: "authoritative" | "indicative" | "non-production";
+        sources: {
+            path: string;
+            anchor: string;
+            kind: string;
+            locatorKind: "symbol" | "exact-snippet" | "line-span" | "manifest-key" | "config-key";
+            lines?: {
+                start: number;
+                end: number;
+            } | undefined;
+        }[];
+        assertion: string;
+        subjectIds: string[];
+        environmentScope: "unknown" | "hosted-production" | "production-reference" | "example" | "self-host-reference" | "local-development";
+        claimKind?: "topology-presence-census" | undefined;
+    }[];
+    sourceCommit: string;
+    repositoryTopology: {
+        id: string;
+        environmentScope: "unknown" | "hosted-production" | "production-reference" | "example" | "self-host-reference" | "local-development";
+        fidelityCeiling: "unknown" | "production-reference-only" | "self-host-reference-only" | "local-development-only";
+        evidenceIds: string[];
+        topologyPresenceCensus: {
+            status: "no-production-capable-topology";
+            evidenceIds: string[];
+            subjectId: string;
+            inspectedSurfaceKinds: ["runtime-entrypoints", "package-workspace-manifests", "container-descriptors", "deployment-descriptors", "structured-capability-indexes"];
+            productionCapableSurfaceCount: 0;
+        };
+    };
+    missingAuthority: {
+        status: "unavailable-in-repository";
+        id: string;
+        kind: string;
+        evidenceIds: string[];
+        requiredFor: string;
+    };
+    accessRequest: {
+        source: string;
+        id: string;
+        reason: string;
+    };
+    authorityBlocker: {
+        id: string;
+        kind: "missing-authoritative-source" | "production-authority-access-required";
+        evidenceIds: string[];
+    };
+}, {
+    coverage: {
+        scannedRoots: string[];
+        sourceKinds: string[];
+    };
+    budget: {
+        primaryDiscovery: {
+            repositoryInspectionCallsUsed: number;
+            elapsedSeconds: number;
+        };
+        authorityGate: {
+            repositoryInspectionCallsUsed: number;
+            elapsedSeconds: number;
+        };
+        overrunBlockerIds?: {
+            primaryDiscovery?: string | undefined;
+            authorityGate?: string | undefined;
+        } | undefined;
+    };
+    application: {
+        id: string;
+        requestedScope: string;
+        evaluationMode: "real-production";
+    };
+    evidence: {
+        id: string;
+        confidence: "proven" | "strong" | "tentative";
+        authority: "authoritative" | "indicative" | "non-production";
+        sources: {
+            path: string;
+            anchor: string;
+            kind: string;
+            locatorKind: "symbol" | "exact-snippet" | "line-span" | "manifest-key" | "config-key";
+            lines?: {
+                start: number;
+                end: number;
+            } | undefined;
+        }[];
+        assertion: string;
+        subjectIds: string[];
+        environmentScope: "unknown" | "hosted-production" | "production-reference" | "example" | "self-host-reference" | "local-development";
+        claimKind?: "topology-presence-census" | undefined;
+    }[];
+    sourceCommit: string;
+    repositoryTopology: {
+        id: string;
+        environmentScope: "unknown" | "hosted-production" | "production-reference" | "example" | "self-host-reference" | "local-development";
+        fidelityCeiling: "unknown" | "production-reference-only" | "self-host-reference-only" | "local-development-only";
+        evidenceIds: string[];
+        topologyPresenceCensus: {
+            status: "no-production-capable-topology";
+            evidenceIds: string[];
+            subjectId: string;
+            inspectedSurfaceKinds: ["runtime-entrypoints", "package-workspace-manifests", "container-descriptors", "deployment-descriptors", "structured-capability-indexes"];
+            productionCapableSurfaceCount: 0;
+        };
+    };
+    missingAuthority: {
+        status: "unavailable-in-repository";
+        id: string;
+        kind: string;
+        evidenceIds: string[];
+        requiredFor: string;
+    };
+    accessRequest: {
+        source: string;
+        id: string;
+        reason: string;
+    };
+    authorityBlocker: {
+        id: string;
+        kind: "missing-authoritative-source" | "production-authority-access-required";
+        evidenceIds: string[];
+    };
+}>;
+export type ProvisionalUniverseScaffoldInput = z.infer<typeof provisionalUniverseScaffoldInputSchema>;
+type ArtifactName = (typeof ARTIFACT_NAMES)[number];
+export interface ProvisionalUniverseArtifactMetadata {
+    bytes: number;
+    digest: `sha256:${string}`;
+}
+export interface ProvisionalUniverseScaffoldResult {
+    outputDirectory: string;
+    texts: Record<ArtifactName, string>;
+    artifacts: Record<ArtifactName, ProvisionalUniverseArtifactMetadata>;
+    validationSummary: {
+        universeIds: number;
+        evidenceIds: number;
+        reviewIds: number;
+    };
+}
+export interface ScaffoldProvisionalUniverseCommandOptions {
+    input: string;
+}
+export interface ScaffoldProvisionalUniverseCommandMetadata {
+    status: 'created';
+    output_directory: string;
+    artifacts: Record<ArtifactName, ProvisionalUniverseArtifactMetadata>;
+    validation: {
+        validator_contract_revision: number;
+        universe_ids: number;
+        evidence_ids: number;
+        review_ids: number;
+    };
+}
+/**
+ * Validates a pure, data-only provisional receipt input, validates the rendered
+ * artifacts against the universe contract, then publishes the three-file set by
+ * one directory rename. Cooperative scaffold calls serialize through a lock,
+ * and every destination observed before publication fails closed.
+ */
+export declare function scaffoldProvisionalUniverse(outputDirectory: string, rawInput: unknown): ProvisionalUniverseScaffoldResult;
+/** CLI adapter for later command registration. Always emits one compact JSON line. */
+export declare function scaffoldProvisionalUniverseCommand(options: ScaffoldProvisionalUniverseCommandOptions): void;
+export {};