@interf/compiler 0.22.0 → 0.33.0

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

@@ -1,7 +1,7 @@
 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`
@@ -12,11 +12,11 @@ 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 +44,11 @@ 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 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 +56,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 +66,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 +74,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,26 +95,234 @@ 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<{
+        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<{
+            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<{
+                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<{
+            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<{
+                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;
@@ -125,32 +331,153 @@ export declare const SourceBuildMaxLoopsSchema: z.ZodNumber;
  * 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
  *   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", "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";
     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 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 +487,22 @@ 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";
         wikilinks_valid: "wikilinks_valid";
         must_not_contain: "must_not_contain";
         must_contain: "must_contain";
@@ -186,14 +518,19 @@ 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";
         wikilinks_valid: "wikilinks_valid";
         must_not_contain: "must_not_contain";
         must_contain: "must_contain";
@@ -205,16 +542,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>;
+/**
+ * User-facing Build Plan check: the plain-English assertion the user
+ * reviews as a Context Check. Requested Artifacts back these checks.
+ * Deterministic Artifact diagnostics remain nested under Artifacts
+ * 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";
+    ready: "ready";
+    not_ready: "not_ready";
 }>;
 export type ReadyVerdict = z.infer<typeof ReadyVerdictSchema>;
 /**
@@ -223,14 +619,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 +636,47 @@ 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.
  *
  * `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";
             wikilinks_valid: "wikilinks_valid";
             must_not_contain: "must_not_contain";
             must_contain: "must_contain";
@@ -289,34 +690,39 @@ 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";
+    ready: "ready";
+    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";
+        ready: "ready";
+        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";
             wikilinks_valid: "wikilinks_valid";
             must_not_contain: "must_not_contain";
             must_contain: "must_contain";
@@ -331,9 +737,215 @@ 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";
     failed: "failed";
+    ready: "ready";
     "not-configured": "not-configured";
     "not-built": "not-built";
     building: "building";
@@ -343,32 +955,34 @@ export declare const ReadinessStatusSchema: z.ZodEnum<{
     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
+ * Artifact 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";
         failed: "failed";
+        ready: "ready";
         "not-configured": "not-configured";
         "not-built": "not-built";
         building: "building";
@@ -391,14 +1005,17 @@ 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";
         failed: "failed";
+        ready: "ready";
         "not-configured": "not-configured";
         "not-built": "not-built";
         building: "building";
@@ -409,22 +1026,23 @@ export declare const ReadinessSchema: z.ZodPreprocess<z.ZodObject<{
     }>;
     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";
             failed: "failed";
+            ready: "ready";
             "not-configured": "not-configured";
             "not-built": "not-built";
             building: "building";
@@ -450,7 +1068,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,17 +1080,18 @@ 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";
             failed: "failed";
+            ready: "ready";
             "not-configured": "not-configured";
             "not-built": "not-built";
             building: "building";
@@ -486,7 +1105,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 +1134,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 +1142,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 +1164,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,11 +1189,21 @@ 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 ArtifactId = z.infer<typeof ArtifactIdSchema>;
 export type RuntimeStage = z.infer<typeof RuntimeStageSchema>;
@@ -562,7 +1214,14 @@ export type SourceKind = z.infer<typeof SourceKindSchema>;
 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 ReadinessStatus = z.infer<typeof ReadinessStatusSchema>;