@davesheffer/hunch 1.31.1 → 1.32.0

package/dist/core/types.d.ts

@@ -0,0 +1,1239 @@
+/**
+ * Core entity schema for the Project Hunch (DESIGN.md §3).
+ *
+ * Zod is the single source of truth: TypeScript types are inferred from the
+ * schemas, and the same schemas validate JSON on the write path and shape MCP
+ * tool inputs. Every record carries `provenance` so nothing is a blind assertion.
+ */
+import { z } from "zod";
+import { ProvenanceSchema, isCredentialFreeText, type Provenance } from "./provenance.js";
+import { type ActionReceipt, type Commitment, type DerivedState, type ExternalEntity, type StateRelationship } from "./stateRecords.js";
+export { ProvenanceSchema, isCredentialFreeText };
+export type { Provenance };
+export declare const ComponentKind: z.ZodEnum<{
+    external: "external";
+    service: "service";
+    module: "module";
+    layer: "layer";
+}>;
+/** Architecture node — a service / module / layer / external dependency. */
+export declare const ComponentSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        external: "external";
+        service: "service";
+        module: "module";
+        layer: "layer";
+    }>;
+    name: z.ZodString;
+    responsibility: z.ZodDefault<z.ZodString>;
+    paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    status: z.ZodDefault<z.ZodEnum<{
+        active: "active";
+        deprecated: "deprecated";
+        archived: "archived";
+    }>>;
+    owners: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    fragility: z.ZodDefault<z.ZodNumber>;
+    provenance: z.ZodObject<{
+        source: z.ZodString;
+        confidence: z.ZodNumber;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        last_verified: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>;
+export type Component = z.infer<typeof ComponentSchema>;
+export declare const RESOURCE_SCHEMA_VERSION: "hunch.resource/1";
+export declare const RESOURCE_RELATIONSHIP_SCHEMA_VERSION: "hunch.resource-relationship/1";
+/** Resource kinds are deliberately extensible: the initial vocabulary is
+ * documented, while repositories may add a stable snake_case kind without a
+ * schema release. */
+export declare const ResourceKindSchema: z.ZodString;
+export declare const ResourceCurrentnessSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        current: "current";
+        stale: "stale";
+        unverified: "unverified";
+    }>;
+    verified_at: z.ZodOptional<z.ZodString>;
+    source_revision: z.ZodOptional<z.ZodString>;
+    source_content_hash: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ResourceCurrentness = z.infer<typeof ResourceCurrentnessSchema>;
+export declare const ResourceMetadataSchema: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>;
+export type ResourceMetadata = z.infer<typeof ResourceMetadataSchema>;
+/** Durable Engineering Landscape node. Runtime health/readiness intentionally has
+ * no field here: those expiring observations belong to ORC. */
+export declare const ResourceSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"hunch.resource/1">;
+    id: z.ZodString;
+    kind: z.ZodString;
+    name: z.ZodString;
+    scope: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    locator: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    lifecycle: z.ZodDefault<z.ZodEnum<{
+        active: "active";
+        deprecated: "deprecated";
+        retired: "retired";
+        planned: "planned";
+    }>>;
+    criticality: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        critical: "critical";
+    }>>;
+    contract_version: z.ZodOptional<z.ZodString>;
+    provenance: z.ZodObject<{
+        source: z.ZodString;
+        confidence: z.ZodNumber;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        last_verified: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    currentness: z.ZodObject<{
+        status: z.ZodEnum<{
+            current: "current";
+            stale: "stale";
+            unverified: "unverified";
+        }>;
+        verified_at: z.ZodOptional<z.ZodString>;
+        source_revision: z.ZodOptional<z.ZodString>;
+        source_content_hash: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strict>;
+export type Resource = z.infer<typeof ResourceSchema>;
+export declare const EdgeType: z.ZodEnum<{
+    depends_on: "depends_on";
+    calls: "calls";
+    imports: "imports";
+    contains: "contains";
+    implements: "implements";
+    supersedes: "supersedes";
+    related_to: "related_to";
+    references: "references";
+    provides: "provides";
+    belongs_to: "belongs_to";
+    implemented_by: "implemented_by";
+    invokes: "invokes";
+    exposes: "exposes";
+    publishes: "publishes";
+    consumes: "consumes";
+    reads_from: "reads_from";
+    writes_to: "writes_to";
+    builds: "builds";
+    tests: "tests";
+    deploys: "deploys";
+    deployed_on: "deployed_on";
+    owned_by: "owned_by";
+    monitored_by: "monitored_by";
+    governed_by: "governed_by";
+    source_of_truth_for: "source_of_truth_for";
+    compatible_with: "compatible_with";
+    replaces: "replaces";
+}>;
+export declare const ResourceRelationshipType: z.ZodEnum<{
+    depends_on: "depends_on";
+    contains: "contains";
+    implements: "implements";
+    provides: "provides";
+    belongs_to: "belongs_to";
+    implemented_by: "implemented_by";
+    invokes: "invokes";
+    exposes: "exposes";
+    publishes: "publishes";
+    consumes: "consumes";
+    reads_from: "reads_from";
+    writes_to: "writes_to";
+    builds: "builds";
+    tests: "tests";
+    deploys: "deploys";
+    deployed_on: "deployed_on";
+    owned_by: "owned_by";
+    monitored_by: "monitored_by";
+    governed_by: "governed_by";
+    source_of_truth_for: "source_of_truth_for";
+    compatible_with: "compatible_with";
+    replaces: "replaces";
+}>;
+/** Typed relationship between components or symbols. */
+export declare const EdgeSchema: z.ZodObject<{
+    schema: z.ZodDefault<z.ZodEnum<{
+        "hunch.resource-relationship/1": "hunch.resource-relationship/1";
+        "hunch.edge/1": "hunch.edge/1";
+    }>>;
+    id: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodString;
+    type: z.ZodEnum<{
+        depends_on: "depends_on";
+        calls: "calls";
+        imports: "imports";
+        contains: "contains";
+        implements: "implements";
+        supersedes: "supersedes";
+        related_to: "related_to";
+        references: "references";
+        provides: "provides";
+        belongs_to: "belongs_to";
+        implemented_by: "implemented_by";
+        invokes: "invokes";
+        exposes: "exposes";
+        publishes: "publishes";
+        consumes: "consumes";
+        reads_from: "reads_from";
+        writes_to: "writes_to";
+        builds: "builds";
+        tests: "tests";
+        deploys: "deploys";
+        deployed_on: "deployed_on";
+        owned_by: "owned_by";
+        monitored_by: "monitored_by";
+        governed_by: "governed_by";
+        source_of_truth_for: "source_of_truth_for";
+        compatible_with: "compatible_with";
+        replaces: "replaces";
+    }>;
+    reason: z.ZodDefault<z.ZodString>;
+    strength: z.ZodDefault<z.ZodNumber>;
+    provenance: z.ZodObject<{
+        source: z.ZodString;
+        confidence: z.ZodNumber;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        last_verified: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    currentness: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            current: "current";
+            stale: "stale";
+            unverified: "unverified";
+        }>;
+        verified_at: z.ZodOptional<z.ZodString>;
+        source_revision: z.ZodOptional<z.ZodString>;
+        source_content_hash: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    environment: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    criticality: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        critical: "critical";
+    }>>;
+    contract_version: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>>;
+}, z.core.$strict>;
+export type Edge = z.infer<typeof EdgeSchema>;
+export declare const SymbolKind: z.ZodEnum<{
+    function: "function";
+    type: "type";
+    enum: "enum";
+    file: "file";
+    method: "method";
+    class: "class";
+    interface: "interface";
+    trait: "trait";
+    variable: "variable";
+}>;
+export declare const SymbolMetricsSchema: z.ZodObject<{
+    loc: z.ZodDefault<z.ZodNumber>;
+    churn_90d: z.ZodDefault<z.ZodNumber>;
+    bug_count: z.ZodDefault<z.ZodNumber>;
+    fan_in: z.ZodDefault<z.ZodNumber>;
+    fan_out: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type SymbolMetrics = z.infer<typeof SymbolMetricsSchema>;
+/** File/function-level node for the dependency map. */
+export declare const SymbolSchema: z.ZodObject<{
+    id: z.ZodString;
+    file: z.ZodString;
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        function: "function";
+        type: "type";
+        enum: "enum";
+        file: "file";
+        method: "method";
+        class: "class";
+        interface: "interface";
+        trait: "trait";
+        variable: "variable";
+    }>;
+    signature_hash: z.ZodDefault<z.ZodString>;
+    calls: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    called_by: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    metrics: z.ZodDefault<z.ZodObject<{
+        loc: z.ZodDefault<z.ZodNumber>;
+        churn_90d: z.ZodDefault<z.ZodNumber>;
+        bug_count: z.ZodDefault<z.ZodNumber>;
+        fan_in: z.ZodDefault<z.ZodNumber>;
+        fan_out: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    last_changed: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type Symbol = z.infer<typeof SymbolSchema>;
+/** The structural delta a decision's commit DELETED — the evidence the Regression
+ *  Guard matches a later diff against ("you're re-adding what dec_X removed"). */
+export declare const RetiredSignalSchema: z.ZodObject<{
+    symbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    deps: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type RetiredSignal = z.infer<typeof RetiredSignalSchema>;
+/** A machine-checkable signal for a REJECTED alternative (the Veto Guard). Unlike
+ *  `retired` (code that once existed and was removed), a rejected alternative never
+ *  existed in code, so its prose is turned into a testable set/regex. Carries its
+ *  OWN provenance, separate from the decision's: an LLM may DRAFT a tripwire
+ *  (advisory only); only a `human_confirmed` tripwire may BLOCK a commit — for every
+ *  tier. One predictable rule (dec_a466655539). */
+export declare const RejectedTripwireSchema: z.ZodObject<{
+    alternative: z.ZodString;
+    scope: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    forbids: z.ZodDefault<z.ZodObject<{
+        deps: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        symbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        patterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    embed_ref: z.ZodOptional<z.ZodString>;
+    provenance: z.ZodObject<{
+        source: z.ZodString;
+        confidence: z.ZodNumber;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        last_verified: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type RejectedTripwire = z.infer<typeof RejectedTripwireSchema>;
+/** ADR-style decision record, auto-drafted and human-confirmable. */
+/** Intent-conformance predicate (the "inversion": prove the code still SATISFIES a
+ *  decision's intent, not just that a diff didn't touch a guarded file). Each predicate
+ *  compiles a decision's intent into a DETERMINISTIC check over the symbol/dependency
+ *  graph Hunch already builds — no model. "pay must verify the session" becomes
+ *  { assert: "calls", subject: "pay", object: "verifySession" }; if pay stops calling
+ *  verifySession the intent is VIOLATED even with no diff in scope. */
+export declare const ConformancePredicateSchema: z.ZodObject<{
+    assert: z.ZodEnum<{
+        calls: "calls";
+        imports: "imports";
+        "not-calls": "not-calls";
+        "not-imports": "not-imports";
+        exists: "exists";
+    }>;
+    subject: z.ZodString;
+    object: z.ZodOptional<z.ZodString>;
+    transitive: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ConformancePredicate = z.infer<typeof ConformancePredicateSchema>;
+export declare const PremiseSchema: z.ZodObject<{
+    claim: z.ZodString;
+    path_absent: z.ZodOptional<z.ZodString>;
+    under: z.ZodOptional<z.ZodString>;
+    path_exists: z.ZodOptional<z.ZodString>;
+    review_by: z.ZodOptional<z.ZodString>;
+    attested: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type Premise = z.infer<typeof PremiseSchema>;
+export declare const DecisionSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    topic: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    status: z.ZodDefault<z.ZodEnum<{
+        proposed: "proposed";
+        accepted: "accepted";
+        rejected: "rejected";
+        superseded: "superseded";
+    }>>;
+    context: z.ZodDefault<z.ZodString>;
+    decision: z.ZodDefault<z.ZodString>;
+    consequences: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    alternatives_rejected: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    rejected_tripwires: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        alternative: z.ZodString;
+        scope: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        forbids: z.ZodDefault<z.ZodObject<{
+            deps: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            symbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            patterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        embed_ref: z.ZodOptional<z.ZodString>;
+        provenance: z.ZodObject<{
+            source: z.ZodString;
+            confidence: z.ZodNumber;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            last_verified: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    related_components: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    related_files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    supersedes: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    superseded_by: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    caused_by_bug: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    commit: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    valid_from: z.ZodOptional<z.ZodString>;
+    valid_to: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    retired: z.ZodDefault<z.ZodObject<{
+        symbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deps: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    conformance: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        assert: z.ZodEnum<{
+            calls: "calls";
+            imports: "imports";
+            "not-calls": "not-calls";
+            "not-imports": "not-imports";
+            exists: "exists";
+        }>;
+        subject: z.ZodString;
+        object: z.ZodOptional<z.ZodString>;
+        transitive: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    premises: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        claim: z.ZodString;
+        path_absent: z.ZodOptional<z.ZodString>;
+        under: z.ZodOptional<z.ZodString>;
+        path_exists: z.ZodOptional<z.ZodString>;
+        review_by: z.ZodOptional<z.ZodString>;
+        attested: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    provenance: z.ZodObject<{
+        source: z.ZodString;
+        confidence: z.ZodNumber;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        last_verified: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    date: z.ZodString;
+}, z.core.$strip>;
+export type Decision = z.infer<typeof DecisionSchema>;
+export declare const BugLineageSchema: z.ZodObject<{
+    introduced_commit: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    detected: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    fixed_commit: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    recurrence_of: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    spawned_decision: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    spawned_constraint: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type BugLineage = z.infer<typeof BugLineageSchema>;
+/** A bug with root cause and lineage (introduced → fixed → recurred). */
+export declare const BugSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    symptom: z.ZodDefault<z.ZodString>;
+    root_cause: z.ZodDefault<z.ZodString>;
+    severity: z.ZodDefault<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        critical: "critical";
+    }>>;
+    status: z.ZodDefault<z.ZodEnum<{
+        fixed: "fixed";
+        open: "open";
+        investigating: "investigating";
+        regressed: "regressed";
+    }>>;
+    affected_files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    affected_symbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    lineage: z.ZodDefault<z.ZodObject<{
+        introduced_commit: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        detected: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        fixed_commit: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        recurrence_of: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        spawned_decision: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        spawned_constraint: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    provenance: z.ZodObject<{
+        source: z.ZodString;
+        confidence: z.ZodNumber;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        last_verified: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type Bug = z.infer<typeof BugSchema>;
+/** An invariant the system must respect. */
+export declare const ConstraintSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodDefault<z.ZodEnum<{
+        security: "security";
+        performance: "performance";
+        correctness: "correctness";
+        architecture: "architecture";
+        compliance: "compliance";
+    }>>;
+    statement: z.ZodString;
+    scope: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    severity: z.ZodDefault<z.ZodEnum<{
+        advisory: "advisory";
+        warning: "warning";
+        blocking: "blocking";
+    }>>;
+    enforcement: z.ZodDefault<z.ZodEnum<{
+        ci: "ci";
+        advisory_v1: "advisory_v1";
+        manual: "manual";
+    }>>;
+    match: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    forbids: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        deps: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        symbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        patterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    rationale: z.ZodDefault<z.ZodString>;
+    source_decision: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    violations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    status: z.ZodDefault<z.ZodEnum<{
+        active: "active";
+        retired: "retired";
+    }>>;
+    valid_from: z.ZodOptional<z.ZodString>;
+    valid_to: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    provenance: z.ZodObject<{
+        source: z.ZodString;
+        confidence: z.ZodNumber;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        last_verified: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type Constraint = z.infer<typeof ConstraintSchema>;
+/** A reusable "how" for a recurring task — trajectory/runbook memory (roadmap #5).
+ *  ADVISORY retrieval context only; never enters any block path. Distilled from a
+ *  commit range, surfaced through the same FTS+graph retrieval as every record. */
+export declare const RunbookSchema: z.ZodObject<{
+    id: z.ZodString;
+    task: z.ZodString;
+    trigger: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    steps: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    gotchas: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    outcome: z.ZodDefault<z.ZodString>;
+    source_range: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    valid_from: z.ZodOptional<z.ZodString>;
+    valid_to: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    provenance: z.ZodObject<{
+        source: z.ZodString;
+        confidence: z.ZodNumber;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        last_verified: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    date: z.ZodString;
+}, z.core.$strip>;
+export type Runbook = z.infer<typeof RunbookSchema>;
+/** An OBSERVATION — audited knowledge with no diff (the anchor is a date + evidence,
+ *  not a commit). Fills the gap between Bug (broke and got fixed) and Decision (chose
+ *  and changed code): "we looked, we found, we haven't acted yet". Examples: an audit
+ *  that surfaced unscoped tenant queries, a measured perf number, a vendor limit, an
+ *  incident with no code fix. ADVISORY retrieval context (pre-edit grounding + MCP);
+ *  never enters any block path. Lifecycle is `triage`, not valid-time: a finding is
+ *  resolved/stale-marked, never superseded. */
+export declare const FindingSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    observation: z.ZodDefault<z.ZodString>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    method: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    severity: z.ZodDefault<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        critical: "critical";
+    }>>;
+    triage: z.ZodDefault<z.ZodEnum<{
+        open: "open";
+        stale: "stale";
+        "accepted-risk": "accepted-risk";
+        scheduled: "scheduled";
+        resolved: "resolved";
+    }>>;
+    affected_files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    affected_symbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    violates_constraint: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    spawned_decision: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    observed_at: z.ZodString;
+    resolved_commit: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    provenance: z.ZodObject<{
+        source: z.ZodString;
+        confidence: z.ZodNumber;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        last_verified: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type Finding = z.infer<typeof FindingSchema>;
+export declare const LANDSCAPE_DRIFT_CANDIDATE_SCHEMA_VERSION: "hunch.landscape-drift-candidate/1";
+/**
+ * An external observer's content-addressed mismatch claim. It is intake evidence
+ * for an advisory Finding only: it cannot update a Resource, relationship,
+ * currentness, decision, constraint, or execution policy.
+ */
+export declare const LandscapeDriftCandidateSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"hunch.landscape-drift-candidate/1">;
+    candidateId: z.ZodString;
+    classification: z.ZodLiteral<"repository_identity_mismatch">;
+    resourceId: z.ZodString;
+    declaredRepositoryId: z.ZodString;
+    observedRepositoryId: z.ZodString;
+    observation: z.ZodObject<{
+        providerId: z.ZodString;
+        observedAt: z.ZodString;
+        providerReceiptId: z.ZodString;
+        providerReceiptHash: z.ZodString;
+        resolutionReceiptId: z.ZodString;
+        resolutionReceiptHash: z.ZodString;
+        resolutionSetHash: z.ZodString;
+    }, z.core.$strict>;
+    authority: z.ZodLiteral<"finding_candidate">;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type LandscapeDriftCandidate = z.infer<typeof LandscapeDriftCandidateSchema>;
+export type CreateLandscapeDriftCandidateInput = Omit<LandscapeDriftCandidate, "schema" | "candidateId" | "classification" | "authority" | "contentHash">;
+export declare function createLandscapeDriftCandidate(input: CreateLandscapeDriftCandidateInput): LandscapeDriftCandidate;
+export declare function assertLandscapeDriftCandidate(value: unknown): asserts value is LandscapeDriftCandidate;
+/** Convert one valid external observation into advisory Hunch memory, never graph authority. */
+export declare function landscapeDriftCandidateFinding(value: unknown): Finding;
+/** The entity collections, keyed by their on-disk directory name. */
+export declare const ENTITY_KINDS: readonly ["components", "resources", "edges", "symbols", "decisions", "bugs", "constraints", "runbooks", "findings", "receipts", "commitments", "derived", "entities", "relationships"];
+export type EntityKind = (typeof ENTITY_KINDS)[number];
+export declare const SCHEMAS: {
+    readonly components: z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            external: "external";
+            service: "service";
+            module: "module";
+            layer: "layer";
+        }>;
+        name: z.ZodString;
+        responsibility: z.ZodDefault<z.ZodString>;
+        paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        status: z.ZodDefault<z.ZodEnum<{
+            active: "active";
+            deprecated: "deprecated";
+            archived: "archived";
+        }>>;
+        owners: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        fragility: z.ZodDefault<z.ZodNumber>;
+        provenance: z.ZodObject<{
+            source: z.ZodString;
+            confidence: z.ZodNumber;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            last_verified: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+    }, z.core.$strip>;
+    readonly resources: z.ZodObject<{
+        schema: z.ZodLiteral<"hunch.resource/1">;
+        id: z.ZodString;
+        kind: z.ZodString;
+        name: z.ZodString;
+        scope: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        locator: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        lifecycle: z.ZodDefault<z.ZodEnum<{
+            active: "active";
+            deprecated: "deprecated";
+            retired: "retired";
+            planned: "planned";
+        }>>;
+        criticality: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            critical: "critical";
+        }>>;
+        contract_version: z.ZodOptional<z.ZodString>;
+        provenance: z.ZodObject<{
+            source: z.ZodString;
+            confidence: z.ZodNumber;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            last_verified: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        currentness: z.ZodObject<{
+            status: z.ZodEnum<{
+                current: "current";
+                stale: "stale";
+                unverified: "unverified";
+            }>;
+            verified_at: z.ZodOptional<z.ZodString>;
+            source_revision: z.ZodOptional<z.ZodString>;
+            source_content_hash: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>>;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+    }, z.core.$strict>;
+    readonly edges: z.ZodObject<{
+        schema: z.ZodDefault<z.ZodEnum<{
+            "hunch.resource-relationship/1": "hunch.resource-relationship/1";
+            "hunch.edge/1": "hunch.edge/1";
+        }>>;
+        id: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+        type: z.ZodEnum<{
+            depends_on: "depends_on";
+            calls: "calls";
+            imports: "imports";
+            contains: "contains";
+            implements: "implements";
+            supersedes: "supersedes";
+            related_to: "related_to";
+            references: "references";
+            provides: "provides";
+            belongs_to: "belongs_to";
+            implemented_by: "implemented_by";
+            invokes: "invokes";
+            exposes: "exposes";
+            publishes: "publishes";
+            consumes: "consumes";
+            reads_from: "reads_from";
+            writes_to: "writes_to";
+            builds: "builds";
+            tests: "tests";
+            deploys: "deploys";
+            deployed_on: "deployed_on";
+            owned_by: "owned_by";
+            monitored_by: "monitored_by";
+            governed_by: "governed_by";
+            source_of_truth_for: "source_of_truth_for";
+            compatible_with: "compatible_with";
+            replaces: "replaces";
+        }>;
+        reason: z.ZodDefault<z.ZodString>;
+        strength: z.ZodDefault<z.ZodNumber>;
+        provenance: z.ZodObject<{
+            source: z.ZodString;
+            confidence: z.ZodNumber;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            last_verified: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        currentness: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                current: "current";
+                stale: "stale";
+                unverified: "unverified";
+            }>;
+            verified_at: z.ZodOptional<z.ZodString>;
+            source_revision: z.ZodOptional<z.ZodString>;
+            source_content_hash: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        environment: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        criticality: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            critical: "critical";
+        }>>;
+        contract_version: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>>;
+    }, z.core.$strict>;
+    readonly symbols: z.ZodObject<{
+        id: z.ZodString;
+        file: z.ZodString;
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            function: "function";
+            type: "type";
+            enum: "enum";
+            file: "file";
+            method: "method";
+            class: "class";
+            interface: "interface";
+            trait: "trait";
+            variable: "variable";
+        }>;
+        signature_hash: z.ZodDefault<z.ZodString>;
+        calls: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        called_by: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        metrics: z.ZodDefault<z.ZodObject<{
+            loc: z.ZodDefault<z.ZodNumber>;
+            churn_90d: z.ZodDefault<z.ZodNumber>;
+            bug_count: z.ZodDefault<z.ZodNumber>;
+            fan_in: z.ZodDefault<z.ZodNumber>;
+            fan_out: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        last_changed: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    readonly decisions: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        topic: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        status: z.ZodDefault<z.ZodEnum<{
+            proposed: "proposed";
+            accepted: "accepted";
+            rejected: "rejected";
+            superseded: "superseded";
+        }>>;
+        context: z.ZodDefault<z.ZodString>;
+        decision: z.ZodDefault<z.ZodString>;
+        consequences: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        alternatives_rejected: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        rejected_tripwires: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            alternative: z.ZodString;
+            scope: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            forbids: z.ZodDefault<z.ZodObject<{
+                deps: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                symbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                patterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            embed_ref: z.ZodOptional<z.ZodString>;
+            provenance: z.ZodObject<{
+                source: z.ZodString;
+                confidence: z.ZodNumber;
+                evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                last_verified: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>>;
+        related_components: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        related_files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        supersedes: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        superseded_by: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        caused_by_bug: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        commit: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        valid_from: z.ZodOptional<z.ZodString>;
+        valid_to: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        retired: z.ZodDefault<z.ZodObject<{
+            symbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            deps: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        conformance: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            assert: z.ZodEnum<{
+                calls: "calls";
+                imports: "imports";
+                "not-calls": "not-calls";
+                "not-imports": "not-imports";
+                exists: "exists";
+            }>;
+            subject: z.ZodString;
+            object: z.ZodOptional<z.ZodString>;
+            transitive: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        premises: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            claim: z.ZodString;
+            path_absent: z.ZodOptional<z.ZodString>;
+            under: z.ZodOptional<z.ZodString>;
+            path_exists: z.ZodOptional<z.ZodString>;
+            review_by: z.ZodOptional<z.ZodString>;
+            attested: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        provenance: z.ZodObject<{
+            source: z.ZodString;
+            confidence: z.ZodNumber;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            last_verified: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        date: z.ZodString;
+    }, z.core.$strip>;
+    readonly bugs: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        symptom: z.ZodDefault<z.ZodString>;
+        root_cause: z.ZodDefault<z.ZodString>;
+        severity: z.ZodDefault<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            critical: "critical";
+        }>>;
+        status: z.ZodDefault<z.ZodEnum<{
+            fixed: "fixed";
+            open: "open";
+            investigating: "investigating";
+            regressed: "regressed";
+        }>>;
+        affected_files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        affected_symbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        lineage: z.ZodDefault<z.ZodObject<{
+            introduced_commit: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            detected: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            fixed_commit: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            recurrence_of: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            spawned_decision: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            spawned_constraint: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+        provenance: z.ZodObject<{
+            source: z.ZodString;
+            confidence: z.ZodNumber;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            last_verified: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    readonly constraints: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodDefault<z.ZodEnum<{
+            security: "security";
+            performance: "performance";
+            correctness: "correctness";
+            architecture: "architecture";
+            compliance: "compliance";
+        }>>;
+        statement: z.ZodString;
+        scope: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        severity: z.ZodDefault<z.ZodEnum<{
+            advisory: "advisory";
+            warning: "warning";
+            blocking: "blocking";
+        }>>;
+        enforcement: z.ZodDefault<z.ZodEnum<{
+            ci: "ci";
+            advisory_v1: "advisory_v1";
+            manual: "manual";
+        }>>;
+        match: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        forbids: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            deps: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            symbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            patterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        rationale: z.ZodDefault<z.ZodString>;
+        source_decision: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        violations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        status: z.ZodDefault<z.ZodEnum<{
+            active: "active";
+            retired: "retired";
+        }>>;
+        valid_from: z.ZodOptional<z.ZodString>;
+        valid_to: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        provenance: z.ZodObject<{
+            source: z.ZodString;
+            confidence: z.ZodNumber;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            last_verified: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    readonly runbooks: z.ZodObject<{
+        id: z.ZodString;
+        task: z.ZodString;
+        trigger: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        steps: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        gotchas: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        outcome: z.ZodDefault<z.ZodString>;
+        source_range: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        valid_from: z.ZodOptional<z.ZodString>;
+        valid_to: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        provenance: z.ZodObject<{
+            source: z.ZodString;
+            confidence: z.ZodNumber;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            last_verified: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        date: z.ZodString;
+    }, z.core.$strip>;
+    readonly findings: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        observation: z.ZodDefault<z.ZodString>;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        method: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        severity: z.ZodDefault<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            critical: "critical";
+        }>>;
+        triage: z.ZodDefault<z.ZodEnum<{
+            open: "open";
+            stale: "stale";
+            "accepted-risk": "accepted-risk";
+            scheduled: "scheduled";
+            resolved: "resolved";
+        }>>;
+        affected_files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        affected_symbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        violates_constraint: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        spawned_decision: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        observed_at: z.ZodString;
+        resolved_commit: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        provenance: z.ZodObject<{
+            source: z.ZodString;
+            confidence: z.ZodNumber;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            last_verified: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    readonly receipts: z.ZodObject<{
+        schema: z.ZodLiteral<"nuryel.receipt/1">;
+        id: z.ZodString;
+        scope: z.ZodObject<{
+            kind: z.ZodEnum<{
+                repository: "repository";
+                organization: "organization";
+                team: "team";
+                user: "user";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+        actor: z.ZodString;
+        action_kind: z.ZodString;
+        target: z.ZodObject<{
+            system: z.ZodString;
+            object_type: z.ZodString;
+            object_key: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            content_hash: z.ZodOptional<z.ZodString>;
+            observed_at: z.ZodString;
+            locator: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        request_fingerprint: z.ZodString;
+        idempotency_key: z.ZodOptional<z.ZodString>;
+        state: z.ZodEnum<{
+            unknown: "unknown";
+            requested: "requested";
+            succeeded: "succeeded";
+            failed: "failed";
+            verified: "verified";
+        }>;
+        occurred_at: z.ZodString;
+        verified_at: z.ZodOptional<z.ZodString>;
+        result_fingerprint: z.ZodOptional<z.ZodString>;
+        invalidates: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        rests_on: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"record">;
+            id: z.ZodString;
+            record_hash: z.ZodString;
+            scope: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    repository: "repository";
+                    organization: "organization";
+                    team: "team";
+                    user: "user";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"external">;
+            ref: z.ZodObject<{
+                system: z.ZodString;
+                object_type: z.ZodString;
+                object_key: z.ZodString;
+                version: z.ZodOptional<z.ZodString>;
+                content_hash: z.ZodOptional<z.ZodString>;
+                observed_at: z.ZodString;
+                locator: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"schema">;
+            name: z.ZodString;
+            fingerprint: z.ZodString;
+        }, z.core.$strict>], "kind">>>;
+        provenance: z.ZodObject<{
+            source: z.ZodString;
+            confidence: z.ZodNumber;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            last_verified: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strict>;
+    readonly commitments: z.ZodObject<{
+        schema: z.ZodLiteral<"nuryel.commitment/1">;
+        id: z.ZodString;
+        scope: z.ZodObject<{
+            kind: z.ZodEnum<{
+                repository: "repository";
+                organization: "organization";
+                team: "team";
+                user: "user";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+        subject: z.ZodString;
+        title: z.ZodString;
+        owner: z.ZodString;
+        due: z.ZodString;
+        status: z.ZodEnum<{
+            open: "open";
+            waiting: "waiting";
+            done: "done";
+            cancelled: "cancelled";
+        }>;
+        source: z.ZodOptional<z.ZodObject<{
+            system: z.ZodString;
+            object_type: z.ZodString;
+            object_key: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            content_hash: z.ZodOptional<z.ZodString>;
+            observed_at: z.ZodString;
+            locator: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        evidence_excerpt: z.ZodOptional<z.ZodString>;
+        closed_by: z.ZodOptional<z.ZodString>;
+        valid_from: z.ZodString;
+        valid_to: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        provenance: z.ZodObject<{
+            source: z.ZodString;
+            confidence: z.ZodNumber;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            last_verified: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strict>;
+    readonly derived: z.ZodObject<{
+        schema: z.ZodLiteral<"nuryel.derived/1">;
+        id: z.ZodString;
+        scope: z.ZodObject<{
+            kind: z.ZodEnum<{
+                repository: "repository";
+                organization: "organization";
+                team: "team";
+                user: "user";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+        subject: z.ZodString;
+        content: z.ZodString;
+        content_hash: z.ZodString;
+        dependencies: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"record">;
+            id: z.ZodString;
+            record_hash: z.ZodString;
+            scope: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    repository: "repository";
+                    organization: "organization";
+                    team: "team";
+                    user: "user";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"external">;
+            ref: z.ZodObject<{
+                system: z.ZodString;
+                object_type: z.ZodString;
+                object_key: z.ZodString;
+                version: z.ZodOptional<z.ZodString>;
+                content_hash: z.ZodOptional<z.ZodString>;
+                observed_at: z.ZodString;
+                locator: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"schema">;
+            name: z.ZodString;
+            fingerprint: z.ZodString;
+        }, z.core.$strict>], "kind">>;
+        transform_version: z.ZodString;
+        computed_at: z.ZodString;
+        valid_to: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        state: z.ZodEnum<{
+            unknown: "unknown";
+            current: "current";
+            stale: "stale";
+        }>;
+        review: z.ZodOptional<z.ZodObject<{
+            by: z.ZodString;
+            at: z.ZodString;
+            previous_hash: z.ZodString;
+            reason: z.ZodString;
+            evidence: z.ZodArray<z.ZodObject<{
+                ref: z.ZodObject<{
+                    system: z.ZodString;
+                    object_type: z.ZodString;
+                    object_key: z.ZodString;
+                    version: z.ZodOptional<z.ZodString>;
+                    content_hash: z.ZodOptional<z.ZodString>;
+                    observed_at: z.ZodString;
+                    locator: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>;
+                excerpt: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        provenance: z.ZodObject<{
+            source: z.ZodString;
+            confidence: z.ZodNumber;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            last_verified: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strict>;
+    readonly entities: z.ZodObject<{
+        schema: z.ZodLiteral<"nuryel.entity/1">;
+        id: z.ZodString;
+        kind: z.ZodString;
+        name: z.ZodString;
+        scope: z.ZodObject<{
+            kind: z.ZodEnum<{
+                repository: "repository";
+                organization: "organization";
+                team: "team";
+                user: "user";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+        refs: z.ZodArray<z.ZodObject<{
+            system: z.ZodString;
+            object_type: z.ZodString;
+            object_key: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            content_hash: z.ZodOptional<z.ZodString>;
+            observed_at: z.ZodString;
+            locator: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        attributes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+        lifecycle: z.ZodDefault<z.ZodEnum<{
+            active: "active";
+            deprecated: "deprecated";
+            retired: "retired";
+        }>>;
+        merged_into: z.ZodOptional<z.ZodString>;
+        provenance: z.ZodObject<{
+            source: z.ZodString;
+            confidence: z.ZodNumber;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            last_verified: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+    }, z.core.$strict>;
+    readonly relationships: z.ZodObject<{
+        schema: z.ZodLiteral<"nuryel.relationship/1">;
+        id: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+        type: z.ZodString;
+        scope: z.ZodObject<{
+            kind: z.ZodEnum<{
+                repository: "repository";
+                organization: "organization";
+                team: "team";
+                user: "user";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+        reason: z.ZodDefault<z.ZodString>;
+        observation_hash: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodOptional<z.ZodObject<{
+            system: z.ZodString;
+            object_type: z.ZodString;
+            object_key: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            content_hash: z.ZodOptional<z.ZodString>;
+            observed_at: z.ZodString;
+            locator: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        lifecycle: z.ZodOptional<z.ZodEnum<{
+            active: "active";
+            retired: "retired";
+        }>>;
+        provenance: z.ZodObject<{
+            source: z.ZodString;
+            confidence: z.ZodNumber;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            last_verified: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strict>;
+};
+export type EntityFor = {
+    components: Component;
+    resources: Resource;
+    edges: Edge;
+    symbols: Symbol;
+    decisions: Decision;
+    bugs: Bug;
+    constraints: Constraint;
+    runbooks: Runbook;
+    findings: Finding;
+    receipts: ActionReceipt;
+    commitments: Commitment;
+    derived: DerivedState;
+    entities: ExternalEntity;
+    relationships: StateRelationship;
+};
+/** Default provenance helper for deterministic (extracted) records. */
+export declare function extracted(confidence: number, evidence?: string[]): Provenance;
+export declare function inferred(confidence: number, evidence?: string[]): Provenance;