@eir-labs/coltrane 0.8.0 → 0.8.1

package/dist/src/genome_schema.d.ts

@@ -541,6 +541,18 @@ export declare const ChairSchema: z.ZodObject<{
      *  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>>;
+    /** The guaranteed turn floor, declared on the WORK (the chair) rather than the player (the
+     *  agent's `max_tool_calls`). Resolves chair > agent > engine default at invocation. OPTIONAL
+     *  so every existing chair record parses byte-equivalent — a Zod object DROPS an undeclared key,
+     *  so the field must be declared here to be RETAINED. A non-negative INTEGER: a negative or
+     *  non-integer cap fails closed at load, never reaching resolution. 0 is a deliberate hard floor,
+     *  parsed as 0 and kept DISTINCT from absent (which falls through to the agent tier). */
+    turn_budget: z.ZodOptional<z.ZodNumber>;
+    /** The per-chair elasticity ceiling on the shared per-gig reserve pool: the most this chair may
+     *  ever draw when it exhausts its budget — no theft even when the pool is larger. Same additive,
+     *  fail-closed, integer discipline as `turn_budget`. May be declared WITHOUT `turn_budget`: the
+     *  budget then falls through the resolution tiers while the reserve still bounds the draw. */
+    turn_reserve: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     role: string;
     depends_on: string[];
@@ -553,6 +565,8 @@ export declare const ChairSchema: z.ZodObject<{
     skill_slug?: string | undefined;
     human?: boolean | undefined;
     supplies?: Record<string, unknown> | undefined;
+    turn_budget?: number | undefined;
+    turn_reserve?: number | undefined;
 }, {
     role: string;
     agent_slug?: string | undefined;
@@ -565,6 +579,8 @@ export declare const ChairSchema: z.ZodObject<{
     required_skills?: string[] | undefined;
     preferred_skills?: string[] | undefined;
     supplies?: Record<string, unknown> | undefined;
+    turn_budget?: number | undefined;
+    turn_reserve?: number | undefined;
 }>;
 export declare const PhaseSchema: z.ZodObject<{
     name: z.ZodString;
@@ -593,6 +609,18 @@ export declare const PhaseSchema: z.ZodObject<{
          *  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>>;
+        /** The guaranteed turn floor, declared on the WORK (the chair) rather than the player (the
+         *  agent's `max_tool_calls`). Resolves chair > agent > engine default at invocation. OPTIONAL
+         *  so every existing chair record parses byte-equivalent — a Zod object DROPS an undeclared key,
+         *  so the field must be declared here to be RETAINED. A non-negative INTEGER: a negative or
+         *  non-integer cap fails closed at load, never reaching resolution. 0 is a deliberate hard floor,
+         *  parsed as 0 and kept DISTINCT from absent (which falls through to the agent tier). */
+        turn_budget: z.ZodOptional<z.ZodNumber>;
+        /** The per-chair elasticity ceiling on the shared per-gig reserve pool: the most this chair may
+         *  ever draw when it exhausts its budget — no theft even when the pool is larger. Same additive,
+         *  fail-closed, integer discipline as `turn_budget`. May be declared WITHOUT `turn_budget`: the
+         *  budget then falls through the resolution tiers while the reserve still bounds the draw. */
+        turn_reserve: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         role: string;
         depends_on: string[];
@@ -605,6 +633,8 @@ export declare const PhaseSchema: z.ZodObject<{
         skill_slug?: string | undefined;
         human?: boolean | undefined;
         supplies?: Record<string, unknown> | undefined;
+        turn_budget?: number | undefined;
+        turn_reserve?: number | undefined;
     }, {
         role: string;
         agent_slug?: string | undefined;
@@ -617,6 +647,8 @@ export declare const PhaseSchema: z.ZodObject<{
         required_skills?: string[] | undefined;
         preferred_skills?: string[] | undefined;
         supplies?: Record<string, unknown> | undefined;
+        turn_budget?: number | undefined;
+        turn_reserve?: number | undefined;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     name: string;
@@ -632,6 +664,8 @@ export declare const PhaseSchema: z.ZodObject<{
         skill_slug?: string | undefined;
         human?: boolean | undefined;
         supplies?: Record<string, unknown> | undefined;
+        turn_budget?: number | undefined;
+        turn_reserve?: number | undefined;
     }[];
 }, {
     name: string;
@@ -647,6 +681,8 @@ export declare const PhaseSchema: z.ZodObject<{
         required_skills?: string[] | undefined;
         preferred_skills?: string[] | undefined;
         supplies?: Record<string, unknown> | undefined;
+        turn_budget?: number | undefined;
+        turn_reserve?: number | undefined;
     }[];
 }>;
 /** Lifecycle status, shared by domain types and standards (#203). */
@@ -684,6 +720,18 @@ export declare const StandardSchema: z.ZodObject<{
              *  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>>;
+            /** The guaranteed turn floor, declared on the WORK (the chair) rather than the player (the
+             *  agent's `max_tool_calls`). Resolves chair > agent > engine default at invocation. OPTIONAL
+             *  so every existing chair record parses byte-equivalent — a Zod object DROPS an undeclared key,
+             *  so the field must be declared here to be RETAINED. A non-negative INTEGER: a negative or
+             *  non-integer cap fails closed at load, never reaching resolution. 0 is a deliberate hard floor,
+             *  parsed as 0 and kept DISTINCT from absent (which falls through to the agent tier). */
+            turn_budget: z.ZodOptional<z.ZodNumber>;
+            /** The per-chair elasticity ceiling on the shared per-gig reserve pool: the most this chair may
+             *  ever draw when it exhausts its budget — no theft even when the pool is larger. Same additive,
+             *  fail-closed, integer discipline as `turn_budget`. May be declared WITHOUT `turn_budget`: the
+             *  budget then falls through the resolution tiers while the reserve still bounds the draw. */
+            turn_reserve: z.ZodOptional<z.ZodNumber>;
         }, "strip", z.ZodTypeAny, {
             role: string;
             depends_on: string[];
@@ -696,6 +744,8 @@ export declare const StandardSchema: z.ZodObject<{
             skill_slug?: string | undefined;
             human?: boolean | undefined;
             supplies?: Record<string, unknown> | undefined;
+            turn_budget?: number | undefined;
+            turn_reserve?: number | undefined;
         }, {
             role: string;
             agent_slug?: string | undefined;
@@ -708,6 +758,8 @@ export declare const StandardSchema: z.ZodObject<{
             required_skills?: string[] | undefined;
             preferred_skills?: string[] | undefined;
             supplies?: Record<string, unknown> | undefined;
+            turn_budget?: number | undefined;
+            turn_reserve?: number | undefined;
         }>, "many">;
     }, "strip", z.ZodTypeAny, {
         name: string;
@@ -723,6 +775,8 @@ export declare const StandardSchema: z.ZodObject<{
             skill_slug?: string | undefined;
             human?: boolean | undefined;
             supplies?: Record<string, unknown> | undefined;
+            turn_budget?: number | undefined;
+            turn_reserve?: number | undefined;
         }[];
     }, {
         name: string;
@@ -738,6 +792,8 @@ export declare const StandardSchema: z.ZodObject<{
             required_skills?: string[] | undefined;
             preferred_skills?: string[] | undefined;
             supplies?: Record<string, unknown> | undefined;
+            turn_budget?: number | undefined;
+            turn_reserve?: number | undefined;
         }[];
     }>, "many">;
     eval_slugs: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString, "many">>>;
@@ -745,6 +801,11 @@ export declare const StandardSchema: z.ZodObject<{
     output_types: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString, "many">>>;
     max_examine_rounds: z.ZodOptional<z.ZodNumber>;
     description: z.ZodOptional<z.ZodString>;
+    /** The DEFAULT gig-level reserve pool: a per-gig quantity of turns a budget-exhausted chair may
+     *  draw from, capped per chair by its own `turn_reserve`. The DISPATCH payload's `pool` (on the
+     *  budget input) is the primary source and OVERRIDES this default deterministically when both are
+     *  present (no max, no sum). Optional + non-negative integer, additive like the chair fields. */
+    reserve_pool: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     slug: string;
     domain: string;
@@ -762,6 +823,8 @@ export declare const StandardSchema: z.ZodObject<{
             skill_slug?: string | undefined;
             human?: boolean | undefined;
             supplies?: Record<string, unknown> | undefined;
+            turn_budget?: number | undefined;
+            turn_reserve?: number | undefined;
         }[];
     }[];
     status?: "active" | "retired" | "deprecated" | undefined;
@@ -772,6 +835,7 @@ export declare const StandardSchema: z.ZodObject<{
     agent_slugs?: string[] | undefined;
     eval_slugs?: readonly string[] | undefined;
     max_examine_rounds?: number | undefined;
+    reserve_pool?: number | undefined;
 }, {
     slug: string;
     domain: string;
@@ -789,6 +853,8 @@ export declare const StandardSchema: z.ZodObject<{
             required_skills?: string[] | undefined;
             preferred_skills?: string[] | undefined;
             supplies?: Record<string, unknown> | undefined;
+            turn_budget?: number | undefined;
+            turn_reserve?: number | undefined;
         }[];
     }[];
     status?: "active" | "retired" | "deprecated" | undefined;
@@ -799,6 +865,7 @@ export declare const StandardSchema: z.ZodObject<{
     agent_slugs?: string[] | undefined;
     eval_slugs?: readonly string[] | undefined;
     max_examine_rounds?: number | undefined;
+    reserve_pool?: number | undefined;
 }>;
 export type StandardInput = z.input<typeof StandardSchema>;
 export type StandardOutput = z.output<typeof StandardSchema>;
@@ -882,11 +949,198 @@ export declare const LineageRecordRefSchema: z.ZodObject<{
     sealed_at?: string | undefined;
 }>;
 export type LineageRecordRefOutput = z.output<typeof LineageRecordRefSchema>;
+/** A CITATION of external published work, shaped so it can be checked rather than admired.
+ *
+ *  The genome had no way to say "this schema class implements that paper." `ForebearSchema` is
+ *  person-shaped (it carries a working disposition taken from a named figure, not a bibliographic
+ *  record) and `LineageEdgeSchema.source` is `z.record(z.unknown())`, so a presence check on it
+ *  passes on `{}`. The gate in `default_genome_quartet.test.ts` already states the bar — "an
+ *  uncited attribution is a claim, not a record" — but had no shape able to enforce it.
+ *
+ *  The refinement below is the citation's analogue of `InstitutionalLawCheckSchema`: an
+ *  institutional law is authorable only if it reduces to an evaluable predicate over typed inputs,
+ *  and a citation stands only if it reduces to a resolvable identifier. Prose that cannot be
+ *  checked does not get to be a record — same refusal, same grounds, both enforced at authorship.
+ *
+ *  `evidence_grade` types the distinction the diplomatics tradition draws and this codebase had
+ *  only ever narrated: ARCHIVE — the primary was fetched, and `retrieved_at` says when — versus
+ *  ATTESTATION — someone declared it. The grade is recorded and never laundered upward. */
+export declare const CitationSchema: z.ZodEffects<z.ZodObject<{
+    /** Author names as cited, e.g. "Crawford, S.E.S.". At least one — an anonymous citation is a rumour. */
+    authors: z.ZodArray<z.ZodString, "many">;
+    year: z.ZodNumber;
+    title: z.ZodString;
+    /** Journal, publisher, or conference. */
+    venue: z.ZodString;
+    /** Volume/issue/pages or equivalent, e.g. "89(3): 582–600". */
+    locator: z.ZodOptional<z.ZodString>;
+    doi: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    /** ARCHIVE = the primary was fetched. ATTESTATION = it was declared. Never laundered upward. */
+    evidence_grade: z.ZodEnum<["archive", "attestation"]>;
+    /** When the primary was fetched. An archive-grade claim is a claim about a fetch that happened. */
+    retrieved_at: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    authors: string[];
+    year: number;
+    title: string;
+    venue: string;
+    evidence_grade: "archive" | "attestation";
+    locator?: string | undefined;
+    doi?: string | undefined;
+    url?: string | undefined;
+    retrieved_at?: string | undefined;
+}, {
+    authors: string[];
+    year: number;
+    title: string;
+    venue: string;
+    evidence_grade: "archive" | "attestation";
+    locator?: string | undefined;
+    doi?: string | undefined;
+    url?: string | undefined;
+    retrieved_at?: string | undefined;
+}>, {
+    authors: string[];
+    year: number;
+    title: string;
+    venue: string;
+    evidence_grade: "archive" | "attestation";
+    locator?: string | undefined;
+    doi?: string | undefined;
+    url?: string | undefined;
+    retrieved_at?: string | undefined;
+}, {
+    authors: string[];
+    year: number;
+    title: string;
+    venue: string;
+    evidence_grade: "archive" | "attestation";
+    locator?: string | undefined;
+    doi?: string | undefined;
+    url?: string | undefined;
+    retrieved_at?: string | undefined;
+}>;
+/** How a genome schema class stands to the published work behind it.
+ *
+ *  Deliberately NOT `LineageEdgeTypeSchema`. That enum is the CAPABILITY vocabulary — "Caps grant
+ *  these" — and widening it to fit scholarship would widen what a capability grant can scope. The
+ *  two are different acts: `anchored-in` says nothing about a paper, `diverges-from` says nothing
+ *  as a permission. This enum mirrors the `lineage-map` domain type's relations exactly, so a
+ *  lineage pass's connection becomes an attribution with no translation step and no finding that
+ *  the genome cannot write down.
+ *
+ *  `diverges-from` is load-bearing, not decorative: this codebase HAS a deliberate divergence
+ *  (chair obligations are stated and never verified, against Fuller's congruence principle), and a
+ *  vocabulary that can only express descent would force that either into silence or into a false
+ *  claim of alignment. */
+export declare const AttributionRelationSchema: z.ZodEnum<["descends-from", "aligns-with", "diverges-from", "supersedes", "informed-by"]>;
+/** Binds one genome schema class to the published work behind it. `what_taken` keeps
+ *  `ForebearSchema`'s word: an attribution names what was taken, not merely what was read. */
+export declare const SchemaAttributionSchema: z.ZodObject<{
+    /** The attributed schema class, by its exported name, e.g. "InstitutionalLawSchema". */
+    subject: z.ZodString;
+    relation: z.ZodEnum<["descends-from", "aligns-with", "diverges-from", "supersedes", "informed-by"]>;
+    what_taken: z.ZodString;
+    citation: z.ZodEffects<z.ZodObject<{
+        /** Author names as cited, e.g. "Crawford, S.E.S.". At least one — an anonymous citation is a rumour. */
+        authors: z.ZodArray<z.ZodString, "many">;
+        year: z.ZodNumber;
+        title: z.ZodString;
+        /** Journal, publisher, or conference. */
+        venue: z.ZodString;
+        /** Volume/issue/pages or equivalent, e.g. "89(3): 582–600". */
+        locator: z.ZodOptional<z.ZodString>;
+        doi: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        /** ARCHIVE = the primary was fetched. ATTESTATION = it was declared. Never laundered upward. */
+        evidence_grade: z.ZodEnum<["archive", "attestation"]>;
+        /** When the primary was fetched. An archive-grade claim is a claim about a fetch that happened. */
+        retrieved_at: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        authors: string[];
+        year: number;
+        title: string;
+        venue: string;
+        evidence_grade: "archive" | "attestation";
+        locator?: string | undefined;
+        doi?: string | undefined;
+        url?: string | undefined;
+        retrieved_at?: string | undefined;
+    }, {
+        authors: string[];
+        year: number;
+        title: string;
+        venue: string;
+        evidence_grade: "archive" | "attestation";
+        locator?: string | undefined;
+        doi?: string | undefined;
+        url?: string | undefined;
+        retrieved_at?: string | undefined;
+    }>, {
+        authors: string[];
+        year: number;
+        title: string;
+        venue: string;
+        evidence_grade: "archive" | "attestation";
+        locator?: string | undefined;
+        doi?: string | undefined;
+        url?: string | undefined;
+        retrieved_at?: string | undefined;
+    }, {
+        authors: string[];
+        year: number;
+        title: string;
+        venue: string;
+        evidence_grade: "archive" | "attestation";
+        locator?: string | undefined;
+        doi?: string | undefined;
+        url?: string | undefined;
+        retrieved_at?: string | undefined;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    subject: string;
+    relation: "descends-from" | "aligns-with" | "diverges-from" | "supersedes" | "informed-by";
+    what_taken: string;
+    citation: {
+        authors: string[];
+        year: number;
+        title: string;
+        venue: string;
+        evidence_grade: "archive" | "attestation";
+        locator?: string | undefined;
+        doi?: string | undefined;
+        url?: string | undefined;
+        retrieved_at?: string | undefined;
+    };
+}, {
+    subject: string;
+    relation: "descends-from" | "aligns-with" | "diverges-from" | "supersedes" | "informed-by";
+    what_taken: string;
+    citation: {
+        authors: string[];
+        year: number;
+        title: string;
+        venue: string;
+        evidence_grade: "archive" | "attestation";
+        locator?: string | undefined;
+        doi?: string | undefined;
+        url?: string | undefined;
+        retrieved_at?: string | undefined;
+    };
+}>;
+export type AttributionRelation = z.output<typeof AttributionRelationSchema>;
+export type CitationOutput = z.output<typeof CitationSchema>;
+export type SchemaAttributionOutput = z.output<typeof SchemaAttributionSchema>;
 /** An institutional LAW as an invocable, machine-checkable contract rather than prose.
  *
- *  Follows Crawford & Ostrom's ADICO grammar — Attributes (who it binds), Deontic
- *  (permitted | obliged | forbidden), aIm (the action or state governed), Conditions (when it
- *  applies), Or-else (the consequence on breach) — the deontic operator drawn from deontic logic.
+ *  Descends from Crawford, S.E.S. & Ostrom, E. (1995), "A Grammar of Institutions," American
+ *  Political Science Review 89(3): 582–600, doi:10.2307/2082975 — the ADICO grammar: Attributes
+ *  (who it binds), Deontic (permitted | obliged | forbidden), aIm (the action or state governed),
+ *  Conditions (when it applies), Or-else (the consequence on breach). Or-else is the slot that
+ *  separates a RULE (ADICO) from a norm (ADIC) and a strategy (AIC), which is why it is required
+ *  here: a statement with no consequence on breach is not a law in this genome. The formal
+ *  attribution is carried as data in GENOME_ATTRIBUTIONS below, not only in this comment.
  *  `check` is the machine-checkable surface: a normalized, serializable predicate an evaluator can
  *  invoke plus the typed inputs it reads (design-by-contract). The evaluator that RUNS the
  *  predicate is a follow-on; this is the shape it consumes. STRICT: an ADICO record with an unknown
@@ -952,23 +1206,48 @@ export declare const InstitutionalLawSchema: z.ZodObject<{
  *  change-request specifies for obligations: who it binds (`attributes`) and the action or state
  *  governed (`aim`), with `deontic` defaulting to `obliged` (an obligation is obliged unless it
  *  says otherwise). Not the full law: conditions / or_else / check are institution-level, not a
- *  burden every chair obligation carries. */
+ *  burden every chair obligation carries.
+ *
+ *  The pair is I/O logic's — Makinson, D. & van der Torre, L. (2000), "Input/Output Logics,"
+ *  Journal of Philosophical Logic 29(4): 383–408, doi:10.1023/A:1004748624537 — which writes a norm
+ *  as (a, x): body `a` the input condition (here the chair and its situation) and head `x` the
+ *  deontic output, read O(x|a), "x is obligatory given a." That is why obligations can drop the
+ *  law's other three slots without becoming prose: the pair is already the complete normative unit.
+ *  Formal attribution in GENOME_ATTRIBUTIONS below. */
 export declare const NormPairSchema: z.ZodObject<{
     attributes: z.ZodString;
     aim: z.ZodString;
     deontic: z.ZodDefault<z.ZodEnum<["permitted", "obliged", "forbidden"]>>;
+    /** ADDITIVE, OPTIONAL obligation-tier mark. An obligation states whether it is a stated norm or
+     *  a verified rule: "declared" says there is no runtime verifier, "enforced" claims a verifier
+     *  backs it. ABSENT-parses-fine, so every pre-existing file round-trips byte-equivalent (a Zod
+     *  object drops an undeclared key, so the field must be declared HERE to be retained). The
+     *  admissibility check (checkInstitutionAdmissibility in institution_enforcement.ts) refuses an
+     *  UNMARKED obligation — the marking is how a document states its enforced/declared split
+     *  rather than leaving silence to pass a norm off as a rule. */
+    tier: z.ZodOptional<z.ZodEnum<["declared", "enforced"]>>;
 }, "strict", z.ZodTypeAny, {
     attributes: string;
     deontic: "permitted" | "obliged" | "forbidden";
     aim: string;
+    tier?: "declared" | "enforced" | undefined;
 }, {
     attributes: string;
     aim: string;
+    tier?: "declared" | "enforced" | undefined;
     deontic?: "permitted" | "obliged" | "forbidden" | undefined;
 }>;
 export type DeonticOperator = z.output<typeof DeonticSchema>;
 export type InstitutionalLawOutput = z.output<typeof InstitutionalLawSchema>;
 export type NormPairOutput = z.output<typeof NormPairSchema>;
+/** Where a genome schema class implements published prior art, the attribution lives HERE as data
+ *  — parseable, dereferenceable, and gradeable — rather than only as a name-drop in a comment a
+ *  reader must take on faith. Both entries below were fetched from publisher/registry on the
+ *  recorded date, which is what earns them `archive` rather than `attestation`.
+ *
+ *  Additive and read-only: nothing in dispatch or hashing consumes this, so an entry here moves no
+ *  genome_hash. It is a record of descent, held to the same bar as any other record in this repo. */
+export declare const GENOME_ATTRIBUTIONS: readonly SchemaAttributionOutput[];
 export declare const InstitutionSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     slug: z.ZodString;
@@ -1272,13 +1551,23 @@ export declare const InstitutionalChairSchema: z.ZodObject<{
         attributes: z.ZodString;
         aim: z.ZodString;
         deontic: z.ZodDefault<z.ZodEnum<["permitted", "obliged", "forbidden"]>>;
+        /** ADDITIVE, OPTIONAL obligation-tier mark. An obligation states whether it is a stated norm or
+         *  a verified rule: "declared" says there is no runtime verifier, "enforced" claims a verifier
+         *  backs it. ABSENT-parses-fine, so every pre-existing file round-trips byte-equivalent (a Zod
+         *  object drops an undeclared key, so the field must be declared HERE to be retained). The
+         *  admissibility check (checkInstitutionAdmissibility in institution_enforcement.ts) refuses an
+         *  UNMARKED obligation — the marking is how a document states its enforced/declared split
+         *  rather than leaving silence to pass a norm off as a rule. */
+        tier: z.ZodOptional<z.ZodEnum<["declared", "enforced"]>>;
     }, "strict", z.ZodTypeAny, {
         attributes: string;
         deontic: "permitted" | "obliged" | "forbidden";
         aim: string;
+        tier?: "declared" | "enforced" | undefined;
     }, {
         attributes: string;
         aim: string;
+        tier?: "declared" | "enforced" | undefined;
         deontic?: "permitted" | "obliged" | "forbidden" | undefined;
     }>, "many">>;
 }, "strip", z.ZodTypeAny, {
@@ -1301,6 +1590,7 @@ export declare const InstitutionalChairSchema: z.ZodObject<{
         attributes: string;
         deontic: "permitted" | "obliged" | "forbidden";
         aim: string;
+        tier?: "declared" | "enforced" | undefined;
     }[];
     human?: boolean | undefined;
     supplies?: Record<string, unknown> | undefined;
@@ -1327,6 +1617,7 @@ export declare const InstitutionalChairSchema: z.ZodObject<{
     obligations?: {
         attributes: string;
         aim: string;
+        tier?: "declared" | "enforced" | undefined;
         deontic?: "permitted" | "obliged" | "forbidden" | undefined;
     }[] | undefined;
 }>;
@@ -1500,15 +1791,15 @@ export declare const ForebearSchema: z.ZodObject<{
     name: string;
     institution_slug: string;
     domain?: string | undefined;
-    kind?: string | undefined;
     what_taken?: string | undefined;
+    kind?: string | undefined;
 }, {
     slug: string;
     name: string;
     institution_slug: string;
     domain?: string | undefined;
-    kind?: string | undefined;
     what_taken?: string | undefined;
+    kind?: string | undefined;
 }>;
 export declare const NorthstarSchema: z.ZodObject<{
     slug: z.ZodString;
@@ -1521,8 +1812,8 @@ export declare const NorthstarSchema: z.ZodObject<{
     quote: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     slug: string;
-    institution_slug: string;
     title: string;
+    institution_slug: string;
     statement: string;
     kind?: string | undefined;
     source?: Record<string, unknown> | undefined;
@@ -1530,8 +1821,8 @@ export declare const NorthstarSchema: z.ZodObject<{
     quote?: string | undefined;
 }, {
     slug: string;
-    institution_slug: string;
     title: string;
+    institution_slug: string;
     statement: string;
     kind?: string | undefined;
     source?: Record<string, unknown> | undefined;
@@ -1901,10 +2192,10 @@ export declare const ChartSchema: z.ZodObject<{
         before_movement: string;
         prompt?: string | undefined;
     }[];
+    venue?: string | undefined;
     budget_envelope?: {
         total_usd: number;
     } | undefined;
-    venue?: string | undefined;
 }, {
     slug: string;
     movements: {
@@ -1920,6 +2211,7 @@ export declare const ChartSchema: z.ZodObject<{
             }[] | undefined;
         }[] | undefined;
     }[];
+    venue?: string | undefined;
     edges?: {
         output_type: string;
         from_movement: string;
@@ -1936,7 +2228,6 @@ export declare const ChartSchema: z.ZodObject<{
     budget_envelope?: {
         total_usd: number;
     } | undefined;
-    venue?: string | undefined;
 }>;
 export type ChartInput = z.input<typeof ChartSchema>;
 export type ChartOutput = z.output<typeof ChartSchema>;