@eir-labs/coltrane 0.7.5 → 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,12 +949,352 @@ 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.
+ *
+ *  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
+ *  field fails to parse. Each law carries its OWN `content_hash` (over its canonical ADICO
+ *  content), which canonical_form.ts already lists in EXCLUDED_FIELDS, so a law never moves the
+ *  institution's structural genome_hash — laws are hashed as content, not folded into structure. */
+export declare const DeonticSchema: z.ZodEnum<["permitted", "obliged", "forbidden"]>;
+export declare const InstitutionalLawCheckSchema: z.ZodObject<{
+    /** A normalized, serializable predicate (e.g. an s-expression) an evaluator invokes. */
+    predicate: z.ZodString;
+    /** The typed inputs the predicate reads: input name → its type name. */
+    inputs: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    predicate: string;
+    inputs: Record<string, string>;
+}, {
+    predicate: string;
+    inputs: Record<string, string>;
+}>;
+export declare const InstitutionalLawSchema: z.ZodObject<{
+    attributes: z.ZodString;
+    deontic: z.ZodEnum<["permitted", "obliged", "forbidden"]>;
+    aim: z.ZodString;
+    conditions: z.ZodString;
+    or_else: z.ZodString;
+    check: z.ZodObject<{
+        /** A normalized, serializable predicate (e.g. an s-expression) an evaluator invokes. */
+        predicate: z.ZodString;
+        /** The typed inputs the predicate reads: input name → its type name. */
+        inputs: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        predicate: string;
+        inputs: Record<string, string>;
+    }, {
+        predicate: string;
+        inputs: Record<string, string>;
+    }>;
+    content_hash: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    attributes: string;
+    deontic: "permitted" | "obliged" | "forbidden";
+    aim: string;
+    conditions: string;
+    or_else: string;
+    check: {
+        predicate: string;
+        inputs: Record<string, string>;
+    };
+    content_hash: string;
+}, {
+    attributes: string;
+    deontic: "permitted" | "obliged" | "forbidden";
+    aim: string;
+    conditions: string;
+    or_else: string;
+    check: {
+        predicate: string;
+        inputs: Record<string, string>;
+    };
+    content_hash: string;
+}>;
+/** A chair OBLIGATION as a deontic NORM PAIR — the deliberate structural SUBSET of ADICO the
+ *  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.
+ *
+ *  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;
     name: z.ZodString;
     kind: z.ZodEnum<["institution", "personal"]>;
-    laws: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    laws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        attributes: z.ZodString;
+        deontic: z.ZodEnum<["permitted", "obliged", "forbidden"]>;
+        aim: z.ZodString;
+        conditions: z.ZodString;
+        or_else: z.ZodString;
+        check: z.ZodObject<{
+            /** A normalized, serializable predicate (e.g. an s-expression) an evaluator invokes. */
+            predicate: z.ZodString;
+            /** The typed inputs the predicate reads: input name → its type name. */
+            inputs: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            predicate: string;
+            inputs: Record<string, string>;
+        }, {
+            predicate: string;
+            inputs: Record<string, string>;
+        }>;
+        content_hash: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        attributes: string;
+        deontic: "permitted" | "obliged" | "forbidden";
+        aim: string;
+        conditions: string;
+        or_else: string;
+        check: {
+            predicate: string;
+            inputs: Record<string, string>;
+        };
+        content_hash: string;
+    }, {
+        attributes: string;
+        deontic: "permitted" | "obliged" | "forbidden";
+        aim: string;
+        conditions: string;
+        or_else: string;
+        check: {
+            predicate: string;
+            inputs: Record<string, string>;
+        };
+        content_hash: string;
+    }>, "many">>;
     wiki_space: z.ZodOptional<z.ZodString>;
     sovereign: z.ZodDefault<z.ZodBoolean>;
     /** First-class lineage: references to approved lineage-records that ground this institution.
@@ -919,7 +1326,18 @@ export declare const InstitutionSchema: z.ZodObject<{
     slug: string;
     name: string;
     kind: "institution" | "personal";
-    laws: string[];
+    laws: {
+        attributes: string;
+        deontic: "permitted" | "obliged" | "forbidden";
+        aim: string;
+        conditions: string;
+        or_else: string;
+        check: {
+            predicate: string;
+            inputs: Record<string, string>;
+        };
+        content_hash: string;
+    }[];
     sovereign: boolean;
     lineage: {
         record_ref: string;
@@ -934,7 +1352,18 @@ export declare const InstitutionSchema: z.ZodObject<{
     name: string;
     kind: "institution" | "personal";
     id?: string | undefined;
-    laws?: string[] | undefined;
+    laws?: {
+        attributes: string;
+        deontic: "permitted" | "obliged" | "forbidden";
+        aim: string;
+        conditions: string;
+        or_else: string;
+        check: {
+            predicate: string;
+            inputs: Record<string, string>;
+        };
+        content_hash: string;
+    }[] | undefined;
     wiki_space?: string | undefined;
     sovereign?: boolean | undefined;
     lineage?: {
@@ -1118,7 +1547,29 @@ export declare const InstitutionalChairSchema: z.ZodObject<{
         standards: readonly string[];
         expires?: string | null | undefined;
     }>]>, "many">>;
-    obligations: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    obligations: z.ZodDefault<z.ZodArray<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, {
     function: "SENSE" | "INTERPRET" | "JUDGE" | "PLAN" | "CREATE" | "VERIFY";
     role: string;
@@ -1135,7 +1586,12 @@ export declare const InstitutionalChairSchema: z.ZodObject<{
         grant: "dispatch";
         standards: readonly string[];
     })[];
-    obligations: string[];
+    obligations: {
+        attributes: string;
+        deontic: "permitted" | "obliged" | "forbidden";
+        aim: string;
+        tier?: "declared" | "enforced" | undefined;
+    }[];
     human?: boolean | undefined;
     supplies?: Record<string, unknown> | undefined;
     id?: string | undefined;
@@ -1158,7 +1614,12 @@ export declare const InstitutionalChairSchema: z.ZodObject<{
         standards: readonly string[];
         expires?: string | null | undefined;
     })[] | undefined;
-    obligations?: string[] | undefined;
+    obligations?: {
+        attributes: string;
+        aim: string;
+        tier?: "declared" | "enforced" | undefined;
+        deontic?: "permitted" | "obliged" | "forbidden" | undefined;
+    }[] | undefined;
 }>;
 /** 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. */
@@ -1330,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;
@@ -1351,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;
@@ -1360,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;
@@ -1731,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: {
@@ -1750,6 +2211,7 @@ export declare const ChartSchema: z.ZodObject<{
             }[] | undefined;
         }[] | undefined;
     }[];
+    venue?: string | undefined;
     edges?: {
         output_type: string;
         from_movement: string;
@@ -1766,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>;