@interf/compiler 0.22.2 → 0.50.0

package/dist/packages/contracts/lib/schema.d.ts

@@ -1,22 +1,32 @@
 import { z } from "zod";
 export declare const InterfIdPattern: RegExp;
-export declare const PreparationNamePattern: RegExp;
-export declare const PreparationNameSchema: z.ZodString;
+export declare const ProjectIdPattern: RegExp;
+export declare const ProjectIdSchema: z.ZodString;
 export declare const BuildPlanIdSchema: z.ZodString;
 /**
- * Build Plan-declared artifact identifier. Same shape as `BuildPlanIdSchema`
- * but conceptually distinct — it identifies a produced thing inside
- * one Build Plan, while `BuildPlanIdSchema` identifies the Build Plan itself.
+ * The user's agent task for a Project.
+ *
+ * Project intent is the compact, durable instruction that explains what
+ * the Context Graph must prepare the Source for. Build Plans operationalize
+ * this field, but Project owns it.
+ */
+export declare const ProjectIntentSchema: z.ZodString;
+/**
+ * Legacy internal output identifier. Same shape as `BuildPlanIdSchema` but
+ * conceptually distinct: it identifies a requested output inside one Build
+ * Plan, while `BuildPlanIdSchema` identifies the Build Plan itself.
+ *
+ * The exported name remains `ArtifactIdSchema` until the ABI rename lands.
  */
 export declare const ArtifactIdSchema: z.ZodString;
 export declare const RuntimeStageSchema: z.ZodString;
 export declare const RuntimeContractTypeSchema: z.ZodString;
 export declare const RuntimeTargetTypeSchema: z.ZodEnum<{
-    "verifiable-context": "verifiable-context";
+    "context-graph": "context-graph";
 }>;
 export declare const TestTargetTypeSchema: z.ZodEnum<{
-    "verifiable-context": "verifiable-context";
     "source-files": "source-files";
+    "context-graph": "context-graph";
 }>;
 export declare function isInterfRelativePath(value: string): boolean;
 /**
@@ -44,13 +54,17 @@ export type LocatorKind = z.infer<typeof LocatorKindSchema>;
 export type Locator = z.infer<typeof LocatorSchema>;
 export declare const SourceKindSchema: z.ZodEnum<{
     "local-folder": "local-folder";
-    "remote-folder": "remote-folder";
 }>;
+export declare const SourceBindingSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        "local-folder": "local-folder";
+    }>;
+    locator: z.ZodString;
+}, z.core.$strict>;
 export declare const SourceSchema: z.ZodObject<{
     id: z.ZodString;
     kind: z.ZodEnum<{
         "local-folder": "local-folder";
-        "remote-folder": "remote-folder";
     }>;
     locator: z.ZodString;
 }, z.core.$strict>;
@@ -58,6 +72,7 @@ export declare const SourceFileSchema: z.ZodObject<{
     id: z.ZodString;
     path: z.ZodString;
     locator: z.ZodString;
+    size_bytes: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 export declare const SourceFilesSchema: z.ZodObject<{
     kind: z.ZodLiteral<"interf-source-files">;
@@ -67,7 +82,6 @@ export declare const SourceFilesSchema: z.ZodObject<{
         id: z.ZodString;
         kind: z.ZodEnum<{
             "local-folder": "local-folder";
-            "remote-folder": "remote-folder";
         }>;
         locator: z.ZodString;
     }, z.core.$strict>;
@@ -76,19 +90,19 @@ export declare const SourceFilesSchema: z.ZodObject<{
         id: z.ZodString;
         path: z.ZodString;
         locator: z.ZodString;
+        size_bytes: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-export declare const SourceSnapshotSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"interf-source-snapshot">;
+export declare const SourceStateSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-source-state">;
     version: z.ZodLiteral<1>;
-    snapshot_id: z.ZodString;
+    graph_id: z.ZodString;
     generated_at: z.ZodString;
     run_id: z.ZodNullable<z.ZodString>;
     source: z.ZodObject<{
         id: z.ZodString;
         kind: z.ZodEnum<{
             "local-folder": "local-folder";
-            "remote-folder": "remote-folder";
         }>;
         locator: z.ZodString;
     }, z.core.$strict>;
@@ -97,60 +111,881 @@ export declare const SourceSnapshotSchema: z.ZodObject<{
         id: z.ZodString;
         path: z.ZodString;
         locator: z.ZodString;
+        size_bytes: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const SourceInspectableUnitSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        file: "file";
+        page: "page";
+        slide: "slide";
+        sheet: "sheet";
+        table: "table";
+        image: "image";
+        section: "section";
+    }>;
+    index: z.ZodOptional<z.ZodNumber>;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const SourceManifestEvidenceSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        "agent-observation": "agent-observation";
+        "connector-metadata": "connector-metadata";
+        "user-provided": "user-provided";
+    }>;
+    summary: z.ZodString;
+}, z.core.$strict>;
+export declare const SourceManifestFileKindSchema: z.ZodEnum<{
+    image: "image";
+    pdf: "pdf";
+    document: "document";
+    spreadsheet: "spreadsheet";
+    presentation: "presentation";
+    text: "text";
+    other: "other";
+}>;
+export declare const SourceManifestFileSchema: z.ZodObject<{
+    id: z.ZodString;
+    locator: z.ZodString;
+    path: z.ZodString;
+    kind: z.ZodDefault<z.ZodEnum<{
+        image: "image";
+        pdf: "pdf";
+        document: "document";
+        spreadsheet: "spreadsheet";
+        presentation: "presentation";
+        text: "text";
+        other: "other";
+    }>>;
+    size_bytes: z.ZodOptional<z.ZodNumber>;
+    content_hash: z.ZodOptional<z.ZodString>;
+    page_count: z.ZodOptional<z.ZodNumber>;
+    inspectable_units: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            file: "file";
+            page: "page";
+            slide: "slide";
+            sheet: "sheet";
+            table: "table";
+            image: "image";
+            section: "section";
+        }>;
+        index: z.ZodOptional<z.ZodNumber>;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    confidence: z.ZodDefault<z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>>;
+    evidence: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            "agent-observation": "agent-observation";
+            "connector-metadata": "connector-metadata";
+            "user-provided": "user-provided";
+        }>;
+        summary: z.ZodString;
     }, z.core.$strict>>;
 }, z.core.$strict>;
+export declare const SourceManifestScannerSchema: z.ZodObject<{
+    executor: z.ZodString;
+    agent_label: z.ZodString;
+    attempt: z.ZodNumber;
+}, z.core.$strict>;
+export declare const SourceManifestSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-source-manifest">;
+    version: z.ZodLiteral<1>;
+    manifest_id: z.ZodString;
+    generated_at: z.ZodString;
+    run_id: z.ZodNullable<z.ZodString>;
+    project: z.ZodString;
+    source: z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            "local-folder": "local-folder";
+        }>;
+        locator: z.ZodString;
+    }, z.core.$strict>;
+    scanner: z.ZodObject<{
+        executor: z.ZodString;
+        agent_label: z.ZodString;
+        attempt: z.ZodNumber;
+    }, z.core.$strict>;
+    source_total: z.ZodNumber;
+    files: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        locator: z.ZodString;
+        path: z.ZodString;
+        kind: z.ZodDefault<z.ZodEnum<{
+            image: "image";
+            pdf: "pdf";
+            document: "document";
+            spreadsheet: "spreadsheet";
+            presentation: "presentation";
+            text: "text";
+            other: "other";
+        }>>;
+        size_bytes: z.ZodOptional<z.ZodNumber>;
+        content_hash: z.ZodOptional<z.ZodString>;
+        page_count: z.ZodOptional<z.ZodNumber>;
+        inspectable_units: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                file: "file";
+                page: "page";
+                slide: "slide";
+                sheet: "sheet";
+                table: "table";
+                image: "image";
+                section: "section";
+            }>;
+            index: z.ZodOptional<z.ZodNumber>;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        confidence: z.ZodDefault<z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>>;
+        evidence: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                "agent-observation": "agent-observation";
+                "connector-metadata": "connector-metadata";
+                "user-provided": "user-provided";
+            }>;
+            summary: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    warnings: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const SourceManifestAuditSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-source-manifest-audit">;
+    version: z.ZodLiteral<1>;
+    run_id: z.ZodNullable<z.ZodString>;
+    manifest_id: z.ZodString;
+    generated_at: z.ZodString;
+    auditor: z.ZodObject<{
+        executor: z.ZodString;
+        agent_label: z.ZodString;
+        attempt: z.ZodNumber;
+    }, z.core.$strict>;
+    verdict: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        "needs-review": "needs-review";
+    }>;
+    findings: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
 export declare const StageInputSchema: z.ZodObject<{
     source_file_id: z.ZodString;
     path: z.ZodString;
     locator: z.ZodString;
+    kind: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+        image: "image";
+        pdf: "pdf";
+        document: "document";
+        spreadsheet: "spreadsheet";
+        presentation: "presentation";
+        text: "text";
+        other: "other";
+    }>>>;
+    size_bytes: z.ZodOptional<z.ZodNumber>;
+    page_count: z.ZodOptional<z.ZodNumber>;
+    inspectable_units: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            file: "file";
+            page: "page";
+            slide: "slide";
+            sheet: "sheet";
+            table: "table";
+            image: "image";
+            section: "section";
+        }>;
+        index: z.ZodOptional<z.ZodNumber>;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>>;
+    content_hash: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export declare const StageInputsSchema: z.ZodObject<{
     kind: z.ZodLiteral<"interf-stage-inputs">;
-    version: z.ZodLiteral<1>;
+    version: z.ZodLiteral<3>;
     generated_at: z.ZodString;
     run_id: z.ZodNullable<z.ZodString>;
     build_plan: z.ZodString;
     stage: z.ZodString;
-    source_snapshot_id: z.ZodString;
+    source_state_id: z.ZodString;
+    source_manifest_id: z.ZodString;
     input_total: z.ZodNumber;
     inputs: z.ZodArray<z.ZodObject<{
         source_file_id: z.ZodString;
         path: z.ZodString;
         locator: z.ZodString;
+        kind: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+            image: "image";
+            pdf: "pdf";
+            document: "document";
+            spreadsheet: "spreadsheet";
+            presentation: "presentation";
+            text: "text";
+            other: "other";
+        }>>>;
+        size_bytes: z.ZodOptional<z.ZodNumber>;
+        page_count: z.ZodOptional<z.ZodNumber>;
+        inspectable_units: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                file: "file";
+                page: "page";
+                slide: "slide";
+                sheet: "sheet";
+                table: "table";
+                image: "image";
+                section: "section";
+            }>;
+            index: z.ZodOptional<z.ZodNumber>;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>>;
+        content_hash: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare const SourceBuildMaxAttemptsSchema: z.ZodNumber;
 export declare const SourceBuildMaxLoopsSchema: z.ZodNumber;
+export declare const ResourceRoleSchema: z.ZodEnum<{
+    source: "source";
+    summary: "summary";
+    other: "other";
+    knowledge: "knowledge";
+    entrypoint: "entrypoint";
+    diagnostic: "diagnostic";
+}>;
+export declare const MetricKeySchema: z.ZodString;
+export declare const ResourceRefSchema: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodEnum<{
+        source: "source";
+        summary: "summary";
+        other: "other";
+        knowledge: "knowledge";
+        entrypoint: "entrypoint";
+        diagnostic: "diagnostic";
+    }>;
+    kind: z.ZodString;
+    label: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    locator: z.ZodOptional<z.ZodString>;
+    stage_id: z.ZodOptional<z.ZodString>;
+    source_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    links: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export declare const MetricCountSchema: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    value: z.ZodNumber;
+    total: z.ZodOptional<z.ZodNumber>;
+    unit: z.ZodOptional<z.ZodString>;
+    primary: z.ZodDefault<z.ZodBoolean>;
+    issue_state: z.ZodOptional<z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        missing: "missing";
+        review: "review";
+    }>>;
+    detail: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export declare const ReviewedInputDecisionSchema: z.ZodEnum<{
+    missing: "missing";
+    used: "used";
+    reviewed: "reviewed";
+    blocked: "blocked";
+    "not-relevant": "not-relevant";
+}>;
+export declare const ReviewedInputSchema: z.ZodObject<{
+    resource_id: z.ZodString;
+    decision: z.ZodEnum<{
+        missing: "missing";
+        used: "used";
+        reviewed: "reviewed";
+        blocked: "blocked";
+        "not-relevant": "not-relevant";
+    }>;
+    reason: z.ZodOptional<z.ZodString>;
+    output_resource_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    source_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export declare const MissingInputSchema: z.ZodObject<{
+    resource_id: z.ZodString;
+    status: z.ZodEnum<{
+        missing: "missing";
+        blocked: "blocked";
+        "not-relevant": "not-relevant";
+    }>;
+    reason: z.ZodString;
+}, z.core.$strict>;
+/**
+ * Stage runtime-file contracts: the `expected-inputs.json` and
+ * `reviewed-inputs.json` files a stage shell reads and writes. Defined once
+ * here so the build engine (stage-manifest writer, native entrypoint reader)
+ * and any future client validate against one shape instead of a hand-rolled
+ * parallel `interface`.
+ */
+export declare const ExpectedInputsFileSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-stage-expected-inputs">;
+    version: z.ZodLiteral<1>;
+    generated_at: z.ZodString;
+    stage_id: z.ZodString;
+    expected: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodEnum<{
+            source: "source";
+            summary: "summary";
+            other: "other";
+            knowledge: "knowledge";
+            entrypoint: "entrypoint";
+            diagnostic: "diagnostic";
+        }>;
+        kind: z.ZodString;
+        label: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        locator: z.ZodOptional<z.ZodString>;
+        stage_id: z.ZodOptional<z.ZodString>;
+        source_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        links: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ExpectedInputsFile = z.infer<typeof ExpectedInputsFileSchema>;
+export declare const ReviewedInputsFileSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-stage-reviewed-inputs">;
+    version: z.ZodLiteral<1>;
+    generated_at: z.ZodString;
+    stage_id: z.ZodString;
+    reviewed: z.ZodArray<z.ZodObject<{
+        resource_id: z.ZodString;
+        decision: z.ZodEnum<{
+            missing: "missing";
+            used: "used";
+            reviewed: "reviewed";
+            blocked: "blocked";
+            "not-relevant": "not-relevant";
+        }>;
+        reason: z.ZodOptional<z.ZodString>;
+        output_resource_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        source_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ReviewedInputsFile = z.infer<typeof ReviewedInputsFileSchema>;
+export declare const StageManifestSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-stage-manifest">;
+    version: z.ZodLiteral<1>;
+    generated_at: z.ZodString;
+    project: z.ZodString;
+    run_id: z.ZodNullable<z.ZodString>;
+    build_plan: z.ZodString;
+    stage_id: z.ZodString;
+    stage_label: z.ZodString;
+    role: z.ZodEnum<{
+        source: "source";
+        summary: "summary";
+        other: "other";
+        knowledge: "knowledge";
+        entrypoint: "entrypoint";
+        diagnostic: "diagnostic";
+    }>;
+    summary: z.ZodString;
+    input_manifests: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodEnum<{
+            source: "source";
+            summary: "summary";
+            other: "other";
+            knowledge: "knowledge";
+            entrypoint: "entrypoint";
+            diagnostic: "diagnostic";
+        }>;
+        kind: z.ZodString;
+        label: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        locator: z.ZodOptional<z.ZodString>;
+        stage_id: z.ZodOptional<z.ZodString>;
+        source_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        links: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
+    expected: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodEnum<{
+            source: "source";
+            summary: "summary";
+            other: "other";
+            knowledge: "knowledge";
+            entrypoint: "entrypoint";
+            diagnostic: "diagnostic";
+        }>;
+        kind: z.ZodString;
+        label: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        locator: z.ZodOptional<z.ZodString>;
+        stage_id: z.ZodOptional<z.ZodString>;
+        source_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        links: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
+    reviewed: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        resource_id: z.ZodString;
+        decision: z.ZodEnum<{
+            missing: "missing";
+            used: "used";
+            reviewed: "reviewed";
+            blocked: "blocked";
+            "not-relevant": "not-relevant";
+        }>;
+        reason: z.ZodOptional<z.ZodString>;
+        output_resource_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        source_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
+    referenced: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodEnum<{
+            source: "source";
+            summary: "summary";
+            other: "other";
+            knowledge: "knowledge";
+            entrypoint: "entrypoint";
+            diagnostic: "diagnostic";
+        }>;
+        kind: z.ZodString;
+        label: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        locator: z.ZodOptional<z.ZodString>;
+        stage_id: z.ZodOptional<z.ZodString>;
+        source_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        links: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
+    missing: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        resource_id: z.ZodString;
+        status: z.ZodEnum<{
+            missing: "missing";
+            blocked: "blocked";
+            "not-relevant": "not-relevant";
+        }>;
+        reason: z.ZodString;
+    }, z.core.$strict>>>;
+    produced: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodEnum<{
+            source: "source";
+            summary: "summary";
+            other: "other";
+            knowledge: "knowledge";
+            entrypoint: "entrypoint";
+            diagnostic: "diagnostic";
+        }>;
+        kind: z.ZodString;
+        label: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        locator: z.ZodOptional<z.ZodString>;
+        stage_id: z.ZodOptional<z.ZodString>;
+        source_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        links: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
+    metrics: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        value: z.ZodNumber;
+        total: z.ZodOptional<z.ZodNumber>;
+        unit: z.ZodOptional<z.ZodString>;
+        primary: z.ZodDefault<z.ZodBoolean>;
+        issue_state: z.ZodOptional<z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            missing: "missing";
+            review: "review";
+        }>>;
+        detail: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const GraphManifestStageSummarySchema: z.ZodObject<{
+    stage_id: z.ZodString;
+    stage_label: z.ZodString;
+    role: z.ZodEnum<{
+        source: "source";
+        summary: "summary";
+        other: "other";
+        knowledge: "knowledge";
+        entrypoint: "entrypoint";
+        diagnostic: "diagnostic";
+    }>;
+    manifest_path: z.ZodString;
+    summary: z.ZodString;
+    produced_total: z.ZodNumber;
+    missing_required_total: z.ZodNumber;
+    metrics: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        value: z.ZodNumber;
+        total: z.ZodOptional<z.ZodNumber>;
+        unit: z.ZodOptional<z.ZodString>;
+        primary: z.ZodDefault<z.ZodBoolean>;
+        issue_state: z.ZodOptional<z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            missing: "missing";
+            review: "review";
+        }>>;
+        detail: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const GraphReadinessRollupSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        ready: "ready";
+        "not-ready": "not-ready";
+    }>;
+    ready: z.ZodBoolean;
+    summary: z.ZodString;
+    context_graph_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    missing_required_total: z.ZodNumber;
+    missing: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        resource_id: z.ZodString;
+        status: z.ZodEnum<{
+            missing: "missing";
+            blocked: "blocked";
+            "not-relevant": "not-relevant";
+        }>;
+        reason: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const GraphOutputCountsSchema: z.ZodObject<{
+    nodes: z.ZodNumber;
+    edges: z.ZodNumber;
+    notes: z.ZodNumber;
+    links: z.ZodNumber;
+    source_refs: z.ZodNumber;
+    claims: z.ZodOptional<z.ZodNumber>;
+    entities: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const GraphManifestSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-graph-manifest">;
+    version: z.ZodLiteral<1>;
+    generated_at: z.ZodString;
+    project: z.ZodString;
+    graph_id: z.ZodString;
+    run_id: z.ZodNullable<z.ZodString>;
+    build_plan: z.ZodString;
+    intent: z.ZodNullable<z.ZodString>;
+    graph_path: z.ZodString;
+    primary_metrics: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        value: z.ZodNumber;
+        total: z.ZodOptional<z.ZodNumber>;
+        unit: z.ZodOptional<z.ZodString>;
+        primary: z.ZodDefault<z.ZodBoolean>;
+        issue_state: z.ZodOptional<z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            missing: "missing";
+            review: "review";
+        }>>;
+        detail: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
+    stages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        stage_id: z.ZodString;
+        stage_label: z.ZodString;
+        role: z.ZodEnum<{
+            source: "source";
+            summary: "summary";
+            other: "other";
+            knowledge: "knowledge";
+            entrypoint: "entrypoint";
+            diagnostic: "diagnostic";
+        }>;
+        manifest_path: z.ZodString;
+        summary: z.ZodString;
+        produced_total: z.ZodNumber;
+        missing_required_total: z.ZodNumber;
+        metrics: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            value: z.ZodNumber;
+            total: z.ZodOptional<z.ZodNumber>;
+            unit: z.ZodOptional<z.ZodString>;
+            primary: z.ZodDefault<z.ZodBoolean>;
+            issue_state: z.ZodOptional<z.ZodEnum<{
+                pass: "pass";
+                fail: "fail";
+                missing: "missing";
+                review: "review";
+            }>>;
+            detail: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+    entrypoints: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodEnum<{
+            source: "source";
+            summary: "summary";
+            other: "other";
+            knowledge: "knowledge";
+            entrypoint: "entrypoint";
+            diagnostic: "diagnostic";
+        }>;
+        kind: z.ZodString;
+        label: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        locator: z.ZodOptional<z.ZodString>;
+        stage_id: z.ZodOptional<z.ZodString>;
+        source_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        links: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
+    resources: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodEnum<{
+            source: "source";
+            summary: "summary";
+            other: "other";
+            knowledge: "knowledge";
+            entrypoint: "entrypoint";
+            diagnostic: "diagnostic";
+        }>;
+        kind: z.ZodString;
+        label: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        locator: z.ZodOptional<z.ZodString>;
+        stage_id: z.ZodOptional<z.ZodString>;
+        source_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        links: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
+    graph_outputs: z.ZodObject<{
+        nodes: z.ZodNumber;
+        edges: z.ZodNumber;
+        notes: z.ZodNumber;
+        links: z.ZodNumber;
+        source_refs: z.ZodNumber;
+        claims: z.ZodOptional<z.ZodNumber>;
+        entities: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    readiness: z.ZodObject<{
+        status: z.ZodEnum<{
+            ready: "ready";
+            "not-ready": "not-ready";
+        }>;
+        ready: z.ZodBoolean;
+        summary: z.ZodString;
+        context_graph_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        missing_required_total: z.ZodNumber;
+        missing: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            resource_id: z.ZodString;
+            status: z.ZodEnum<{
+                missing: "missing";
+                blocked: "blocked";
+                "not-relevant": "not-relevant";
+            }>;
+            reason: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
 /**
  * Canonical check kinds the engine knows how to evaluate.
  *
  * Adding a new kind requires an engine release (the evaluator must
- * implement it). Build Plans and user checks pick from this list; they
+ * implement it). Plans and user checks pick from this list; they
  * cannot invent custom kinds.
  *
  *   file_exists                    — file is present and non-empty
+ *   source_manifest_valid          — source-manifest.json exists, parses, and has at least one file
  *   min_file_count                 — directory has ≥ N files (params: { min: number })
  *   min_file_count_matches_source  — directory has ≥ source_total files (the "all files analyzed" check)
+ *   source_summary_folders         — summaries directory has ≥ source_total source folders, each with summary.md or manifest.md
+ *   source_page_coverage           — page summary outputs exist for every manifest page unit
  *   frontmatter_valid              — every markdown file has parseable YAML frontmatter
  *   frontmatter_required_keys      — every markdown file has these frontmatter keys (params: { keys: string[] })
+ *   frontmatter_nonempty_keys      — every markdown file has non-empty values for these frontmatter keys
+ *   source_refs_required           — every markdown file has non-empty source_refs/source_ref/source_path frontmatter
+ *   summary_backlinks_present      — every summary cited by a note's source_refs is also wikilinked from that layer (no orphaned summaries)
+ *   knowledge_web_connectivity     — every knowledge note links at least one OTHER knowledge note (no disconnected islands in the knowledge web)
+ *   graph_notes_connected          — every markdown note across the WHOLE Context Graph (summaries, knowledge, artifacts, home) is link-connected to at least one other note (no free-floating island anywhere, including uncited summaries)
  *   wikilinks_valid                — every wikilink resolves
- *   must_not_contain               — file/directory does not contain forbidden phrases (params: { phrases: string[] })
- *   must_contain                   — file/directory contains required phrases (params: { phrases: string[] })
- *   qa_match                       — user-defined Q/A: agent answer matches expected (params: { question, expected, strictness })
+ *   must_not_contain               — file/directory does not contain forbidden phrases (params: { phrases: string[] } or { text: string })
+ *   must_contain                   — file/directory contains required phrases (params: { phrases: string[] } or { text: string })
+ *   qa_match                       — user-defined Q/A: agent answer matches expected (params: { expected: string, strictness?: "loose" | "strict" })
  */
-export declare const CHECK_KINDS: readonly ["file_exists", "min_file_count", "min_file_count_matches_source", "frontmatter_valid", "frontmatter_required_keys", "wikilinks_valid", "must_not_contain", "must_contain", "qa_match"];
+export declare const CHECK_KINDS: readonly ["file_exists", "source_manifest_valid", "min_file_count", "min_file_count_matches_source", "source_summary_folders", "source_page_coverage", "frontmatter_valid", "frontmatter_required_keys", "frontmatter_nonempty_keys", "source_refs_required", "summary_backlinks_present", "knowledge_web_connectivity", "graph_notes_connected", "wikilinks_valid", "must_not_contain", "must_contain", "qa_match"];
 export declare const CheckKindSchema: z.ZodEnum<{
     file_exists: "file_exists";
+    source_manifest_valid: "source_manifest_valid";
     min_file_count: "min_file_count";
     min_file_count_matches_source: "min_file_count_matches_source";
+    source_summary_folders: "source_summary_folders";
+    source_page_coverage: "source_page_coverage";
     frontmatter_valid: "frontmatter_valid";
     frontmatter_required_keys: "frontmatter_required_keys";
+    frontmatter_nonempty_keys: "frontmatter_nonempty_keys";
+    source_refs_required: "source_refs_required";
+    summary_backlinks_present: "summary_backlinks_present";
+    knowledge_web_connectivity: "knowledge_web_connectivity";
+    graph_notes_connected: "graph_notes_connected";
     wikilinks_valid: "wikilinks_valid";
     must_not_contain: "must_not_contain";
     must_contain: "must_contain";
     qa_match: "qa_match";
 }>;
 export type CheckKind = z.infer<typeof CheckKindSchema>;
+export declare const CHECK_PARAM_CONTRACTS: {
+    readonly file_exists: {
+        readonly params: {};
+        readonly examples: readonly [{}];
+    };
+    readonly source_manifest_valid: {
+        readonly params: {
+            readonly path: "optional manifest path; defaults to .interf/runtime/source-manifest.json";
+        };
+        readonly examples: readonly [{}];
+    };
+    readonly min_file_count: {
+        readonly params: {
+            readonly min: "optional number; defaults to 1";
+        };
+        readonly examples: readonly [{
+            readonly min: 26;
+        }];
+    };
+    readonly min_file_count_matches_source: {
+        readonly params: {
+            readonly match: "optional count key string; defaults to source_total";
+        };
+        readonly examples: readonly [{
+            readonly match: "source_total";
+        }];
+    };
+    readonly source_summary_folders: {
+        readonly params: {
+            readonly match: "optional count key string; defaults to source_total";
+            readonly summary_file: "optional filename string; defaults to summary.md";
+            readonly manifest_file: "optional filename string; defaults to manifest.md";
+        };
+        readonly examples: readonly [{
+            readonly match: "source_total";
+        }];
+    };
+    readonly source_page_coverage: {
+        readonly params: {
+            readonly pages_dir: "optional directory name inside each source summary folder; defaults to pages";
+            readonly summary_file: "optional filename string; defaults to summary.md";
+        };
+        readonly examples: readonly [{
+            readonly pages_dir: "pages";
+        }];
+    };
+    readonly frontmatter_valid: {
+        readonly params: {};
+        readonly examples: readonly [{}];
+    };
+    readonly frontmatter_required_keys: {
+        readonly params: {
+            readonly keys: "required string[]";
+        };
+        readonly examples: readonly [{
+            readonly keys: readonly ["page", "title", "summary"];
+        }];
+    };
+    readonly frontmatter_nonempty_keys: {
+        readonly params: {
+            readonly keys: "required string[]";
+        };
+        readonly examples: readonly [{
+            readonly keys: readonly ["source_refs", "verification_state"];
+        }];
+    };
+    readonly source_refs_required: {
+        readonly params: {
+            readonly keys: "optional string[]; defaults to source_refs, source_ref, source_path";
+        };
+        readonly examples: readonly [{
+            readonly keys: readonly ["source_refs"];
+        }];
+    };
+    readonly summary_backlinks_present: {
+        readonly params: {
+            readonly summaries_dir: "optional summaries directory name; defaults to summaries";
+            readonly summary_file: "optional summary filename; defaults to summary.md";
+            readonly manifest_file: "optional manifest filename; defaults to manifest.md";
+        };
+        readonly examples: readonly [{}, {
+            readonly summaries_dir: "summaries";
+        }];
+    };
+    readonly knowledge_web_connectivity: {
+        readonly params: {
+            readonly knowledge_dir: "optional knowledge directory; defaults to the artifact's own target path. May only narrow the scan to a path inside that target layer.";
+        };
+        readonly examples: readonly [{}, {
+            readonly knowledge_dir: "knowledge";
+        }];
+    };
+    readonly graph_notes_connected: {
+        readonly params: {
+            readonly graph_root: "optional graph-root-relative directory to scan; defaults to the Context Graph root (every note in every layer). Use to narrow the floor to one layer (e.g. summaries) when a Build Plan splits the connectivity floor across outputs.";
+        };
+        readonly examples: readonly [{}, {
+            readonly graph_root: "summaries";
+        }];
+    };
+    readonly wikilinks_valid: {
+        readonly params: {};
+        readonly examples: readonly [{}];
+    };
+    readonly must_not_contain: {
+        readonly params: {
+            readonly phrases: "preferred string[] of forbidden phrases";
+            readonly text: "optional string shorthand for one forbidden phrase";
+        };
+        readonly examples: readonly [{
+            readonly phrases: readonly ["TODO", "Not yet built."];
+        }, {
+            readonly text: "TODO";
+        }];
+    };
+    readonly must_contain: {
+        readonly params: {
+            readonly phrases: "preferred string[] of required phrases";
+            readonly text: "optional string shorthand for one required phrase";
+        };
+        readonly examples: readonly [{
+            readonly phrases: readonly ["Bristol", "Central London"];
+        }, {
+            readonly text: "Bristol";
+        }];
+    };
+    readonly qa_match: {
+        readonly params: {
+            readonly expected: "required expected answer string";
+            readonly strictness: "optional string; loose or strict; defaults to loose";
+        };
+        readonly examples: readonly [{
+            readonly expected: "Acme Corp";
+            readonly strictness: "loose";
+        }];
+    };
+};
 /**
  * One check declaration. Reusable across stage/artifact/user scopes.
  *
@@ -160,17 +995,25 @@ export type CheckKind = z.infer<typeof CheckKindSchema>;
  * rule-specific config (typed at the engine evaluator).
  *
  * `required: true` (default) → a failed check fails the parent
- * (stage/artifact/preparation). `required: false` → soft check, fails
+ * (stage/artifact/Project). `required: false` → soft check, fails
  * warn but don't block the `ready` verdict.
  */
 export declare const CheckSchema: z.ZodObject<{
     id: z.ZodString;
     kind: z.ZodEnum<{
         file_exists: "file_exists";
+        source_manifest_valid: "source_manifest_valid";
         min_file_count: "min_file_count";
         min_file_count_matches_source: "min_file_count_matches_source";
+        source_summary_folders: "source_summary_folders";
+        source_page_coverage: "source_page_coverage";
         frontmatter_valid: "frontmatter_valid";
         frontmatter_required_keys: "frontmatter_required_keys";
+        frontmatter_nonempty_keys: "frontmatter_nonempty_keys";
+        source_refs_required: "source_refs_required";
+        summary_backlinks_present: "summary_backlinks_present";
+        knowledge_web_connectivity: "knowledge_web_connectivity";
+        graph_notes_connected: "graph_notes_connected";
         wikilinks_valid: "wikilinks_valid";
         must_not_contain: "must_not_contain";
         must_contain: "must_contain";
@@ -186,14 +1029,22 @@ export type Check = z.infer<typeof CheckSchema>;
  * short one-line label for the UI; `details` carries rule-specific
  * structured data (e.g., file count, missing keys, broken link list).
  */
-export declare const ProofSchema: z.ZodObject<{
+export declare const CheckResultSchema: z.ZodObject<{
     check_id: z.ZodString;
     kind: z.ZodEnum<{
         file_exists: "file_exists";
+        source_manifest_valid: "source_manifest_valid";
         min_file_count: "min_file_count";
         min_file_count_matches_source: "min_file_count_matches_source";
+        source_summary_folders: "source_summary_folders";
+        source_page_coverage: "source_page_coverage";
         frontmatter_valid: "frontmatter_valid";
         frontmatter_required_keys: "frontmatter_required_keys";
+        frontmatter_nonempty_keys: "frontmatter_nonempty_keys";
+        source_refs_required: "source_refs_required";
+        summary_backlinks_present: "summary_backlinks_present";
+        knowledge_web_connectivity: "knowledge_web_connectivity";
+        graph_notes_connected: "graph_notes_connected";
         wikilinks_valid: "wikilinks_valid";
         must_not_contain: "must_not_contain";
         must_contain: "must_contain";
@@ -205,16 +1056,75 @@ export declare const ProofSchema: z.ZodObject<{
     details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     evaluated_at: z.ZodString;
 }, z.core.$strict>;
-export type Proof = z.infer<typeof ProofSchema>;
+export type CheckResult = z.infer<typeof CheckResultSchema>;
+export declare const ContextCheckStatusSchema: z.ZodEnum<{
+    passed: "passed";
+    pending: "pending";
+    running: "running";
+    failed: "failed";
+    skipped: "skipped";
+}>;
+export type ContextCheckStatus = z.infer<typeof ContextCheckStatusSchema>;
+/**
+ * Legacy Build Plan check declaration. Current product surfaces should prefer
+ * concrete coverage metrics, Stage Manifests, and Graph Manifest readiness.
+ * Deterministic output diagnostics remain nested under requested outputs and
+ * use `CheckSchema`.
+ */
+export declare const ContextCheckDeclarationSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    backed_by_artifact_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    evidence_expectation: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const ContextCheckProjectionSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    backed_by_artifact_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    evidence_expectation: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        passed: "passed";
+        pending: "pending";
+        running: "running";
+        failed: "failed";
+        skipped: "skipped";
+    }>>;
+    evidence: z.ZodOptional<z.ZodString>;
+    issue: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const ContextCheckSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    backed_by_artifact_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    evidence_expectation: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        passed: "passed";
+        pending: "pending";
+        running: "running";
+        failed: "failed";
+        skipped: "skipped";
+    }>>;
+    evidence: z.ZodOptional<z.ZodString>;
+    issue: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ContextCheckDeclaration = z.infer<typeof ContextCheckDeclarationSchema>;
+export type ContextCheckProjection = z.infer<typeof ContextCheckProjectionSchema>;
+export type ContextCheck = z.infer<typeof ContextCheckSchema>;
 /**
  * Per-thing readiness verdict. Used for an artifact, a stage, or a
- * preparation. Aggregate verdict over its required checks.
+ * Project. Aggregate verdict over its required checks.
  */
 export declare const ReadyVerdictSchema: z.ZodEnum<{
     ready: "ready";
-    not_ready: "not_ready";
     failed: "failed";
     skipped: "skipped";
+    not_ready: "not_ready";
 }>;
 export type ReadyVerdict = z.infer<typeof ReadyVerdictSchema>;
 /**
@@ -223,14 +1133,14 @@ export type ReadyVerdict = z.infer<typeof ReadyVerdictSchema>;
  * convention reference this constant in `frontmatter_required_keys`
  * check params rather than re-typing the list.
  */
-export declare const STANDARD_EVIDENCE_FRONTMATTER_KEYS: readonly ["source", "source_kind", "evidence_tier", "truth_mode", "state"];
+export declare const STANDARD_EVIDENCE_FRONTMATTER_KEYS: readonly ["source", "source_file_id", "source_path", "source_locator", "source_kind", "evidence_tier", "truth_mode", "state"];
 export type StandardEvidenceFrontmatterKey = typeof STANDARD_EVIDENCE_FRONTMATTER_KEYS[number];
 /**
- * Where an Artifact materializes. Discriminated union so future kinds
- * (literal value, remote handle, confirmation-only) slot in without a
- * schema break. `path` is always relative to the verifiable-context root,
- * and `artifact_kind` tells consumers whether the target materializes
- * as a file or directory.
+ * Where an Artifact materializes. `path` is always relative to the
+ * Context Graph root, and `artifact_kind` tells consumers whether the
+ * target materializes as a file or directory. The `kind: "path"`
+ * discriminator is retained on the wire so a future shape variant can be
+ * added as a discriminated union without renaming existing data.
  */
 export declare const ArtifactPathShapeSchema: z.ZodObject<{
     kind: z.ZodLiteral<"path">;
@@ -240,42 +1150,50 @@ export declare const ArtifactPathShapeSchema: z.ZodObject<{
         directory: "directory";
     }>;
 }, z.core.$strict>;
-export declare const ArtifactShapeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const ArtifactShapeSchema: z.ZodObject<{
     kind: z.ZodLiteral<"path">;
     path: z.ZodString;
     artifact_kind: z.ZodEnum<{
         file: "file";
         directory: "directory";
     }>;
-}, z.core.$strict>], "kind">;
+}, z.core.$strict>;
 export type ArtifactPathShape = z.infer<typeof ArtifactPathShapeSchema>;
-export type ArtifactShape = z.infer<typeof ArtifactShapeSchema>;
+export type ArtifactShape = ArtifactPathShape;
 /**
- * Build Plan-declared Artifact — a produced thing.
+ * Legacy internal requested-output schema.
  *
  * `checks[]` is the locked vocabulary: an array of `Check` (with
  * `kind` from `CHECK_KINDS`). The runtime evaluates them via the
- * shared check evaluator and produces `Proof[]` on each Build run.
+ * shared check evaluator and produces `CheckResult[]` on each Build.
  */
 export declare const ArtifactSchema: z.ZodObject<{
     id: z.ZodString;
     description: z.ZodString;
-    shape: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    shape: z.ZodObject<{
         kind: z.ZodLiteral<"path">;
         path: z.ZodString;
         artifact_kind: z.ZodEnum<{
             file: "file";
             directory: "directory";
         }>;
-    }, z.core.$strict>], "kind">;
+    }, z.core.$strict>;
     checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         kind: z.ZodEnum<{
             file_exists: "file_exists";
+            source_manifest_valid: "source_manifest_valid";
             min_file_count: "min_file_count";
             min_file_count_matches_source: "min_file_count_matches_source";
+            source_summary_folders: "source_summary_folders";
+            source_page_coverage: "source_page_coverage";
             frontmatter_valid: "frontmatter_valid";
             frontmatter_required_keys: "frontmatter_required_keys";
+            frontmatter_nonempty_keys: "frontmatter_nonempty_keys";
+            source_refs_required: "source_refs_required";
+            summary_backlinks_present: "summary_backlinks_present";
+            knowledge_web_connectivity: "knowledge_web_connectivity";
+            graph_notes_connected: "graph_notes_connected";
             wikilinks_valid: "wikilinks_valid";
             must_not_contain: "must_not_contain";
             must_contain: "must_contain";
@@ -289,34 +1207,42 @@ export declare const ArtifactSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type Artifact = z.infer<typeof ArtifactSchema>;
 /**
- * Per-Artifact runtime status. Lives on Build run resources and on
- * preparation resources. `proofs[]` carries the structured evidence
+ * Per-Artifact runtime status. Lives on Build resources and on
+ * Project resources. `check_results[]` carries the structured evidence
  * emitted by the shared check evaluator.
  */
 export declare const ArtifactStatusValueSchema: z.ZodEnum<{
     ready: "ready";
-    not_ready: "not_ready";
     failed: "failed";
     skipped: "skipped";
+    not_ready: "not_ready";
 }>;
 export type ArtifactStatusValue = ReadyVerdict;
 export declare const ArtifactStatusSchema: z.ZodObject<{
     artifact_id: z.ZodString;
     status: z.ZodEnum<{
         ready: "ready";
-        not_ready: "not_ready";
         failed: "failed";
         skipped: "skipped";
+        not_ready: "not_ready";
     }>;
     built_by_stages: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    proofs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    check_results: z.ZodDefault<z.ZodArray<z.ZodObject<{
         check_id: z.ZodString;
         kind: z.ZodEnum<{
             file_exists: "file_exists";
+            source_manifest_valid: "source_manifest_valid";
             min_file_count: "min_file_count";
             min_file_count_matches_source: "min_file_count_matches_source";
+            source_summary_folders: "source_summary_folders";
+            source_page_coverage: "source_page_coverage";
             frontmatter_valid: "frontmatter_valid";
             frontmatter_required_keys: "frontmatter_required_keys";
+            frontmatter_nonempty_keys: "frontmatter_nonempty_keys";
+            source_refs_required: "source_refs_required";
+            summary_backlinks_present: "summary_backlinks_present";
+            knowledge_web_connectivity: "knowledge_web_connectivity";
+            graph_notes_connected: "graph_notes_connected";
             wikilinks_valid: "wikilinks_valid";
             must_not_contain: "must_not_contain";
             must_contain: "must_contain";
@@ -331,50 +1257,258 @@ export declare const ArtifactStatusSchema: z.ZodObject<{
     summary: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type ArtifactStatus = z.infer<typeof ArtifactStatusSchema>;
+export declare const BuildEvidenceIssueStateSchema: z.ZodEnum<{
+    pass: "pass";
+    fail: "fail";
+    missing: "missing";
+    review: "review";
+}>;
+export type BuildEvidenceIssueState = z.infer<typeof BuildEvidenceIssueStateSchema>;
+export declare const BuildEvidenceMetricSchema: z.ZodObject<{
+    observed: z.ZodNumber;
+    total: z.ZodOptional<z.ZodNumber>;
+    unit: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type BuildEvidenceMetric = z.infer<typeof BuildEvidenceMetricSchema>;
+export declare const BuildEvidenceRefSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        output: "output";
+        "source-inventory": "source-inventory";
+        "stage-record": "stage-record";
+        validator: "validator";
+        trace: "trace";
+        "stage-evidence": "stage-evidence";
+    }>;
+    label: z.ZodString;
+    ref: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    run_id: z.ZodOptional<z.ZodString>;
+    stage_id: z.ZodOptional<z.ZodString>;
+    artifact_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type BuildEvidenceRef = z.infer<typeof BuildEvidenceRefSchema>;
+export declare const BuildCheckRowSchema: z.ZodObject<{
+    id: z.ZodString;
+    assertion: z.ZodString;
+    metric: z.ZodObject<{
+        observed: z.ZodNumber;
+        total: z.ZodOptional<z.ZodNumber>;
+        unit: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    evidence: z.ZodObject<{
+        kind: z.ZodEnum<{
+            output: "output";
+            "source-inventory": "source-inventory";
+            "stage-record": "stage-record";
+            validator: "validator";
+            trace: "trace";
+            "stage-evidence": "stage-evidence";
+        }>;
+        label: z.ZodString;
+        ref: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+        run_id: z.ZodOptional<z.ZodString>;
+        stage_id: z.ZodOptional<z.ZodString>;
+        artifact_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    issue_state: z.ZodOptional<z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        missing: "missing";
+        review: "review";
+    }>>;
+    issue: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type BuildCheckRow = z.infer<typeof BuildCheckRowSchema>;
+export declare const BuildEvidenceResourceSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-build-evidence">;
+    version: z.ZodLiteral<1>;
+    generated_at: z.ZodString;
+    project_id: z.ZodString;
+    build_run_id: z.ZodNullable<z.ZodString>;
+    ready: z.ZodBoolean;
+    summary: z.ZodString;
+    rows: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        assertion: z.ZodString;
+        metric: z.ZodObject<{
+            observed: z.ZodNumber;
+            total: z.ZodOptional<z.ZodNumber>;
+            unit: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        evidence: z.ZodObject<{
+            kind: z.ZodEnum<{
+                output: "output";
+                "source-inventory": "source-inventory";
+                "stage-record": "stage-record";
+                validator: "validator";
+                trace: "trace";
+                "stage-evidence": "stage-evidence";
+            }>;
+            label: z.ZodString;
+            ref: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.ZodString>;
+            stage_id: z.ZodOptional<z.ZodString>;
+            artifact_id: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        issue_state: z.ZodOptional<z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            missing: "missing";
+            review: "review";
+        }>>;
+        issue: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type BuildEvidenceResource = z.infer<typeof BuildEvidenceResourceSchema>;
+export declare const EvidenceCountKeySchema: z.ZodString;
+export declare const StageEvidenceSourceRefSchema: z.ZodObject<{
+    path: z.ZodString;
+    source_file_id: z.ZodOptional<z.ZodString>;
+    locator: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type StageEvidenceSourceRef = z.infer<typeof StageEvidenceSourceRefSchema>;
+export declare const StageEvidenceOutputRefSchema: z.ZodObject<{
+    artifact_id: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strict>;
+export type StageEvidenceOutputRef = z.infer<typeof StageEvidenceOutputRefSchema>;
+export declare const StageEvidenceCountSchema: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    value: z.ZodNumber;
+    total: z.ZodOptional<z.ZodNumber>;
+    unit: z.ZodOptional<z.ZodString>;
+    source: z.ZodEnum<{
+        stage: "stage";
+        engine: "engine";
+    }>;
+    stage_id: z.ZodOptional<z.ZodString>;
+    artifact_id: z.ZodOptional<z.ZodString>;
+    primary: z.ZodOptional<z.ZodBoolean>;
+    expected: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type StageEvidenceCount = z.infer<typeof StageEvidenceCountSchema>;
+export declare const StageEvidenceItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodString;
+    label: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    source_refs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        source_file_id: z.ZodOptional<z.ZodString>;
+        locator: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    output_refs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        artifact_id: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strict>>>;
+    stage_id: z.ZodString;
+    artifact_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type StageEvidenceItem = z.infer<typeof StageEvidenceItemSchema>;
+export declare const StageEvidenceEdgeSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    relation: z.ZodString;
+    stage_id: z.ZodString;
+}, z.core.$strict>;
+export type StageEvidenceEdge = z.infer<typeof StageEvidenceEdgeSchema>;
+export declare const StageEvidenceSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-stage-evidence">;
+    version: z.ZodLiteral<1>;
+    run_id: z.ZodString;
+    stage: z.ZodString;
+    counts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        value: z.ZodNumber;
+        total: z.ZodOptional<z.ZodNumber>;
+        unit: z.ZodOptional<z.ZodString>;
+        source: z.ZodEnum<{
+            stage: "stage";
+            engine: "engine";
+        }>;
+        stage_id: z.ZodOptional<z.ZodString>;
+        artifact_id: z.ZodOptional<z.ZodString>;
+        primary: z.ZodOptional<z.ZodBoolean>;
+        expected: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+    items: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodString;
+        label: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        source_refs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            source_file_id: z.ZodOptional<z.ZodString>;
+            locator: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        output_refs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            artifact_id: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strict>>>;
+        stage_id: z.ZodString;
+        artifact_id: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
+    edges: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        relation: z.ZodString;
+        stage_id: z.ZodString;
+    }, z.core.$strict>>>;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type StageEvidence = z.infer<typeof StageEvidenceSchema>;
 export declare const ReadinessStatusSchema: z.ZodEnum<{
     ready: "ready";
+    "not-ready": "not-ready";
     failed: "failed";
     "not-configured": "not-configured";
     "not-built": "not-built";
     building: "building";
     built: "built";
     checking: "checking";
-    "not-ready": "not-ready";
     stale: "stale";
 }>;
 export declare const ReadinessGateSchema: z.ZodEnum<{
-    "verifiable-context": "verifiable-context";
-    "preparation-config": "preparation-config";
+    "context-graph": "context-graph";
+    "project-config": "project-config";
     "build-run": "build-run";
-    "artifact-checks": "artifact-checks";
-    "readiness-checks": "readiness-checks";
-    "checks-current": "checks-current";
+    "artifact-diagnostics": "artifact-diagnostics";
+    "context-checks": "context-checks";
+    benchmarks: "benchmarks";
+    "benchmarks-current": "benchmarks-current";
 }>;
 /**
  * Per-gate status — one row in the readiness summary. A gate is a
- * high-level layer (is config valid? is verifiable context built? did
- * latest Build run succeed?). Gate failures are aggregated alongside
- * artifact-check failures into the overall `Readiness` verdict.
+ * high-level layer (is config valid? is the Context Graph built? did
+ * the latest Build succeed?). Gate failures are aggregated alongside
+ * output diagnostic failures into the overall `Readiness` verdict.
  */
 export declare const GateStatusSchema: z.ZodObject<{
     gate: z.ZodEnum<{
-        "verifiable-context": "verifiable-context";
-        "preparation-config": "preparation-config";
+        "context-graph": "context-graph";
+        "project-config": "project-config";
         "build-run": "build-run";
-        "artifact-checks": "artifact-checks";
-        "readiness-checks": "readiness-checks";
-        "checks-current": "checks-current";
+        "artifact-diagnostics": "artifact-diagnostics";
+        "context-checks": "context-checks";
+        benchmarks: "benchmarks";
+        "benchmarks-current": "benchmarks-current";
     }>;
     ok: z.ZodBoolean;
     status: z.ZodOptional<z.ZodEnum<{
         ready: "ready";
+        "not-ready": "not-ready";
         failed: "failed";
         "not-configured": "not-configured";
         "not-built": "not-built";
         building: "building";
         built: "built";
         checking: "checking";
-        "not-ready": "not-ready";
         stale: "stale";
     }>>;
     summary: z.ZodString;
@@ -391,46 +1525,50 @@ export declare const VerifyTargetResultSchema: z.ZodObject<{
     run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strict>;
-export declare const ReadinessSchema: z.ZodPreprocess<z.ZodObject<{
+/**
+ * Project-level readiness verdict.
+ */
+export declare const ReadinessSchema: z.ZodObject<{
     kind: z.ZodLiteral<"interf-readiness-state">;
     version: z.ZodLiteral<1>;
     generated_at: z.ZodString;
-    preparation: z.ZodString;
+    project: z.ZodString;
     status: z.ZodEnum<{
         ready: "ready";
+        "not-ready": "not-ready";
         failed: "failed";
         "not-configured": "not-configured";
         "not-built": "not-built";
         building: "building";
         built: "built";
         checking: "checking";
-        "not-ready": "not-ready";
         stale: "stale";
     }>;
     ready: z.ZodBoolean;
     summary: z.ZodString;
-    verifiable_context_path: z.ZodNullable<z.ZodString>;
+    context_graph_path: z.ZodNullable<z.ZodString>;
     latest_build_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    latest_test_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    latest_benchmark_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     build: z.ZodNullable<z.ZodObject<{
         gate: z.ZodEnum<{
-            "verifiable-context": "verifiable-context";
-            "preparation-config": "preparation-config";
+            "context-graph": "context-graph";
+            "project-config": "project-config";
             "build-run": "build-run";
-            "artifact-checks": "artifact-checks";
-            "readiness-checks": "readiness-checks";
-            "checks-current": "checks-current";
+            "artifact-diagnostics": "artifact-diagnostics";
+            "context-checks": "context-checks";
+            benchmarks: "benchmarks";
+            "benchmarks-current": "benchmarks-current";
         }>;
         ok: z.ZodBoolean;
         status: z.ZodOptional<z.ZodEnum<{
             ready: "ready";
+            "not-ready": "not-ready";
             failed: "failed";
             "not-configured": "not-configured";
             "not-built": "not-built";
             building: "building";
             built: "built";
             checking: "checking";
-            "not-ready": "not-ready";
             stale: "stale";
         }>>;
         summary: z.ZodString;
@@ -450,7 +1588,7 @@ export declare const ReadinessSchema: z.ZodPreprocess<z.ZodObject<{
             run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         }, z.core.$strict>>;
-        verifiable_context: z.ZodNullable<z.ZodObject<{
+        context_graph: z.ZodNullable<z.ZodObject<{
             passed: z.ZodNumber;
             total: z.ZodNumber;
             pass_rate: z.ZodNullable<z.ZodNumber>;
@@ -462,23 +1600,24 @@ export declare const ReadinessSchema: z.ZodPreprocess<z.ZodObject<{
     }, z.core.$strict>;
     checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
         gate: z.ZodEnum<{
-            "verifiable-context": "verifiable-context";
-            "preparation-config": "preparation-config";
+            "context-graph": "context-graph";
+            "project-config": "project-config";
             "build-run": "build-run";
-            "artifact-checks": "artifact-checks";
-            "readiness-checks": "readiness-checks";
-            "checks-current": "checks-current";
+            "artifact-diagnostics": "artifact-diagnostics";
+            "context-checks": "context-checks";
+            benchmarks: "benchmarks";
+            "benchmarks-current": "benchmarks-current";
         }>;
         ok: z.ZodBoolean;
         status: z.ZodOptional<z.ZodEnum<{
             ready: "ready";
+            "not-ready": "not-ready";
             failed: "failed";
             "not-configured": "not-configured";
             "not-built": "not-built";
             building: "building";
             built: "built";
             checking: "checking";
-            "not-ready": "not-ready";
             stale: "stale";
         }>>;
         summary: z.ZodString;
@@ -486,7 +1625,7 @@ export declare const ReadinessSchema: z.ZodPreprocess<z.ZodObject<{
         run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         artifact_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strict>>>;
-}, z.core.$strict>>;
+}, z.core.$strict>;
 export declare const TestCaseExpectSchema: z.ZodObject<{
     must_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
     must_include_one_of: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
@@ -515,7 +1654,7 @@ export declare const RuntimeExecutorInfoSchema: z.ZodObject<{
 export declare const CANONICAL_ROLES: readonly ["extractor", "summarizer", "structurer", "verifier", "general"];
 export type CanonicalRole = typeof CANONICAL_ROLES[number];
 /**
- * Open-ended role identifier. Build Plans invent role names freely; the
+ * Open-ended role identifier. Plans invent role names freely; the
  * role-router maps unknown names to `general` at run time.
  */
 export declare const RoleSchema: z.ZodString;
@@ -523,7 +1662,19 @@ export declare const RoleSchema: z.ZodString;
  * One agent in the registry. `available` is a runtime-only flag — true
  * if the command's first token resolves on PATH. Stripped before
  * persistence.
+ *
+ * `prefs` carries the merged-at-runtime per-agent preferences (env vars,
+ * model, effort). It is filled in at load time by looking up the
+ * registry's `agent_prefs` map by name. The persisted shape never carries
+ * `prefs` — it lives in `agent_prefs` on disk so built-in agents (which
+ * are detected, not persisted) can also receive preferences.
  */
+export declare const AgentPrefsSchema: z.ZodObject<{
+    env_vars: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    effort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type AgentPrefs = z.infer<typeof AgentPrefsSchema>;
 export declare const AgentRecordSchema: z.ZodObject<{
     name: z.ZodString;
     display_name: z.ZodString;
@@ -533,10 +1684,21 @@ export declare const AgentRecordSchema: z.ZodObject<{
         user: "user";
     }>;
     available: z.ZodOptional<z.ZodBoolean>;
+    prefs: z.ZodOptional<z.ZodObject<{
+        env_vars: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        effort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type AgentRecord = z.infer<typeof AgentRecordSchema>;
 export declare const RoleMapSchema: z.ZodRecord<z.ZodString, z.ZodString>;
 export type RoleMap = z.infer<typeof RoleMapSchema>;
+export declare const AgentPrefsMapSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    env_vars: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    effort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>>;
+export type AgentPrefsMap = z.infer<typeof AgentPrefsMapSchema>;
 export declare const AgentsRegistrySchema: z.ZodObject<{
     agents: z.ZodDefault<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -547,24 +1709,54 @@ export declare const AgentsRegistrySchema: z.ZodObject<{
             user: "user";
         }>;
         available: z.ZodOptional<z.ZodBoolean>;
+        prefs: z.ZodOptional<z.ZodObject<{
+            env_vars: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            effort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>>;
     role_map: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    agent_prefs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        env_vars: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        effort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>>;
 }, z.core.$strict>;
 export type AgentsRegistry = z.infer<typeof AgentsRegistrySchema>;
-export type PreparationName = z.infer<typeof PreparationNameSchema>;
+export type ProjectId = z.infer<typeof ProjectIdSchema>;
 export type BuildPlanId = z.infer<typeof BuildPlanIdSchema>;
+export type ProjectIntent = z.infer<typeof ProjectIntentSchema>;
 export type ArtifactId = z.infer<typeof ArtifactIdSchema>;
 export type RuntimeStage = z.infer<typeof RuntimeStageSchema>;
 export type RuntimeContractType = z.infer<typeof RuntimeContractTypeSchema>;
 export type RuntimeTargetType = z.infer<typeof RuntimeTargetTypeSchema>;
 export type TestTargetType = z.infer<typeof TestTargetTypeSchema>;
 export type SourceKind = z.infer<typeof SourceKindSchema>;
+export type SourceBinding = z.infer<typeof SourceBindingSchema>;
 export type Source = z.infer<typeof SourceSchema>;
 export type SourceFile = z.infer<typeof SourceFileSchema>;
 export type SourceFiles = z.infer<typeof SourceFilesSchema>;
-export type SourceSnapshot = z.infer<typeof SourceSnapshotSchema>;
+export type SourceState = z.infer<typeof SourceStateSchema>;
+export type SourceInspectableUnit = z.infer<typeof SourceInspectableUnitSchema>;
+export type SourceManifestEvidence = z.infer<typeof SourceManifestEvidenceSchema>;
+export type SourceManifestFileKind = z.infer<typeof SourceManifestFileKindSchema>;
+export type SourceManifestFile = z.infer<typeof SourceManifestFileSchema>;
+export type SourceManifestScanner = z.infer<typeof SourceManifestScannerSchema>;
+export type SourceManifest = z.infer<typeof SourceManifestSchema>;
+export type SourceManifestAudit = z.infer<typeof SourceManifestAuditSchema>;
 export type StageInput = z.infer<typeof StageInputSchema>;
 export type StageInputs = z.infer<typeof StageInputsSchema>;
+export type ResourceRole = z.infer<typeof ResourceRoleSchema>;
+export type ResourceRef = z.infer<typeof ResourceRefSchema>;
+export type MetricCount = z.infer<typeof MetricCountSchema>;
+export type ReviewedInputDecision = z.infer<typeof ReviewedInputDecisionSchema>;
+export type ReviewedInput = z.infer<typeof ReviewedInputSchema>;
+export type MissingInput = z.infer<typeof MissingInputSchema>;
+export type StageManifest = z.infer<typeof StageManifestSchema>;
+export type GraphManifestStageSummary = z.infer<typeof GraphManifestStageSummarySchema>;
+export type GraphReadinessRollup = z.infer<typeof GraphReadinessRollupSchema>;
+export type GraphOutputCounts = z.infer<typeof GraphOutputCountsSchema>;
+export type GraphManifest = z.infer<typeof GraphManifestSchema>;
 export type ReadinessStatus = z.infer<typeof ReadinessStatusSchema>;
 export type ReadinessGate = z.infer<typeof ReadinessGateSchema>;
 export type GateStatus = z.infer<typeof GateStatusSchema>;