@eir-labs/coltrane 0.6.2 → 0.7.3

package/dist/src/genome_schema.d.ts

@@ -24,6 +24,213 @@ export declare const BrowserGrantSchema: z.ZodObject<{
     headless?: boolean | undefined;
 }>;
 export type BrowserGrant = z.output<typeof BrowserGrantSchema>;
+export declare const NetworkGrantSchema: z.ZodObject<{
+    allow: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    methods: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    max_requests: z.ZodOptional<z.ZodNumber>;
+    max_bytes: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    allow: string[];
+    methods?: string[] | undefined;
+    max_requests?: number | undefined;
+    max_bytes?: number | undefined;
+}, {
+    allow?: string[] | undefined;
+    methods?: string[] | undefined;
+    max_requests?: number | undefined;
+    max_bytes?: number | undefined;
+}>;
+export declare const SkillPermissionSchema: z.ZodObject<{
+    tier: z.ZodOptional<z.ZodNumber>;
+    network: z.ZodOptional<z.ZodObject<{
+        allow: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        methods: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        max_requests: z.ZodOptional<z.ZodNumber>;
+        max_bytes: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        allow: string[];
+        methods?: string[] | undefined;
+        max_requests?: number | undefined;
+        max_bytes?: number | undefined;
+    }, {
+        allow?: string[] | undefined;
+        methods?: string[] | undefined;
+        max_requests?: number | undefined;
+        max_bytes?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    tier?: number | undefined;
+    network?: {
+        allow: string[];
+        methods?: string[] | undefined;
+        max_requests?: number | undefined;
+        max_bytes?: number | undefined;
+    } | undefined;
+}, {
+    tier?: number | undefined;
+    network?: {
+        allow?: string[] | undefined;
+        methods?: string[] | undefined;
+        max_requests?: number | undefined;
+        max_bytes?: number | undefined;
+    } | undefined;
+}>;
+/**
+ * A HYDRATION SLOT — a named hole in a skill's method that something outside the agent fills.
+ *
+ * The seam this draws is the whole point of a carried skill: the METHOD is the agent's (portable,
+ * it travels into any institution that seats the player), while the DATA the method operates on is
+ * the institution's. A skill that hard-codes one house's constraints is not portable; a skill that
+ * declares the slot and receives the constraints is.
+ *
+ * `binding` says WHEN the slot is filled, and the two times are not interchangeable:
+ *   - "institution" (the default when omitted) — filled at SEAT time from the chair's `supplies`.
+ *     Known before any run exists, so a `required` slot nothing supplies is a DEAD SLOT and
+ *     composition refuses it, exactly as an unresolvable tool grant is refused.
+ *   - "gig" — filled at DISPATCH time from the gig payload. These are the chair contract's formal
+ *     parameters and the dispatch input is the argument list, so compose time cannot demand them:
+ *     it knows nothing about the arguments of a run that has not been asked for yet. Their floor
+ *     belongs to the runtime pre-flight at t=0.
+ */
+export declare const HydrationSlotSchema: z.ZodObject<{
+    type: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    binding: z.ZodOptional<z.ZodEnum<["institution", "gig"]>>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    description?: string | undefined;
+    required?: boolean | undefined;
+    binding?: "institution" | "gig" | undefined;
+}, {
+    type: string;
+    description?: string | undefined;
+    required?: boolean | undefined;
+    binding?: "institution" | "gig" | undefined;
+}>;
+export declare const SkillSchema: z.ZodObject<{
+    slug: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
+    skill_type: z.ZodOptional<z.ZodString>;
+    input_type: z.ZodOptional<z.ZodString>;
+    output_type: z.ZodOptional<z.ZodString>;
+    corpus: z.ZodOptional<z.ZodString>;
+    determinism_ratio: z.ZodOptional<z.ZodNumber>;
+    permission: z.ZodOptional<z.ZodObject<{
+        tier: z.ZodOptional<z.ZodNumber>;
+        network: z.ZodOptional<z.ZodObject<{
+            allow: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            methods: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            max_requests: z.ZodOptional<z.ZodNumber>;
+            max_bytes: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            allow: string[];
+            methods?: string[] | undefined;
+            max_requests?: number | undefined;
+            max_bytes?: number | undefined;
+        }, {
+            allow?: string[] | undefined;
+            methods?: string[] | undefined;
+            max_requests?: number | undefined;
+            max_bytes?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        tier?: number | undefined;
+        network?: {
+            allow: string[];
+            methods?: string[] | undefined;
+            max_requests?: number | undefined;
+            max_bytes?: number | undefined;
+        } | undefined;
+    }, {
+        tier?: number | undefined;
+        network?: {
+            allow?: string[] | undefined;
+            methods?: string[] | undefined;
+            max_requests?: number | undefined;
+            max_bytes?: number | undefined;
+        } | undefined;
+    }>>;
+    description: z.ZodOptional<z.ZodString>;
+    timeout_ms: z.ZodOptional<z.ZodNumber>;
+    /** Slot name → the declared shape of what fills it. See HydrationSlotSchema: the method is the
+     *  agent's, the slot data is the institution's (or the gig's). */
+    hydration: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        binding: z.ZodOptional<z.ZodEnum<["institution", "gig"]>>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+        binding?: "institution" | "gig" | undefined;
+    }, {
+        type: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+        binding?: "institution" | "gig" | undefined;
+    }>>>;
+    fixtures: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    code: z.ZodOptional<z.ZodString>;
+    md: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    slug: string;
+    version?: number | undefined;
+    code?: string | undefined;
+    description?: string | undefined;
+    skill_type?: string | undefined;
+    input_type?: string | undefined;
+    output_type?: string | undefined;
+    corpus?: string | undefined;
+    determinism_ratio?: number | undefined;
+    permission?: {
+        tier?: number | undefined;
+        network?: {
+            allow: string[];
+            methods?: string[] | undefined;
+            max_requests?: number | undefined;
+            max_bytes?: number | undefined;
+        } | undefined;
+    } | undefined;
+    timeout_ms?: number | undefined;
+    hydration?: Record<string, {
+        type: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+        binding?: "institution" | "gig" | undefined;
+    }> | undefined;
+    fixtures?: unknown[] | undefined;
+    md?: string | undefined;
+}, {
+    slug: string;
+    version?: number | undefined;
+    code?: string | undefined;
+    description?: string | undefined;
+    skill_type?: string | undefined;
+    input_type?: string | undefined;
+    output_type?: string | undefined;
+    corpus?: string | undefined;
+    determinism_ratio?: number | undefined;
+    permission?: {
+        tier?: number | undefined;
+        network?: {
+            allow?: string[] | undefined;
+            methods?: string[] | undefined;
+            max_requests?: number | undefined;
+            max_bytes?: number | undefined;
+        } | undefined;
+    } | undefined;
+    timeout_ms?: number | undefined;
+    hydration?: Record<string, {
+        type: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+        binding?: "institution" | "gig" | undefined;
+    }> | undefined;
+    fixtures?: unknown[] | undefined;
+    md?: string | undefined;
+}>;
 export declare const AgentSchema: z.ZodObject<{
     slug: z.ZodString;
     primitives: z.ZodReadonly<z.ZodArray<z.ZodEnum<["SENSE", "INTERPRET", "JUDGE", "PLAN", "CREATE", "VERIFY"]>, "many">>;
@@ -36,7 +243,144 @@ export declare const AgentSchema: z.ZodObject<{
     behavioral_primitives: z.ZodReadonly<z.ZodTuple<[z.ZodEnum<["explorer", "analyst", "critic", "synthesizer", "planner", "executor", "audience_modeler"]>, z.ZodEnum<["explorer", "analyst", "critic", "synthesizer", "planner", "executor", "audience_modeler"]>], null>>;
     allowed_tools: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString, "many">>>;
     disallowed_tools: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString, "many">>>;
+    /** REFERENCES into the shared repertoire (`skills/<slug>/`): the off-the-shelf method, bound by
+     *  name, resolved against the genome's skills map at run time. A slug that resolves to no
+     *  package is a dangling binding (loader) and a dead name when a chair requires it (runtime). */
     skill_slugs: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString, "many">>>;
+    /** The agent's OWN skills, carried on its record rather than referenced by name.
+     *
+     *  An agent is the thing closest to its own work, so it is the agent that grows technique — and
+     *  grown technique has to be portable: the same player seated in a second institution brings its
+     *  method along instead of waiting for that institution's repertoire to contain it. Institution
+     *  data never rides along; a carried skill declares `hydration` slots and the seating fills them.
+     *
+     *  Relationship to `skill_slugs`: slugs name the SHARED repertoire, `skills` are the agent's own.
+     *  Resolution unions the two, carried-first, so a carried definition SHADOWS a same-slug
+     *  repertoire package (the player's own technique is the one that plays) and a slug covered by a
+     *  carried definition is not a dangling binding. */
+    skills: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        version: z.ZodOptional<z.ZodNumber>;
+        skill_type: z.ZodOptional<z.ZodString>;
+        input_type: z.ZodOptional<z.ZodString>;
+        output_type: z.ZodOptional<z.ZodString>;
+        corpus: z.ZodOptional<z.ZodString>;
+        determinism_ratio: z.ZodOptional<z.ZodNumber>;
+        permission: z.ZodOptional<z.ZodObject<{
+            tier: z.ZodOptional<z.ZodNumber>;
+            network: z.ZodOptional<z.ZodObject<{
+                allow: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+                methods: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                max_requests: z.ZodOptional<z.ZodNumber>;
+                max_bytes: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                allow: string[];
+                methods?: string[] | undefined;
+                max_requests?: number | undefined;
+                max_bytes?: number | undefined;
+            }, {
+                allow?: string[] | undefined;
+                methods?: string[] | undefined;
+                max_requests?: number | undefined;
+                max_bytes?: number | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            tier?: number | undefined;
+            network?: {
+                allow: string[];
+                methods?: string[] | undefined;
+                max_requests?: number | undefined;
+                max_bytes?: number | undefined;
+            } | undefined;
+        }, {
+            tier?: number | undefined;
+            network?: {
+                allow?: string[] | undefined;
+                methods?: string[] | undefined;
+                max_requests?: number | undefined;
+                max_bytes?: number | undefined;
+            } | undefined;
+        }>>;
+        description: z.ZodOptional<z.ZodString>;
+        timeout_ms: z.ZodOptional<z.ZodNumber>;
+        /** Slot name → the declared shape of what fills it. See HydrationSlotSchema: the method is the
+         *  agent's, the slot data is the institution's (or the gig's). */
+        hydration: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            binding: z.ZodOptional<z.ZodEnum<["institution", "gig"]>>;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            description?: string | undefined;
+            required?: boolean | undefined;
+            binding?: "institution" | "gig" | undefined;
+        }, {
+            type: string;
+            description?: string | undefined;
+            required?: boolean | undefined;
+            binding?: "institution" | "gig" | undefined;
+        }>>>;
+        fixtures: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+        code: z.ZodOptional<z.ZodString>;
+        md: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        slug: string;
+        version?: number | undefined;
+        code?: string | undefined;
+        description?: string | undefined;
+        skill_type?: string | undefined;
+        input_type?: string | undefined;
+        output_type?: string | undefined;
+        corpus?: string | undefined;
+        determinism_ratio?: number | undefined;
+        permission?: {
+            tier?: number | undefined;
+            network?: {
+                allow: string[];
+                methods?: string[] | undefined;
+                max_requests?: number | undefined;
+                max_bytes?: number | undefined;
+            } | undefined;
+        } | undefined;
+        timeout_ms?: number | undefined;
+        hydration?: Record<string, {
+            type: string;
+            description?: string | undefined;
+            required?: boolean | undefined;
+            binding?: "institution" | "gig" | undefined;
+        }> | undefined;
+        fixtures?: unknown[] | undefined;
+        md?: string | undefined;
+    }, {
+        slug: string;
+        version?: number | undefined;
+        code?: string | undefined;
+        description?: string | undefined;
+        skill_type?: string | undefined;
+        input_type?: string | undefined;
+        output_type?: string | undefined;
+        corpus?: string | undefined;
+        determinism_ratio?: number | undefined;
+        permission?: {
+            tier?: number | undefined;
+            network?: {
+                allow?: string[] | undefined;
+                methods?: string[] | undefined;
+                max_requests?: number | undefined;
+                max_bytes?: number | undefined;
+            } | undefined;
+        } | undefined;
+        timeout_ms?: number | undefined;
+        hydration?: Record<string, {
+            type: string;
+            description?: string | undefined;
+            required?: boolean | undefined;
+            binding?: "institution" | "gig" | undefined;
+        }> | undefined;
+        fixtures?: unknown[] | undefined;
+        md?: string | undefined;
+    }>, "many">>>;
     model_tier: z.ZodOptional<z.ZodEnum<["economy", "standard", "premium"]>>;
     max_tool_calls: z.ZodOptional<z.ZodNumber>;
     max_token_budget: z.ZodOptional<z.ZodNumber>;
@@ -75,6 +419,35 @@ export declare const AgentSchema: z.ZodObject<{
     allowed_tools?: readonly string[] | undefined;
     disallowed_tools?: readonly string[] | undefined;
     skill_slugs?: readonly string[] | undefined;
+    skills?: readonly {
+        slug: string;
+        version?: number | undefined;
+        code?: string | undefined;
+        description?: string | undefined;
+        skill_type?: string | undefined;
+        input_type?: string | undefined;
+        output_type?: string | undefined;
+        corpus?: string | undefined;
+        determinism_ratio?: number | undefined;
+        permission?: {
+            tier?: number | undefined;
+            network?: {
+                allow: string[];
+                methods?: string[] | undefined;
+                max_requests?: number | undefined;
+                max_bytes?: number | undefined;
+            } | undefined;
+        } | undefined;
+        timeout_ms?: number | undefined;
+        hydration?: Record<string, {
+            type: string;
+            description?: string | undefined;
+            required?: boolean | undefined;
+            binding?: "institution" | "gig" | undefined;
+        }> | undefined;
+        fixtures?: unknown[] | undefined;
+        md?: string | undefined;
+    }[] | undefined;
     model_tier?: "standard" | "economy" | "premium" | undefined;
     max_tool_calls?: number | undefined;
     max_token_budget?: number | undefined;
@@ -100,6 +473,35 @@ export declare const AgentSchema: z.ZodObject<{
     allowed_tools?: readonly string[] | undefined;
     disallowed_tools?: readonly string[] | undefined;
     skill_slugs?: readonly string[] | undefined;
+    skills?: readonly {
+        slug: string;
+        version?: number | undefined;
+        code?: string | undefined;
+        description?: string | undefined;
+        skill_type?: string | undefined;
+        input_type?: string | undefined;
+        output_type?: string | undefined;
+        corpus?: string | undefined;
+        determinism_ratio?: number | undefined;
+        permission?: {
+            tier?: number | undefined;
+            network?: {
+                allow?: string[] | undefined;
+                methods?: string[] | undefined;
+                max_requests?: number | undefined;
+                max_bytes?: number | undefined;
+            } | undefined;
+        } | undefined;
+        timeout_ms?: number | undefined;
+        hydration?: Record<string, {
+            type: string;
+            description?: string | undefined;
+            required?: boolean | undefined;
+            binding?: "institution" | "gig" | undefined;
+        }> | undefined;
+        fixtures?: unknown[] | undefined;
+        md?: string | undefined;
+    }[] | undefined;
     model_tier?: "standard" | "economy" | "premium" | undefined;
     max_tool_calls?: number | undefined;
     max_token_budget?: number | undefined;
@@ -118,11 +520,27 @@ export declare const ChairSchema: z.ZodObject<{
     role: z.ZodString;
     agent_slug: z.ZodOptional<z.ZodString>;
     skill_slug: z.ZodOptional<z.ZodString>;
+    /** The human seat: the chair is an approval office held by a person. No agent, no skill —
+     *  the incumbent's sealed verdict is the chair's output, and a gig that reaches this chair
+     *  unapproved PARKS (awaiting_approval) rather than confabulating a yes. */
+    human: z.ZodOptional<z.ZodBoolean>;
     depends_on: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     input_contract: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     output_contract: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     optional_outputs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** The FLOOR. A skill named here must be held by whoever is seated — bound by slug or carried on
+     *  the record — or the seating is refused at compose and the chair fails closed at run. */
     required_skills: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** The PREFERENCE. Technique this chair would rather its incumbent hold, stated without refusing
+     *  the ones who do not: the roster of available agents is a fact about the world, not a defect,
+     *  and a preference that refused a seating would be a second floor under another name. Nothing
+     *  checks it at compose time — deliberately, including its names, since a chair may legitimately
+     *  prefer a technique no agent in the genome has grown yet. */
+    preferred_skills: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** The institution's side of a hydration contract, at the phase-chair level: slot name → the
+     *  value that fills it. An institution-bound `required` slot on a skill the seated agent holds
+     *  and nothing here (or on the institutional chair) fills is refused at compose. */
+    supplies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
     role: string;
     depends_on: string[];
@@ -130,17 +548,23 @@ export declare const ChairSchema: z.ZodObject<{
     output_contract: string[];
     optional_outputs: string[];
     required_skills: string[];
+    preferred_skills: string[];
     agent_slug?: string | undefined;
     skill_slug?: string | undefined;
+    human?: boolean | undefined;
+    supplies?: Record<string, unknown> | undefined;
 }, {
     role: string;
     agent_slug?: string | undefined;
     skill_slug?: string | undefined;
+    human?: boolean | undefined;
     depends_on?: string[] | undefined;
     input_contract?: string[] | undefined;
     output_contract?: string[] | undefined;
     optional_outputs?: string[] | undefined;
     required_skills?: string[] | undefined;
+    preferred_skills?: string[] | undefined;
+    supplies?: Record<string, unknown> | undefined;
 }>;
 export declare const PhaseSchema: z.ZodObject<{
     name: z.ZodString;
@@ -148,11 +572,27 @@ export declare const PhaseSchema: z.ZodObject<{
         role: z.ZodString;
         agent_slug: z.ZodOptional<z.ZodString>;
         skill_slug: z.ZodOptional<z.ZodString>;
+        /** The human seat: the chair is an approval office held by a person. No agent, no skill —
+         *  the incumbent's sealed verdict is the chair's output, and a gig that reaches this chair
+         *  unapproved PARKS (awaiting_approval) rather than confabulating a yes. */
+        human: z.ZodOptional<z.ZodBoolean>;
         depends_on: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
         input_contract: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
         output_contract: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
         optional_outputs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** The FLOOR. A skill named here must be held by whoever is seated — bound by slug or carried on
+         *  the record — or the seating is refused at compose and the chair fails closed at run. */
         required_skills: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** The PREFERENCE. Technique this chair would rather its incumbent hold, stated without refusing
+         *  the ones who do not: the roster of available agents is a fact about the world, not a defect,
+         *  and a preference that refused a seating would be a second floor under another name. Nothing
+         *  checks it at compose time — deliberately, including its names, since a chair may legitimately
+         *  prefer a technique no agent in the genome has grown yet. */
+        preferred_skills: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** The institution's side of a hydration contract, at the phase-chair level: slot name → the
+         *  value that fills it. An institution-bound `required` slot on a skill the seated agent holds
+         *  and nothing here (or on the institutional chair) fills is refused at compose. */
+        supplies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, "strip", z.ZodTypeAny, {
         role: string;
         depends_on: string[];
@@ -160,17 +600,23 @@ export declare const PhaseSchema: z.ZodObject<{
         output_contract: string[];
         optional_outputs: string[];
         required_skills: string[];
+        preferred_skills: string[];
         agent_slug?: string | undefined;
         skill_slug?: string | undefined;
+        human?: boolean | undefined;
+        supplies?: Record<string, unknown> | undefined;
     }, {
         role: string;
         agent_slug?: string | undefined;
         skill_slug?: string | undefined;
+        human?: boolean | undefined;
         depends_on?: string[] | undefined;
         input_contract?: string[] | undefined;
         output_contract?: string[] | undefined;
         optional_outputs?: string[] | undefined;
         required_skills?: string[] | undefined;
+        preferred_skills?: string[] | undefined;
+        supplies?: Record<string, unknown> | undefined;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     name: string;
@@ -181,8 +627,11 @@ export declare const PhaseSchema: z.ZodObject<{
         output_contract: string[];
         optional_outputs: string[];
         required_skills: string[];
+        preferred_skills: string[];
         agent_slug?: string | undefined;
         skill_slug?: string | undefined;
+        human?: boolean | undefined;
+        supplies?: Record<string, unknown> | undefined;
     }[];
 }, {
     name: string;
@@ -190,11 +639,14 @@ export declare const PhaseSchema: z.ZodObject<{
         role: string;
         agent_slug?: string | undefined;
         skill_slug?: string | undefined;
+        human?: boolean | undefined;
         depends_on?: string[] | undefined;
         input_contract?: string[] | undefined;
         output_contract?: string[] | undefined;
         optional_outputs?: string[] | undefined;
         required_skills?: string[] | undefined;
+        preferred_skills?: string[] | undefined;
+        supplies?: Record<string, unknown> | undefined;
     }[];
 }>;
 /** Lifecycle status, shared by domain types and standards (#203). */
@@ -211,11 +663,27 @@ export declare const StandardSchema: z.ZodObject<{
             role: z.ZodString;
             agent_slug: z.ZodOptional<z.ZodString>;
             skill_slug: z.ZodOptional<z.ZodString>;
+            /** The human seat: the chair is an approval office held by a person. No agent, no skill —
+             *  the incumbent's sealed verdict is the chair's output, and a gig that reaches this chair
+             *  unapproved PARKS (awaiting_approval) rather than confabulating a yes. */
+            human: z.ZodOptional<z.ZodBoolean>;
             depends_on: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
             input_contract: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
             output_contract: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
             optional_outputs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            /** The FLOOR. A skill named here must be held by whoever is seated — bound by slug or carried on
+             *  the record — or the seating is refused at compose and the chair fails closed at run. */
             required_skills: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            /** The PREFERENCE. Technique this chair would rather its incumbent hold, stated without refusing
+             *  the ones who do not: the roster of available agents is a fact about the world, not a defect,
+             *  and a preference that refused a seating would be a second floor under another name. Nothing
+             *  checks it at compose time — deliberately, including its names, since a chair may legitimately
+             *  prefer a technique no agent in the genome has grown yet. */
+            preferred_skills: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            /** The institution's side of a hydration contract, at the phase-chair level: slot name → the
+             *  value that fills it. An institution-bound `required` slot on a skill the seated agent holds
+             *  and nothing here (or on the institutional chair) fills is refused at compose. */
+            supplies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, "strip", z.ZodTypeAny, {
             role: string;
             depends_on: string[];
@@ -223,17 +691,23 @@ export declare const StandardSchema: z.ZodObject<{
             output_contract: string[];
             optional_outputs: string[];
             required_skills: string[];
+            preferred_skills: string[];
             agent_slug?: string | undefined;
             skill_slug?: string | undefined;
+            human?: boolean | undefined;
+            supplies?: Record<string, unknown> | undefined;
         }, {
             role: string;
             agent_slug?: string | undefined;
             skill_slug?: string | undefined;
+            human?: boolean | undefined;
             depends_on?: string[] | undefined;
             input_contract?: string[] | undefined;
             output_contract?: string[] | undefined;
             optional_outputs?: string[] | undefined;
             required_skills?: string[] | undefined;
+            preferred_skills?: string[] | undefined;
+            supplies?: Record<string, unknown> | undefined;
         }>, "many">;
     }, "strip", z.ZodTypeAny, {
         name: string;
@@ -244,8 +718,11 @@ export declare const StandardSchema: z.ZodObject<{
             output_contract: string[];
             optional_outputs: string[];
             required_skills: string[];
+            preferred_skills: string[];
             agent_slug?: string | undefined;
             skill_slug?: string | undefined;
+            human?: boolean | undefined;
+            supplies?: Record<string, unknown> | undefined;
         }[];
     }, {
         name: string;
@@ -253,11 +730,14 @@ export declare const StandardSchema: z.ZodObject<{
             role: string;
             agent_slug?: string | undefined;
             skill_slug?: string | undefined;
+            human?: boolean | undefined;
             depends_on?: string[] | undefined;
             input_contract?: string[] | undefined;
             output_contract?: string[] | undefined;
             optional_outputs?: string[] | undefined;
             required_skills?: string[] | undefined;
+            preferred_skills?: string[] | undefined;
+            supplies?: Record<string, unknown> | undefined;
         }[];
     }>, "many">;
     eval_slugs: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString, "many">>>;
@@ -277,18 +757,21 @@ export declare const StandardSchema: z.ZodObject<{
             output_contract: string[];
             optional_outputs: string[];
             required_skills: string[];
+            preferred_skills: string[];
             agent_slug?: string | undefined;
             skill_slug?: string | undefined;
+            human?: boolean | undefined;
+            supplies?: Record<string, unknown> | undefined;
         }[];
     }[];
     status?: "active" | "retired" | "deprecated" | undefined;
     input_types?: readonly string[] | undefined;
     output_types?: readonly string[] | undefined;
+    description?: string | undefined;
     agents?: unknown[] | undefined;
     agent_slugs?: string[] | undefined;
     eval_slugs?: readonly string[] | undefined;
     max_examine_rounds?: number | undefined;
-    description?: string | undefined;
 }, {
     slug: string;
     domain: string;
@@ -298,168 +781,27 @@ export declare const StandardSchema: z.ZodObject<{
             role: string;
             agent_slug?: string | undefined;
             skill_slug?: string | undefined;
+            human?: boolean | undefined;
             depends_on?: string[] | undefined;
             input_contract?: string[] | undefined;
             output_contract?: string[] | undefined;
             optional_outputs?: string[] | undefined;
             required_skills?: string[] | undefined;
+            preferred_skills?: string[] | undefined;
+            supplies?: Record<string, unknown> | undefined;
         }[];
     }[];
     status?: "active" | "retired" | "deprecated" | undefined;
     input_types?: readonly string[] | undefined;
     output_types?: readonly string[] | undefined;
+    description?: string | undefined;
     agents?: unknown[] | undefined;
     agent_slugs?: string[] | undefined;
     eval_slugs?: readonly string[] | undefined;
     max_examine_rounds?: number | undefined;
-    description?: string | undefined;
 }>;
 export type StandardInput = z.input<typeof StandardSchema>;
 export type StandardOutput = z.output<typeof StandardSchema>;
-export declare const NetworkGrantSchema: z.ZodObject<{
-    allow: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-    methods: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    max_requests: z.ZodOptional<z.ZodNumber>;
-    max_bytes: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    allow: string[];
-    methods?: string[] | undefined;
-    max_requests?: number | undefined;
-    max_bytes?: number | undefined;
-}, {
-    allow?: string[] | undefined;
-    methods?: string[] | undefined;
-    max_requests?: number | undefined;
-    max_bytes?: number | undefined;
-}>;
-export declare const SkillPermissionSchema: z.ZodObject<{
-    tier: z.ZodOptional<z.ZodNumber>;
-    network: z.ZodOptional<z.ZodObject<{
-        allow: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-        methods: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        max_requests: z.ZodOptional<z.ZodNumber>;
-        max_bytes: z.ZodOptional<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        allow: string[];
-        methods?: string[] | undefined;
-        max_requests?: number | undefined;
-        max_bytes?: number | undefined;
-    }, {
-        allow?: string[] | undefined;
-        methods?: string[] | undefined;
-        max_requests?: number | undefined;
-        max_bytes?: number | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    tier?: number | undefined;
-    network?: {
-        allow: string[];
-        methods?: string[] | undefined;
-        max_requests?: number | undefined;
-        max_bytes?: number | undefined;
-    } | undefined;
-}, {
-    tier?: number | undefined;
-    network?: {
-        allow?: string[] | undefined;
-        methods?: string[] | undefined;
-        max_requests?: number | undefined;
-        max_bytes?: number | undefined;
-    } | undefined;
-}>;
-export declare const SkillSchema: z.ZodObject<{
-    slug: z.ZodString;
-    version: z.ZodOptional<z.ZodNumber>;
-    skill_type: z.ZodOptional<z.ZodString>;
-    input_type: z.ZodOptional<z.ZodString>;
-    output_type: z.ZodOptional<z.ZodString>;
-    corpus: z.ZodOptional<z.ZodString>;
-    determinism_ratio: z.ZodOptional<z.ZodNumber>;
-    permission: z.ZodOptional<z.ZodObject<{
-        tier: z.ZodOptional<z.ZodNumber>;
-        network: z.ZodOptional<z.ZodObject<{
-            allow: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-            methods: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            max_requests: z.ZodOptional<z.ZodNumber>;
-            max_bytes: z.ZodOptional<z.ZodNumber>;
-        }, "strip", z.ZodTypeAny, {
-            allow: string[];
-            methods?: string[] | undefined;
-            max_requests?: number | undefined;
-            max_bytes?: number | undefined;
-        }, {
-            allow?: string[] | undefined;
-            methods?: string[] | undefined;
-            max_requests?: number | undefined;
-            max_bytes?: number | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        tier?: number | undefined;
-        network?: {
-            allow: string[];
-            methods?: string[] | undefined;
-            max_requests?: number | undefined;
-            max_bytes?: number | undefined;
-        } | undefined;
-    }, {
-        tier?: number | undefined;
-        network?: {
-            allow?: string[] | undefined;
-            methods?: string[] | undefined;
-            max_requests?: number | undefined;
-            max_bytes?: number | undefined;
-        } | undefined;
-    }>>;
-    description: z.ZodOptional<z.ZodString>;
-    timeout_ms: z.ZodOptional<z.ZodNumber>;
-    fixtures: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
-    code: z.ZodOptional<z.ZodString>;
-    md: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    slug: string;
-    version?: number | undefined;
-    code?: string | undefined;
-    description?: string | undefined;
-    skill_type?: string | undefined;
-    input_type?: string | undefined;
-    output_type?: string | undefined;
-    corpus?: string | undefined;
-    determinism_ratio?: number | undefined;
-    permission?: {
-        tier?: number | undefined;
-        network?: {
-            allow: string[];
-            methods?: string[] | undefined;
-            max_requests?: number | undefined;
-            max_bytes?: number | undefined;
-        } | undefined;
-    } | undefined;
-    timeout_ms?: number | undefined;
-    fixtures?: unknown[] | undefined;
-    md?: string | undefined;
-}, {
-    slug: string;
-    version?: number | undefined;
-    code?: string | undefined;
-    description?: string | undefined;
-    skill_type?: string | undefined;
-    input_type?: string | undefined;
-    output_type?: string | undefined;
-    corpus?: string | undefined;
-    determinism_ratio?: number | undefined;
-    permission?: {
-        tier?: number | undefined;
-        network?: {
-            allow?: string[] | undefined;
-            methods?: string[] | undefined;
-            max_requests?: number | undefined;
-            max_bytes?: number | undefined;
-        } | undefined;
-    } | undefined;
-    timeout_ms?: number | undefined;
-    fixtures?: unknown[] | undefined;
-    md?: string | undefined;
-}>;
 export declare const EvalSchema: z.ZodObject<{
     slug: z.ZodString;
     domain: z.ZodOptional<z.ZodString>;
@@ -508,10 +850,38 @@ export declare const DomainTypeSchema: z.ZodObject<{
     required_fields?: string[] | undefined;
 }>;
 export type SkillOutput = z.output<typeof SkillSchema>;
+export type HydrationSlot = z.output<typeof HydrationSlotSchema>;
 export type EvalOutput = z.output<typeof EvalSchema>;
 export type DomainTypeOutput = z.output<typeof DomainTypeSchema>;
 /** The typed lineage-edge vocabulary. Caps grant these; lineage edges are made of them. */
 export declare const LineageEdgeTypeSchema: z.ZodEnum<["anchored-in", "produced-by", "evolved-from", "descends-from"]>;
+/** A reference from an institution to a published lineage-record that grounds it. The record
+ *  itself is sealed content-addressed in the ledger; the institution carries the REFERENCE, so an
+ *  APPROVED lineage (the lineage-pass standard's `approve` chair sealed a passing lineage-verdict)
+ *  becomes first-class institutional grounding — see `institutionLineageGrounding` below. `record_ref`
+ *  is the only non-optional field: a lineage reference that names no record references nothing.
+ *  Store-side home is `coltrane_institution_lineage` (follow-up; not built here). */
+export declare const LineageRecordRefSchema: z.ZodObject<{
+    /** content_sha (or slug) of the sealed lineage-record this institution is grounded in. */
+    record_ref: z.ZodString;
+    /** the lineage-question the record answered, for display without dereferencing the record. */
+    question: z.ZodOptional<z.ZodString>;
+    /** the human seal: filled from the approve chair's verdict when the lineage is adopted. Null
+     *  until then — an institution never grounds itself on an unapproved lineage. */
+    approved_by: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    sealed_at: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    record_ref: string;
+    approved_by: string | null;
+    question?: string | undefined;
+    sealed_at?: string | undefined;
+}, {
+    record_ref: string;
+    question?: string | undefined;
+    approved_by?: string | null | undefined;
+    sealed_at?: string | undefined;
+}>;
+export type LineageRecordRefOutput = z.output<typeof LineageRecordRefSchema>;
 export declare const InstitutionSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     slug: z.ZodString;
@@ -520,12 +890,43 @@ export declare const InstitutionSchema: z.ZodObject<{
     laws: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     wiki_space: z.ZodOptional<z.ZodString>;
     sovereign: z.ZodDefault<z.ZodBoolean>;
+    /** First-class lineage: references to approved lineage-records that ground this institution.
+     *  Additive and defaulted, so an institution declared without it simply has no adopted lineage
+     *  yet. A record lands here only after the lineage-pass `approve` chair seals it; every agent
+     *  seated in the institution then inherits these as formal grounding (see the surfacing seam in
+     *  `institutionLineageGrounding`). */
+    lineage: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** content_sha (or slug) of the sealed lineage-record this institution is grounded in. */
+        record_ref: z.ZodString;
+        /** the lineage-question the record answered, for display without dereferencing the record. */
+        question: z.ZodOptional<z.ZodString>;
+        /** the human seal: filled from the approve chair's verdict when the lineage is adopted. Null
+         *  until then — an institution never grounds itself on an unapproved lineage. */
+        approved_by: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        sealed_at: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        record_ref: string;
+        approved_by: string | null;
+        question?: string | undefined;
+        sealed_at?: string | undefined;
+    }, {
+        record_ref: string;
+        question?: string | undefined;
+        approved_by?: string | null | undefined;
+        sealed_at?: string | undefined;
+    }>, "many">>;
 }, "strip", z.ZodTypeAny, {
     slug: string;
     name: string;
     kind: "institution" | "personal";
     laws: string[];
     sovereign: boolean;
+    lineage: {
+        record_ref: string;
+        approved_by: string | null;
+        question?: string | undefined;
+        sealed_at?: string | undefined;
+    }[];
     id?: string | undefined;
     wiki_space?: string | undefined;
 }, {
@@ -536,6 +937,12 @@ export declare const InstitutionSchema: z.ZodObject<{
     laws?: string[] | undefined;
     wiki_space?: string | undefined;
     sovereign?: boolean | undefined;
+    lineage?: {
+        record_ref: string;
+        question?: string | undefined;
+        approved_by?: string | null | undefined;
+        sealed_at?: string | undefined;
+    }[] | undefined;
 }>;
 export declare const OrganizationSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
@@ -612,7 +1019,7 @@ export declare const OrgInstitutionSchema: z.ZodObject<{
     institution_slug: string;
 }>;
 /** A capability grant: a typed lineage-edge scope, optionally expiring. The grant IS the policy. */
-export declare const CapGrantSchema: z.ZodObject<{
+export declare const EdgeCapGrantSchema: z.ZodObject<{
     edge_type: z.ZodEnum<["anchored-in", "produced-by", "evolved-from", "descends-from"]>;
     scope: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     expires: z.ZodDefault<z.ZodNullable<z.ZodString>>;
@@ -625,15 +1032,68 @@ export declare const CapGrantSchema: z.ZodObject<{
     scope: Record<string, unknown>;
     expires?: string | null | undefined;
 }>;
+/** The chair-contract dispatch grant — the office names which standards its incumbent may
+ *  run. Authority sits on the chair; a credential presented by the incumbent may only
+ *  narrow it, never widen it. (This is the shape the store's authorization function reads:
+ *  a flat cap, not a scope smuggled inside a lineage edge.) */
+export declare const DispatchCapGrantSchema: z.ZodObject<{
+    grant: z.ZodLiteral<"dispatch">;
+    standards: z.ZodReadonly<z.ZodArray<z.ZodString, "many">>;
+    expires: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    expires: string | null;
+    grant: "dispatch";
+    standards: readonly string[];
+}, {
+    grant: "dispatch";
+    standards: readonly string[];
+    expires?: string | null | undefined;
+}>;
+/** A chair cap is a lineage-edge grant or a dispatch grant. One union, one Zod source. */
+export declare const CapGrantSchema: z.ZodUnion<[z.ZodObject<{
+    edge_type: z.ZodEnum<["anchored-in", "produced-by", "evolved-from", "descends-from"]>;
+    scope: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    expires: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    edge_type: "anchored-in" | "produced-by" | "evolved-from" | "descends-from";
+    scope: Record<string, unknown>;
+    expires: string | null;
+}, {
+    edge_type: "anchored-in" | "produced-by" | "evolved-from" | "descends-from";
+    scope: Record<string, unknown>;
+    expires?: string | null | undefined;
+}>, z.ZodObject<{
+    grant: z.ZodLiteral<"dispatch">;
+    standards: z.ZodReadonly<z.ZodArray<z.ZodString, "many">>;
+    expires: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    expires: string | null;
+    grant: "dispatch";
+    standards: readonly string[];
+}, {
+    grant: "dispatch";
+    standards: readonly string[];
+    expires?: string | null | undefined;
+}>]>;
 /** The chair is the thing: the seat's configuration, not a person. */
 export declare const InstitutionalChairSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     institution_slug: z.ZodString;
     role: z.ZodString;
+    /** The human office: this chair is held by a person, never a model agent. */
+    human: z.ZodOptional<z.ZodBoolean>;
     function: z.ZodEnum<["SENSE", "INTERPRET", "JUDGE", "PLAN", "CREATE", "VERIFY"]>;
     mission: z.ZodString;
+    /** The floor: skills the office requires of whoever holds it. */
     required_skills: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-    caps: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    /** The preference: technique the office would rather its incumbent hold, stated without refusing
+     *  the agents who do not hold it. Same two-tier reading as the phase chair's. */
+    preferred_skills: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** The institution's data, delivered through the office: hydration slot name → the value that
+     *  fills it. This is where institution-specific content belongs — NOT inside the carried skill,
+     *  which is why the skill stays portable across institutions. */
+    supplies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    caps: z.ZodDefault<z.ZodArray<z.ZodUnion<[z.ZodObject<{
         edge_type: z.ZodEnum<["anchored-in", "produced-by", "evolved-from", "descends-from"]>;
         scope: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         expires: z.ZodDefault<z.ZodNullable<z.ZodString>>;
@@ -645,42 +1105,85 @@ export declare const InstitutionalChairSchema: z.ZodObject<{
         edge_type: "anchored-in" | "produced-by" | "evolved-from" | "descends-from";
         scope: Record<string, unknown>;
         expires?: string | null | undefined;
-    }>, "many">>;
+    }>, z.ZodObject<{
+        grant: z.ZodLiteral<"dispatch">;
+        standards: z.ZodReadonly<z.ZodArray<z.ZodString, "many">>;
+        expires: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        expires: string | null;
+        grant: "dispatch";
+        standards: readonly string[];
+    }, {
+        grant: "dispatch";
+        standards: readonly string[];
+        expires?: string | null | undefined;
+    }>]>, "many">>;
     obligations: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
     function: "SENSE" | "INTERPRET" | "JUDGE" | "PLAN" | "CREATE" | "VERIFY";
     role: string;
     required_skills: string[];
+    preferred_skills: string[];
     institution_slug: string;
     mission: string;
-    caps: {
+    caps: ({
         edge_type: "anchored-in" | "produced-by" | "evolved-from" | "descends-from";
         scope: Record<string, unknown>;
         expires: string | null;
-    }[];
+    } | {
+        expires: string | null;
+        grant: "dispatch";
+        standards: readonly string[];
+    })[];
     obligations: string[];
+    human?: boolean | undefined;
+    supplies?: Record<string, unknown> | undefined;
     id?: string | undefined;
 }, {
     function: "SENSE" | "INTERPRET" | "JUDGE" | "PLAN" | "CREATE" | "VERIFY";
     role: string;
     institution_slug: string;
     mission: string;
+    human?: boolean | undefined;
     required_skills?: string[] | undefined;
+    preferred_skills?: string[] | undefined;
+    supplies?: Record<string, unknown> | undefined;
     id?: string | undefined;
-    caps?: {
+    caps?: ({
         edge_type: "anchored-in" | "produced-by" | "evolved-from" | "descends-from";
         scope: Record<string, unknown>;
         expires?: string | null | undefined;
-    }[] | undefined;
+    } | {
+        grant: "dispatch";
+        standards: readonly string[];
+        expires?: string | null | undefined;
+    })[] | undefined;
     obligations?: string[] | undefined;
 }>;
-/** A seat: a named agent bound into a chair for an org, witnessed. */
+/** What a seating cited: a source and the claim read from it. Both required — a source with no
+ *  claim cites nothing in particular, and a claim with no source is a recollection. */
+export declare const TechniqueEvidenceSchema: z.ZodObject<{
+    source: z.ZodString;
+    claim: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    source: string;
+    claim: string;
+}, {
+    source: string;
+    claim: string;
+}>;
+/** A seat: a named agent bound into a chair for an org, witnessed.
+ *
+ *  Seating is a JUDGEMENT — this player, this office — and `technique_evidence` makes it a recorded
+ *  one: the ledger queries, improvement reports, prior gig fingerprints or deterministic suite
+ *  results the decision weighed. Optional, because a seating may be made on no evidence at all;
+ *  what is not optional is the difference between the two, which is exactly what the field records. */
 export declare const ChairAssignmentSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     chair_id: z.ZodString;
     agent_slug: z.ZodString;
     org_slug: z.ZodString;
-    contract_caps: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    contract_caps: z.ZodDefault<z.ZodArray<z.ZodUnion<[z.ZodObject<{
         edge_type: z.ZodEnum<["anchored-in", "produced-by", "evolved-from", "descends-from"]>;
         scope: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         expires: z.ZodDefault<z.ZodNullable<z.ZodString>>;
@@ -692,28 +1195,66 @@ export declare const ChairAssignmentSchema: z.ZodObject<{
         edge_type: "anchored-in" | "produced-by" | "evolved-from" | "descends-from";
         scope: Record<string, unknown>;
         expires?: string | null | undefined;
+    }>, z.ZodObject<{
+        grant: z.ZodLiteral<"dispatch">;
+        standards: z.ZodReadonly<z.ZodArray<z.ZodString, "many">>;
+        expires: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        expires: string | null;
+        grant: "dispatch";
+        standards: readonly string[];
+    }, {
+        grant: "dispatch";
+        standards: readonly string[];
+        expires?: string | null | undefined;
+    }>]>, "many">>;
+    technique_evidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        claim: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        claim: string;
+    }, {
+        source: string;
+        claim: string;
     }>, "many">>;
     witnessed_by: z.ZodDefault<z.ZodNullable<z.ZodString>>;
 }, "strip", z.ZodTypeAny, {
     agent_slug: string;
     org_slug: string;
     chair_id: string;
-    contract_caps: {
+    contract_caps: ({
         edge_type: "anchored-in" | "produced-by" | "evolved-from" | "descends-from";
         scope: Record<string, unknown>;
         expires: string | null;
-    }[];
+    } | {
+        expires: string | null;
+        grant: "dispatch";
+        standards: readonly string[];
+    })[];
     witnessed_by: string | null;
     id?: string | undefined;
+    technique_evidence?: {
+        source: string;
+        claim: string;
+    }[] | undefined;
 }, {
     agent_slug: string;
     org_slug: string;
     chair_id: string;
     id?: string | undefined;
-    contract_caps?: {
+    contract_caps?: ({
         edge_type: "anchored-in" | "produced-by" | "evolved-from" | "descends-from";
         scope: Record<string, unknown>;
         expires?: string | null | undefined;
+    } | {
+        grant: "dispatch";
+        standards: readonly string[];
+        expires?: string | null | undefined;
+    })[] | undefined;
+    technique_evidence?: {
+        source: string;
+        claim: string;
     }[] | undefined;
     witnessed_by?: string | null | undefined;
 }>;
@@ -722,7 +1263,7 @@ export declare const ExchangeContractSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     from_institution: z.ZodString;
     to_institution: z.ZodString;
-    caps: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    caps: z.ZodDefault<z.ZodArray<z.ZodUnion<[z.ZodObject<{
         edge_type: z.ZodEnum<["anchored-in", "produced-by", "evolved-from", "descends-from"]>;
         scope: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         expires: z.ZodDefault<z.ZodNullable<z.ZodString>>;
@@ -734,14 +1275,30 @@ export declare const ExchangeContractSchema: z.ZodObject<{
         edge_type: "anchored-in" | "produced-by" | "evolved-from" | "descends-from";
         scope: Record<string, unknown>;
         expires?: string | null | undefined;
-    }>, "many">>;
+    }>, z.ZodObject<{
+        grant: z.ZodLiteral<"dispatch">;
+        standards: z.ZodReadonly<z.ZodArray<z.ZodString, "many">>;
+        expires: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        expires: string | null;
+        grant: "dispatch";
+        standards: readonly string[];
+    }, {
+        grant: "dispatch";
+        standards: readonly string[];
+        expires?: string | null | undefined;
+    }>]>, "many">>;
     witnessed_by: z.ZodDefault<z.ZodNullable<z.ZodString>>;
 }, "strip", z.ZodTypeAny, {
-    caps: {
+    caps: ({
         edge_type: "anchored-in" | "produced-by" | "evolved-from" | "descends-from";
         scope: Record<string, unknown>;
         expires: string | null;
-    }[];
+    } | {
+        expires: string | null;
+        grant: "dispatch";
+        standards: readonly string[];
+    })[];
     witnessed_by: string | null;
     from_institution: string;
     to_institution: string;
@@ -750,11 +1307,15 @@ export declare const ExchangeContractSchema: z.ZodObject<{
     from_institution: string;
     to_institution: string;
     id?: string | undefined;
-    caps?: {
+    caps?: ({
         edge_type: "anchored-in" | "produced-by" | "evolved-from" | "descends-from";
         scope: Record<string, unknown>;
         expires?: string | null | undefined;
-    }[] | undefined;
+    } | {
+        grant: "dispatch";
+        standards: readonly string[];
+        expires?: string | null | undefined;
+    })[] | undefined;
     witnessed_by?: string | null | undefined;
 }>;
 export declare const ForebearSchema: z.ZodObject<{
@@ -794,8 +1355,8 @@ export declare const NorthstarSchema: z.ZodObject<{
     title: string;
     statement: string;
     kind?: string | undefined;
-    ordinal?: number | undefined;
     source?: Record<string, unknown> | undefined;
+    ordinal?: number | undefined;
     quote?: string | undefined;
 }, {
     slug: string;
@@ -803,8 +1364,8 @@ export declare const NorthstarSchema: z.ZodObject<{
     title: string;
     statement: string;
     kind?: string | undefined;
-    ordinal?: number | undefined;
     source?: Record<string, unknown> | undefined;
+    ordinal?: number | undefined;
     quote?: string | undefined;
 }>;
 export declare const LineageEdgeSchema: z.ZodObject<{
@@ -866,16 +1427,492 @@ export declare const OrgServiceKeySchema: z.ZodObject<{
     issued_at?: string | undefined;
 }>;
 export type InstitutionOutput = z.output<typeof InstitutionSchema>;
+/** The institution-lineage SURFACING SEAM. When a seat renders a player into a Claude Code
+ *  subagent (`src/player_to_claude_code.ts`, the seat→prompt transform), the institution's approved
+ *  lineage-records are read through here and folded into the agent's formal grounding — the same
+ *  seam a future institutional-northstars / forebears surface would use. Today it returns the refs
+ *  themselves (the institution definition carries them); the STORE-BACKED path (dereferencing each
+ *  `record_ref` to its sealed lineage-record via `coltrane_institution_lineage`) is the follow-up
+ *  the instance layer fills. Named here, additively, so the seam has one home rather than being
+ *  reinvented at the render call site. */
+export declare function institutionLineageGrounding(inst: InstitutionOutput): readonly LineageRecordRefOutput[];
 export type OrganizationOutput = z.output<typeof OrganizationSchema>;
 export type AgentRecordOutput = z.output<typeof AgentRecordSchema>;
 export type CapGrant = z.output<typeof CapGrantSchema>;
 export type InstitutionalChairOutput = z.output<typeof InstitutionalChairSchema>;
 export type ChairAssignmentOutput = z.output<typeof ChairAssignmentSchema>;
+export type TechniqueEvidence = z.output<typeof TechniqueEvidenceSchema>;
 export type ExchangeContractOutput = z.output<typeof ExchangeContractSchema>;
 export type ForebearOutput = z.output<typeof ForebearSchema>;
 export type NorthstarOutput = z.output<typeof NorthstarSchema>;
 export type LineageEdgeOutput = z.output<typeof LineageEdgeSchema>;
 export type OrgServiceKeyOutput = z.output<typeof OrgServiceKeySchema>;
+/** One typed edge: a type the source movement seals, consumed by the sink movement's entry chairs. */
+export declare const ChartEdgeSchema: z.ZodObject<{
+    from_movement: z.ZodString;
+    to_movement: z.ZodString;
+    output_type: z.ZodString;
+    /** true = a CONDITIONAL edge: the type lives only in a terminal chair's `optional_outputs`,
+     *  so the flow may legitimately carry nothing. Compose classifies it; it cannot prove the
+     *  optional output will be produced, which is why a conditional edge never satisfies a
+     *  REQUIRED entry slot (src/chart.ts R6/R7). */
+    optional: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    output_type: string;
+    from_movement: string;
+    to_movement: string;
+    optional: boolean;
+}, {
+    output_type: string;
+    from_movement: string;
+    to_movement: string;
+    optional?: boolean | undefined;
+}>;
+/** Who plays which chair for this movement — a recorded act, optionally with its evidence. */
+export declare const ChartSeatingSchema: z.ZodObject<{
+    chair: z.ZodString;
+    agent_slug: z.ZodString;
+    technique_evidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        claim: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        claim: string;
+    }, {
+        source: string;
+        claim: string;
+    }>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    agent_slug: string;
+    chair: string;
+    technique_evidence?: {
+        source: string;
+        claim: string;
+    }[] | undefined;
+}, {
+    agent_slug: string;
+    chair: string;
+    technique_evidence?: {
+        source: string;
+        claim: string;
+    }[] | undefined;
+}>;
+/** One movement: a standard, its gig-bound hydration arguments, and its seatings.
+ *
+ *  `movement_id` — NOT `standard_slug` — is the identity everything keys on: the checkpoint
+ *  namespace, the reuse-cache namespace, the edge endpoints. That is what lets one standard
+ *  appear twice in a chart without the two instances sharing cached results. */
+export declare const ChartMovementSchema: z.ZodObject<{
+    movement_id: z.ZodString;
+    standard_slug: z.ZodString;
+    runtime_fills: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    seatings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        chair: z.ZodString;
+        agent_slug: z.ZodString;
+        technique_evidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            source: z.ZodString;
+            claim: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            source: string;
+            claim: string;
+        }, {
+            source: string;
+            claim: string;
+        }>, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        agent_slug: string;
+        chair: string;
+        technique_evidence?: {
+            source: string;
+            claim: string;
+        }[] | undefined;
+    }, {
+        agent_slug: string;
+        chair: string;
+        technique_evidence?: {
+            source: string;
+            claim: string;
+        }[] | undefined;
+    }>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    movement_id: string;
+    standard_slug: string;
+    runtime_fills: Record<string, unknown>;
+    seatings: {
+        agent_slug: string;
+        chair: string;
+        technique_evidence?: {
+            source: string;
+            claim: string;
+        }[] | undefined;
+    }[];
+}, {
+    movement_id: string;
+    standard_slug: string;
+    runtime_fills?: Record<string, unknown> | undefined;
+    seatings?: {
+        agent_slug: string;
+        chair: string;
+        technique_evidence?: {
+            source: string;
+            claim: string;
+        }[] | undefined;
+    }[] | undefined;
+}>;
+/** A human seat between movements. Parks on `deps.approvals[gate_id]`. */
+export declare const ChartApprovalGateSchema: z.ZodObject<{
+    gate_id: z.ZodString;
+    after_movement: z.ZodString;
+    before_movement: z.ZodString;
+    chair: z.ZodString;
+    prompt: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    chair: string;
+    gate_id: string;
+    after_movement: string;
+    before_movement: string;
+    prompt?: string | undefined;
+}, {
+    chair: string;
+    gate_id: string;
+    after_movement: string;
+    before_movement: string;
+    prompt?: string | undefined;
+}>;
+/** The ceiling for the whole performance, in real money. */
+export declare const ChartBudgetEnvelopeSchema: z.ZodObject<{
+    total_usd: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    total_usd: number;
+}, {
+    total_usd: number;
+}>;
+export declare const ChartSchema: z.ZodObject<{
+    slug: z.ZodString;
+    movements: z.ZodArray<z.ZodObject<{
+        movement_id: z.ZodString;
+        standard_slug: z.ZodString;
+        runtime_fills: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        seatings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            chair: z.ZodString;
+            agent_slug: z.ZodString;
+            technique_evidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                source: z.ZodString;
+                claim: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                source: string;
+                claim: string;
+            }, {
+                source: string;
+                claim: string;
+            }>, "many">>;
+        }, "strict", z.ZodTypeAny, {
+            agent_slug: string;
+            chair: string;
+            technique_evidence?: {
+                source: string;
+                claim: string;
+            }[] | undefined;
+        }, {
+            agent_slug: string;
+            chair: string;
+            technique_evidence?: {
+                source: string;
+                claim: string;
+            }[] | undefined;
+        }>, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        movement_id: string;
+        standard_slug: string;
+        runtime_fills: Record<string, unknown>;
+        seatings: {
+            agent_slug: string;
+            chair: string;
+            technique_evidence?: {
+                source: string;
+                claim: string;
+            }[] | undefined;
+        }[];
+    }, {
+        movement_id: string;
+        standard_slug: string;
+        runtime_fills?: Record<string, unknown> | undefined;
+        seatings?: {
+            agent_slug: string;
+            chair: string;
+            technique_evidence?: {
+                source: string;
+                claim: string;
+            }[] | undefined;
+        }[] | undefined;
+    }>, "many">;
+    edges: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        from_movement: z.ZodString;
+        to_movement: z.ZodString;
+        output_type: z.ZodString;
+        /** true = a CONDITIONAL edge: the type lives only in a terminal chair's `optional_outputs`,
+         *  so the flow may legitimately carry nothing. Compose classifies it; it cannot prove the
+         *  optional output will be produced, which is why a conditional edge never satisfies a
+         *  REQUIRED entry slot (src/chart.ts R6/R7). */
+        optional: z.ZodDefault<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        output_type: string;
+        from_movement: string;
+        to_movement: string;
+        optional: boolean;
+    }, {
+        output_type: string;
+        from_movement: string;
+        to_movement: string;
+        optional?: boolean | undefined;
+    }>, "many">>;
+    approval_gates: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        gate_id: z.ZodString;
+        after_movement: z.ZodString;
+        before_movement: z.ZodString;
+        chair: z.ZodString;
+        prompt: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        chair: string;
+        gate_id: string;
+        after_movement: string;
+        before_movement: string;
+        prompt?: string | undefined;
+    }, {
+        chair: string;
+        gate_id: string;
+        after_movement: string;
+        before_movement: string;
+        prompt?: string | undefined;
+    }>, "many">>;
+    budget_envelope: z.ZodOptional<z.ZodObject<{
+        total_usd: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        total_usd: number;
+    }, {
+        total_usd: number;
+    }>>;
+    /** The VENUE this performance is held in, by slug — a `VenueSchema` in the genome (below).
+     *
+     *  A slug, never an inline room: the venue is an institution-level object shared by whichever
+     *  arrangement is fit for it, so it is named here and defined once there. A slug that resolves
+     *  to no venue is a dead name and `composeChart` refuses the chart (R10), exactly as an
+     *  unresolvable tool grant refuses a dispatch.
+     *
+     *  Deliberately NOT folded into `chart_hash`: a room is environment, not structure. Two runs of
+     *  the same arrangement in differently-configured rooms share an arrangement identity; what
+     *  distinguishes them belongs to the run's own record, not the chart's. */
+    venue: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    slug: string;
+    movements: {
+        movement_id: string;
+        standard_slug: string;
+        runtime_fills: Record<string, unknown>;
+        seatings: {
+            agent_slug: string;
+            chair: string;
+            technique_evidence?: {
+                source: string;
+                claim: string;
+            }[] | undefined;
+        }[];
+    }[];
+    edges: {
+        output_type: string;
+        from_movement: string;
+        to_movement: string;
+        optional: boolean;
+    }[];
+    approval_gates: {
+        chair: string;
+        gate_id: string;
+        after_movement: string;
+        before_movement: string;
+        prompt?: string | undefined;
+    }[];
+    budget_envelope?: {
+        total_usd: number;
+    } | undefined;
+    venue?: string | undefined;
+}, {
+    slug: string;
+    movements: {
+        movement_id: string;
+        standard_slug: string;
+        runtime_fills?: Record<string, unknown> | undefined;
+        seatings?: {
+            agent_slug: string;
+            chair: string;
+            technique_evidence?: {
+                source: string;
+                claim: string;
+            }[] | undefined;
+        }[] | undefined;
+    }[];
+    edges?: {
+        output_type: string;
+        from_movement: string;
+        to_movement: string;
+        optional?: boolean | undefined;
+    }[] | undefined;
+    approval_gates?: {
+        chair: string;
+        gate_id: string;
+        after_movement: string;
+        before_movement: string;
+        prompt?: string | undefined;
+    }[] | undefined;
+    budget_envelope?: {
+        total_usd: number;
+    } | undefined;
+    venue?: string | undefined;
+}>;
+export type ChartInput = z.input<typeof ChartSchema>;
+export type ChartOutput = z.output<typeof ChartSchema>;
+export type ChartMovementOutput = z.output<typeof ChartMovementSchema>;
+export type ChartEdgeOutput = z.output<typeof ChartEdgeSchema>;
+export type ChartApprovalGateOutput = z.output<typeof ChartApprovalGateSchema>;
+export type ChartSeatingOutput = z.output<typeof ChartSeatingSchema>;
+/** The room's equipment: a deny-by-default allowlist of tool grants, in the same vocabulary as an
+ *  agent's `allowed_tools`. A venue with no tools holds nothing — not "read-only tools", nothing. */
+export declare const VenueEquipmentSchema: z.ZodObject<{
+    tools: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    tools: string[];
+}, {
+    tools?: string[] | undefined;
+}>;
+export declare const VenueDoorsSchema: z.ZodObject<{
+    ingress: z.ZodDefault<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+    egress: z.ZodDefault<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    ingress: string[];
+    egress: string[];
+}, {
+    ingress?: string[] | undefined;
+    egress?: string[] | undefined;
+}>;
+/** Lifecycle. Ephemeral is the default: the contract is the durable object and the realization is
+ *  disposable, because everything a standing room accumulates — drift, residue from prior gigs,
+ *  standing credentials, warm state — is exactly the class of thing no output's `input_shas` can
+ *  cover. `standing` is permitted as a named exception and owes a rebuild cadence (venueDefect). */
+export declare const VenueLifecycleSchema: z.ZodObject<{
+    policy: z.ZodDefault<z.ZodEnum<["ephemeral", "standing"]>>;
+    /** ISO-8601 duration or cron-shaped cadence — read by the responsible office, not the engine. */
+    rebuild_cadence: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    policy: "ephemeral" | "standing";
+    rebuild_cadence?: string | undefined;
+}, {
+    policy?: "ephemeral" | "standing" | undefined;
+    rebuild_cadence?: string | undefined;
+}>;
+export declare const VenueSchema: z.ZodObject<{
+    slug: z.ZodString;
+    /** Exactly one owning institution. The institution is the duty holder; the office below is the
+     *  appointed accountable individual. */
+    institution_slug: z.ZodString;
+    /** Why this room is shaped the way it is — read at review, never at runtime. */
+    description: z.ZodOptional<z.ZodString>;
+    /** The base kind of room (e.g. "ingest-empty", "code-work"). A label for humans and for
+     *  "which room does this work want", not a resolvable reference. */
+    flavor: z.ZodOptional<z.ZodString>;
+    /** Defaulted, not required, and the default is the EMPTY room. Every access-shaped field here
+     *  leans the same way: absent doors reach nothing, absent installs install nothing, an absent
+     *  credential surface permits nothing. A venue that forgot to state its equipment must hold
+     *  nothing rather than hold whatever the reader assumed — and both doors into this class (the
+     *  loader and venue_define) get that from the one schema rather than from two agreeing habits. */
+    equipment: z.ZodDefault<z.ZodObject<{
+        tools: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        tools: string[];
+    }, {
+        tools?: string[] | undefined;
+    }>>;
+    doors: z.ZodOptional<z.ZodObject<{
+        ingress: z.ZodDefault<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+        egress: z.ZodDefault<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        ingress: string[];
+        egress: string[];
+    }, {
+        ingress?: string[] | undefined;
+        egress?: string[] | undefined;
+    }>>;
+    /** Digest-pinned software the room contains. */
+    installs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Which CLASSES of credential may legitimately be present, by name. Never material, and never
+     *  a field material could occupy: a room that declares nothing here is a room where finding a
+     *  credential is a breach rather than a configuration difference. */
+    credential_surface: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    lifecycle: z.ZodDefault<z.ZodObject<{
+        policy: z.ZodDefault<z.ZodEnum<["ephemeral", "standing"]>>;
+        /** ISO-8601 duration or cron-shaped cadence — read by the responsible office, not the engine. */
+        rebuild_cadence: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        policy: "ephemeral" | "standing";
+        rebuild_cadence?: string | undefined;
+    }, {
+        policy?: "ephemeral" | "standing" | undefined;
+        rebuild_cadence?: string | undefined;
+    }>>;
+    /** The accountable office: an institutional chair id (the office, not its incumbent). One named
+     *  duty-holder answers for the room and for what it permits. */
+    responsible_chair: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    slug: string;
+    institution_slug: string;
+    equipment: {
+        tools: string[];
+    };
+    installs: string[];
+    credential_surface: string[];
+    lifecycle: {
+        policy: "ephemeral" | "standing";
+        rebuild_cadence?: string | undefined;
+    };
+    description?: string | undefined;
+    flavor?: string | undefined;
+    doors?: {
+        ingress: string[];
+        egress: string[];
+    } | undefined;
+    responsible_chair?: string | undefined;
+}, {
+    slug: string;
+    institution_slug: string;
+    description?: string | undefined;
+    flavor?: string | undefined;
+    equipment?: {
+        tools?: string[] | undefined;
+    } | undefined;
+    doors?: {
+        ingress?: string[] | undefined;
+        egress?: string[] | undefined;
+    } | undefined;
+    installs?: string[] | undefined;
+    credential_surface?: string[] | undefined;
+    lifecycle?: {
+        policy?: "ephemeral" | "standing" | undefined;
+        rebuild_cadence?: string | undefined;
+    } | undefined;
+    responsible_chair?: string | undefined;
+}>;
+export type VenueInput = z.input<typeof VenueSchema>;
+export type VenueOutput = z.output<typeof VenueSchema>;
+/**
+ * Cross-field venue rules — the ones a single field cannot state.
+ *
+ * A separate function rather than a `.superRefine`, on purpose and by the existing idiom
+ * (`domainTypeDefect` in src/registry.ts): the MCP write-surface is generated from
+ * `zodToMcpProps(VenueSchema)`, which needs a plain `ZodObject` with a `.shape`, and a refined
+ * schema is a `ZodEffects` that has neither. So both doors — the loader and `venue_define` — call
+ * `VenueSchema.safeParse` and then this, and a rule enforced at one door is enforced at both.
+ *
+ * Returns the teaching message, or null when the venue is sound.
+ */
+export declare function venueDefect(venue: VenueOutput): string | null;
 type JsonType = "string" | "number" | "boolean" | "array" | "object";
 /** The MCP `properties` map (field → JSON type) for a genome class schema. */
 export declare function zodToMcpProps(schema: z.ZodObject<z.ZodRawShape>): Record<string, JsonType>;