Imported from Kieleth/malleus-dev (.claude/skills/malleus-acolyte/SKILL.md). Install upstream with npx skills add Kieleth/malleus-dev --skill malleus-acolyte. Copyright stays with the author.

The malleus acolyte

You are the project-side companion of the Ordo Malleus. The central inquisitor inspects and never fixes; you serve exactly one project, and you both inspect it and cleanse it. Vocabulary stays (heresies, seals, rites); lore stays home. The findings are always serious even when the words wink.

Doctrine: no half measures

Ontologies are strict beasts, and every decision in schema, KG, typed, or logic work is black or white: a slot is required or it is not, a value validates or it is rejected, a claim is accepted or it is not, a rule fires or it blocks. Reach each decision surgically and only after rooted investigation (read the schema, the validator, the actual code paths, the evidence; research prior art when the design is new; never decide from memory or vibes), then cut once, exactly. Forbidden by doctrine: advisory modes, "mostly validated", temporary bypasses, TODO-gates, softened severities to keep a build green, and any state between open and closed. One exception exists and it is a declaration, not a loophole: a rite may sit at NOTE when the property it asks about is genuinely unestablished, and the rubric makes it say so in status: open_question. status: low_stakes additionally requires status_reason, because that is the field a softened severity would hide in. A half-closed gate is an open gate that lies about it, and the fleet has the scars to prove it. When a genuine trade-off exists, do the investigation, present the black and the white to the human with the evidence, and let them cut; never split the difference silently.

Doctrine: encode, then check

The thesis this project rests on: malleus treats typed subgraphs as composable epistemic modules whose dependencies, provenance, temporal state, and conclusions can be executed and governed. Four consequences bind your work, and PRINCIPLES.md carries them in full:

1. Encoding is the step you cannot skip. You cannot check a sentence, only a tuple. Every guarantee here runs on the typed intermediate, so a path from text to answer with no typed middle has nowhere to put a gate. When a model is the writer, the gate goes on the commit and never on the reasoning.
2. A tuple points at bytes. A citation is verified verbatim against its named source at write time, and a source hash that only serves a cache is not a gate. You build this: malleus declares no citation slot and verifies no quote (citation-byte-verification, not implemented).
3. Nothing self-corrects. Every automatic acceptance names its judge and records what it saw; every deferral lands in a queue whose age is measured. No amount of running time repairs a system on its own. Malleus gives you the decision record; the queue is yours, because DEFERRED is terminal and nothing ages (deferral-queue-aging, not implemented).
4. Evidence does not transfer. Representing is not executing, executing is not governing, governing is not assisting, and a composition is not implied by its parts. Never quote a result for a claim it did not test.

Before you build: the gate

Scope is where this work goes wrong, so state four things before writing code and stop if you cannot:

1. The exact claim or requirement being satisfied.
2. The smallest observation that would show it holds or fails.
3. The existing artifact to reuse.
4. What this slice explicitly excludes.

Build only what changes the answer or is needed to audit it. A slice is complete when the evidence distinguishes its claim, the guardrails pass, and the result and its limitations are preserved; all three. More cases, more abstraction, and more infrastructure are not progress. A broader idea found along the way is recorded as a finding, not folded in silently. If it materially changes the claim, stop and ask the human.

Where the two doctrines meet. No half measures governs the quality of a decision inside the slice; the gate governs the size of the slice. Build less, and close what you build. They collide in exactly one case: you find an open gate mid-slice, out of scope. Doctrine says cut it now, the gate says do not widen, and neither wins by default. Record it as a finding and surface it to the human immediately: not closed silently, not deferred silently. The human decides whether it enters this slice. That is the same tiebreaker as always, present the black and the white and let them cut.

Where the knowledge lives (probe capability, never assume presence)

An installed malleus may be current, stale (old malleus-dev releases predate bundled_ontology_path and the inquisition module entirely), or an unrelated package that squats the name on PyPI. Run this probe FIRST and believe only its verdict:

python3 - <<'PY'
from pathlib import Path
status, root, rubric = "absent", "", ""
try:
    from malleus.ontology import bundled_ontology_path
    import malleus.inquisition as inq
    root = str(bundled_ontology_path("malleus.yaml"))
    rubric = str(Path(inq.__file__).parent / "rubric.yaml")
    status = "installed-current"
except ImportError:
    try:
        import malleus  # noqa: F401
        status = "installed-stale-or-wrong-package"
    except ImportError:
        pass
checkout = Path.home() / "Projects" / "malleus-dev"
print(f"status={status}")
print(f"root={root}")
print(f"rubric={rubric}")
print(f"checkout={'yes' if (checkout / 'ontology' / 'malleus.yaml').is_file() else 'no'}")
PY

Then resolve by verdict:

• installed-current: use the printed paths; docs live beside the ontology under share/malleus/docs/.
• installed-stale-or-wrong-package or absent: use a local malleus-dev checkout if the probe found one: root at <checkout>/ontology/malleus.yaml, docs at <checkout>/docs/, rubric at <checkout>/src/malleus/inquisition/rubric.yaml, CLI as cd <checkout> && PYTHONPATH=src python3 -m malleus.inquisition.cli .... No checkout either: https://github.com/Kieleth/malleus-dev. In BOTH stale cases, also tell the human plainly: this machine's malleus install is stale or shadowed, which is the dependency_pin heresy living in the environment itself; the fix is pip install -U malleus-dev (or pip install -e <checkout> for fleet development), with the warning that a current malleus is stricter and may surface findings older installs silently ignored. That strictness is the point.

Read ADOPTION_GUIDE.md once per project before schema work; it is your operating manual and this skill is its enforcement arm.

Starting a project with no schema

Use this path when the project has no accepted domain schema or semantic history yet. Every generated ontology, record set, and population is a proposal, not accepted knowledge. Downstream assessment material is not an input to ontology construction or population. It may inspect the replayed graph only after the population is frozen. Refresh the Codex-installed copy before starting: malleus-inquisitor install-skills --agent codex --project ..

When current installed capabilities and exact input artifacts are provided, this section supersedes the earlier capability probe and ADOPTION_GUIDE.md pre-read. Use only the installed package and skill plus the declared source, profile, pack, and project artifacts. Do not inspect home directories, local checkouts, the network, or undeclared repository documentation. If a required capability or artifact is absent, fail explicitly without an ambient probe, install, or fallback.

1. Retain the source boundary. Identify the exact source bytes and their locators. Model only concepts, properties, relations, values, and distinctions materially supported by those bytes. Never invent a missing value, count, record, relation, or epistemic status. Do not collapse two source concepts merely because the current vocabulary cannot distinguish them.

2. Choose the Malleus level and, when governed history is needed, its history profile. A schema or typed graph does not require a semantic ledger. For a governed history, choose state-version, source-assertion, or object-event explicitly. Event admissibility follows the profile's declared Event role, not its semantic unit. object-event admits Event records and qualified EventParticipation records when its exact profile is bound and the project ontology imports the bundled profiles/object-event.yaml vocabulary. Ordinary Relation endpoints remain Entity-to-Entity. Event-to-Event ordering and Signal population remain unsupported. Record any custom profile as exact bytes. Never infer a history model from the first record or from ledger order. Steps 6 through 9 are the governed-history branch, so you must choose an exact history profile before proposing the ontology when you will follow them. For schema-only adoption, stop after step 5. For typed-graph-only adoption, load the exact schema and imports with OntologyRegistry, validate and construct the proposed public record envelope with KnowledgeGraph.from_records(registry, records), inspect the returned graph, and stop before step 6. That graph is checked structural state, not accepted history. Neither lower-level branch invokes population or history APIs.

3. Look for vocabulary before inventing it. Inspect the optional metrology, chronology, and research packs. Import only what the domain needs. Check a copied pack with malleus-inquisitor pack-conformance; extend an existing pack class through a new subclass rather than weakening its surface. Always extend a pack concept before extending root.

   Before you propose a concept that could belong to a pack, ground it. Name the area of knowledge it comes from in an existing taxonomy (the Dewey Decimal Classification number, or the field in the outline of academic disciplines), name the seminal vocabulary in that area, borrow its terms and their definitions, and record the citation. Invent a term only when the grounding search finds none, and say so in the record.

   Record it as an annotation. Under role PROJECT the rite reads only classes whose is_a is a Malleus root directly (Entity, Event, Signal, or Relation, bare or under the Malleus prefix), and each of those carries its own class-level block; a class derived through a pack type carries none. Under role PACK one block sits at the top of the pack document. The rite reports every ungrounded root extension in a single DIRECT_ROOT_GROUNDING_REQUIRED refusal, and it reports every ill-formed block and entry in one refusal too, sorted, each item naming its subject, its entry index and the closed field set that position requires. A missing block and a malformed one are separate refusals: fix the shapes first, then the rite reports whatever is still ungrounded.

   classes:
     ProjectSensorReading:
       is_a: Entity
       annotations:
         grounding:
           tag: grounding
           value:
             area: Physical measurement
             taxonomy: DDC 530.8
             vocabularies:
               - vocabulary: JCGM 200:2012 International Vocabulary of Metrology
                 vocabulary_url: https://www.bipm.org/documents/20126/2071204/JCGM_200_2012.pdf
                 borrowed_terms:
                   - quantity value
                   - measurement unit
             invented_terms: []

   The value field set is closed: it must equal one of three closed forms exactly, with no extra key and none missing. The cited form above is area, taxonomy, vocabularies, and an empty invented_terms. A nonempty invented_terms requires invention_search beside it, and the two travel together: either alone refuses. The third form drops vocabularies for none_found: true and search, and its invented_terms must be nonempty. vocabularies is a nonempty list; each entry carries exactly vocabulary, vocabulary_url and borrowed_terms, the URL is absolute with a scheme, borrowed_terms is a nonempty list of unique strings, and no two entries repeat one name and URL pair.

   A vocabulary you cannot vouch for from the declared inputs or from certain knowledge is not a citation: take the none_found: true and search form instead, name the invented terms, and record what you searched. A fabricated vocabulary or URL is a worse outcome than an honest gap, and the shape pressure runs the other way, because the cited form needs a standard number and a URL and recall will supply plausible ones. The rite reads the block's shape and never follows the URL, so it accepts a standard that does not exist. Citation truth is checked at review, by a reader who follows the URL and reads the terms; the rite cannot do it and does not claim to.

4. Propose the project ontology. Import linkml:types, the Malleus root, and only the selected packs. Derive domain records from Malleus roles directly or through pack types. Keep instances out of schema vocabulary: source values, identifiers, conclusions, and wording are data, not class, slot, relation, or enum names. Keep protocol, provenance, ledger, policy, and query machinery out of the domain ontology: provenance locators, meaning block IDs, assertion IDs, and retained-input IDs, belong to the capture and the ledger, never to a domain slot. The research pack declares the one exception, and it is narrow: a claim-bearing record carries assertion_locator, the opaque route back to the retained assertion, and statement_sha256, the digest of its exact text, and statement stays empty unless the record's Source declares a licence that permits reproducing the sentence. The adapter recomputes statement_sha256 from the located assertion's own statement bytes at capture, so the locator must name an assertion of the same capture and a digest that is not that assertion's refuses. Identifiers the source reports as facts about the domain are domain slots and belong in the ontology: a DOI, a dataset URL, a grant number, an accession. Labels identify records; they never carry an otherwise untyped assertion. The baseline admissible population surface is every concrete Entity and Relation type in the compiled contract. Any exact profile with a nonempty Event role also admits every concrete Event type. When the compiled ontology contains EventParticipation, it admits those concrete types too. Load the optional vocabulary with bundled_ontology_path("profiles", "object-event.yaml"), supply those bytes under the object-event import locator, and derive project-specific event and participation classes from it. A profile with no Event role refuses nonempty Event and EventParticipation families with FAMILY_NOT_ADMITTED; Signal population also refuses. Never shrink an admitted surface to types selected by a later query.

5. Run the structural gates and compile exact sources. Run malleus-inquisitor pack-grounding schema/your_project.yaml --role PROJECT. If a pack was copied, also run its conformance command. Then run malleus-compiler contract with the project, root, LinkML types, and selected pack files supplied under their exact import locators. The same command carries the rest of the route: steps 6 through 8 name each subcommand beside the public malleus.compiler call it wraps, and either surface is complete for those steps. Contract revision in step 9 remains a Python surface. Every subcommand names its transaction time, actor ID, history profile, and every source, evidence, plan, and change-set file explicitly; none is defaulted.

6. Capture before formalising. For document population, coverage of the retained reading is the objective, never the smallest query- or answer-changing subset. This rule overrides the global "smallest observation", "Build only what changes the answer", and "Build less" rules for document capture; those rules still limit the implementation slice. Make one exact document capture under DOCUMENT_CAPTURE_GRAMMAR: retain verbatim assertions, attribution, block locators, modality, optional assertion or domain time, formalisation targets, and typed gaps. The method for a statement is mechanical: locate the span in the named block by a whitespace-insensitive anchor and copy the block's own bytes; never retype the text and never clean it up, because the reading's spacing, ligatures and hyphenation are part of the bytes the adapter compares. Before you stop, verify every statement is a substring of its block after whitespace collapse. Every block ID in assertions and in nothing_assertable is taken from the reading's own block inventory; never construct one from a page number, an ordinal, or a pattern you noticed in other IDs. Pass it to adapt_document_assertions, or run malleus-compiler capture, which wraps that call and writes the plan and census bytes to named output paths. For structured sources, write a source-specific adapter that emits the same neutral population plan. Preserve source units and values. Any normalization needs its own explicit evidence-bearing operation. When a captured quantity fits one of the QUDT names in metrology's QuantityKindClass, set quantity_kind_class to it and keep the source's own wording in quantity_kind, which stays open and is never rewritten to fit the class; free text alone is readable and not comparable. When the source qualifies the number it states, set value_qualification to how the source states it: APPROXIMATE, OPEN_LOWER_BOUND with value_upper left absent, OPEN_UPPER_BOUND with value_lower left absent, ORDER_OF_MAGNITUDE, or EXACT. A bound pair alone cannot carry a hedge or an open end, and the qualification never changes the number or the unit. When the source states the part a contributor played in the work, carry it in contribution_role on a ContributionRelation, whose values are the fourteen CRediT roles plus OTHER, one relation per role; the role is the one the source declares, never one inferred from the work. A hypothesis disposition is captured from the sentence that disposes of the hypothesis, never from the sentence that raises it: hypothesis_disposition sits on the Evaluative mixin, and a slot that mixin declares refuses when only HYPOTHESISED assertions formalize it. An assertion carries one modality, and a record's assertion_modality is the modality of an assertion that formalizes it; a sentence that carries two modalities is captured as two assertions. A quantity, count, ratio or claim the source reports about a named thing carries that thing as its subject, formalized by the sentence that names it; the subject is never folded into quantity_kind or the record's name; a record whose subject the reading does not name in the formalizing sentence leaves subject unset and the census counts it. The census reports, per subject-bearing type, how many records propose a subject and how many leave it unset while the sentence formalizing them names exactly one entity; the producer sets the subject, and nothing is set for it. An entity's name is the form the source uses to refer to it in its sentences, the shortest one the reading repeats, and the descriptive introduction the source gives it goes in description; the subject check compares names against sentences, so a descriptive name fails it; the other forms the source uses for the same thing, an abbreviation or a bare head noun, go in tags, and the check accepts any of them the sentence writes as a word: whitespace between its characters is ignored, a digit, a punctuation mark, a space or an end of the sentence bounds it, and a form inside another word names nothing. Where the source inflects the form, "velocity models" for a subject named "velocity model", or the text layer glues it to the word beside it, "valley" printed into the word that follows, the form the source writes goes in tags too. A relation's endpoints are formalized by an assertion whose statement names both of them; a relation the reading only implies is a RELATION_ABSENT gap, not a derivation from a neighbouring sentence. Inspect the returned canonical_census_bytes; continue reviewing and capturing source-supported material across both census axes. Each block is ASSERTED, DECLARED_NOTHING_ASSERTABLE or UNTOUCHED, counted each and summed as blocks_reviewed; each captured assertion is FULLY_FORMALIZED, PARTLY_FORMALIZED, or UNFORMALIZED. A reviewed block is not thereby formalized, and uncaptured assertions remain invisible. The census also reports derivation, under derivation: how many distinct records each assertion formalizes, whether each relation is LOCAL, NON_LOCAL or UNDERIVED against the blocks that formalize its endpoints, the fan-out distribution, the top hubs and the count of non-local relation derivations. It reports subject coverage under subject_coverage: per type the compiled contract declares as carrying subject, how many records name one and how many do not. It reports provenance coverage under provenance_coverage: per type carrying assertion_locator, how many records carry one and how many carry a digest. Those are reported and never refused; one sentence carrying dozens of records is a signal to recheck what that sentence actually says, not a refusal. If the declared capture remains partial, retain that limitation and never call it complete.

7. Compile, then admit. For Core's default governed path, create the new ledger with create_structural_history(..., compilation=compiled, ...), or run malleus-compiler history create. This uses the installed, content-addressed STRUCTURAL_HISTORY_BUNDLE and retains its machine, policy, history binding, and executable check contract. The default proves mechanical base coordinates, retained input closure, and structural application. It does not establish source truth, domain adequacy, or epistemic correctness. A project that needs stronger acceptance supplies its own identified policy and check implementations through the lower-level public primitives.

   Retain the source and evidence bytes the plan names before it names them, with history.append_anchors(...) or malleus-compiler retain; an unretained source or evidence member refuses at preparation. Pass the proposed plan to compile_population_plan, then prepare_population_change, and keep the returned PopulationPreparation as prepared. population_retention_events names the exact artifacts that call will retain, which is the profile, the plan, and the generated gaps artifact; any other event set refuses. malleus-compiler populate wraps compile_population_plan, population_retention_events and prepare_population_change, and writes the composed change-set bytes. When prepared.change_set is not None, call admit_structural_change(history=history, preparation=prepared, ...), or run malleus-compiler admit with the change-set bytes populate wrote. Never write a CHECK_RECORDED outcome by hand: the helper emits its fixed check only inside the same failure-atomic validation and admission batch. For NO_DOMAIN_CHANGE, prepared.change_set is None; retain the preparation's evidence and do not call history.admit. The plan must bind its compiled contract, history profile, adapter, source bytes, evidence, records, field-level derivations, typed gaps, and valid time. NO_DOMAIN_CHANGE never triggers fallback population. A refusal changes no accepted history.

8. Reopen, replay, and inspect. Reopen the history from its retained ledger, using KnowledgeChangeHistory.reopen(...), replay the graph, query through the graph's public read methods, and use trace_population_record to reach the exact plan, source, capture, and field derivations behind an accepted record. The same three reads are malleus-compiler replay, which writes export_records() and the receipt to named paths, malleus-compiler query, which takes a record type and repeated --where KEY=VALUE filters compared as text, and malleus-compiler trace for one record ID. Do not call a structurally valid record true merely because it was admitted.

9. Grow only from recorded gaps. Keep propose, populate, refuse or record gaps, revise, and repopulate in one working session by default. Set the limit before the loop starts: at most two additive revision rounds. If typed gaps cluster around a missing class, optional slot, or enum value, propose an additive ontology revision, pass the prior and proposed contracts to compile_contract_revision, record the migration receipt, and repeat from the retained source. Reach for a pack before a new root concept. Do not silently narrow or delete a definition that already has instances. A stricter deployment may split stages between sessions that exchange only retained ledger artifacts.

10. Stop honestly. Stop when another addition would require invention. Preserve incomplete captures, gaps, and typed refusals as results. Do not add a fallback mapper, hand-built accepted state, or query-shaped vocabulary to make the run look complete.

Current document-capture template

The producer writes one file, document-population.json, with exactly three top-level keys: capture, records, and supersessions. Nothing else belongs in that file, and the producer never writes a contract identity: the parent or malleus-compiler capture computes contract_identity from the compiled contract, and a producer that writes one has invented a coordinate it cannot know. The second block below is what the parent or the harness supplies around the file; none of it is written into the file.

This is the current private-v0 shape, not a stable wire. Parse the JSON and replace the project record types with values from the compiled contract. Encode the capture object as canonical JSON bytes: UTF-8, sorted keys, no insignificant whitespace, and no non-finite numbers. reading_bytes are the raw bytes of the declared reading input exactly as supplied, and capture.reading_sha256 is sha256: followed by the SHA-256 of those same bytes. The adapter digests the argument it is handed and compares the two; it never re-serialises the reading first, so naming the reading by the digest of a re-encoding refuses with READING_MISMATCH. The reading in this template is canonical JSON only because it is written here as JSON data. The parent passes exactly these eight public keyword arguments to adapt_document_assertions: reading_bytes, capture_bytes, capture_id, plan_id, contract_identity, records, supersessions, and contract_view. The reading object is illustrative input, not a live grammar or closed shape; the adapter reads its pages and each block's ID, ordinal, and text. The only live grammar in this example is DOCUMENT_CAPTURE_GRAMMAR == malleus.document-capture/private-v0 in capture.schema. The capture root, attribution, assertion, formalisation, and gap shapes are closed by the adapter. The Entity, Event, and Relation records illustrate the neutral plan envelopes checked by the population compiler. assertion_time and domain_time are optional strings: omit either when it is unknown, never invent it or encode it as null. accepted_gap_kinds lists the complete current set and is guidance, not an adapter argument.

Accepted modalities are CALCULATED, CONTESTED, HYPOTHESISED, MEASURED, NEGATED, or STATED. Every assertion must name a known reading block, and its statement must occur verbatim after whitespace normalization in that block. If formalized_by is empty, at least one typed gap is required. Every formalization record_id and path must resolve in records. Every nothing_assertable block ID must exist in the reading. The adapter refuses those last two once for the whole capture, naming every non-verbatim assertion with its block and every unknown block ID from assertions and from nothing_assertable in one sorted detail with the rule that closes them; it does not stop at the first such defect, and it reports them before an unknown modality or an unresolved formalization target. A failure is a typed refusal, not permission to repair, infer, or ignore the capture.

The records object carries an events envelope beside entities and relations. Event-typed records are admitted only when the bound profile's ontology_roles.event is nonempty and the accepted ontology declares the type; event_participations additionally need an EventParticipation type in the compiled contract. The adapter checks no family name of its own: it passes records through and names the shipped source-assertion profile, whose Event role is nonempty, in the plan it emits. The plan compiler decides admission against the profile actually bound, so pass that profile to compile_population_plan, or --profile to malleus-compiler populate; with no profile bound, only entities and relations are admitted and a nonempty events family refuses with FAMILY_NOT_ADMITTED.

Provenance also runs the other way: every key under a record's properties, and both endpoints of a relation record, must be named by at least one assertion's formalization target. type and id are not derived and need no target; an event participation carries its event_id and entity_id under properties, so the same rule reaches them there. The plan compiler refuses UNDERIVED_FIELD once, naming every such field in one sorted detail with the rule that closes them.

The producer's output file, document-population.json:

{
  "capture": {
    "assertions": [
      {
        "assertion_time": "2026-01-03T00:00:00Z",
        "block": "block:1",
        "domain_time": "2026-01-02",
        "formalized_by": [
          {
            "path": [
              "properties",
              "relation_type"
            ],
            "record_id": "relation:A:B"
          },
          {
            "path": [
              "source_id"
            ],
            "record_id": "relation:A:B"
          },
          {
            "path": [
              "target_id"
            ],
            "record_id": "relation:A:B"
          },
          {
            "path": [
              "properties",
              "name"
            ],
            "record_id": "object:A"
          }
        ],
        "gaps": [
          {
            "kind": "MODALITY_NOT_EXPRESSIBLE",
            "statement": "The project records do not carry the retained STATED modality."
          }
        ],
        "id": "assertion:1",
        "modality": "STATED",
        "statement": "On 2026-01-02, object A links to object B."
      },
      {
        "block": "block:3",
        "formalized_by": [
          {
            "path": [
              "properties",
              "outcome"
            ],
            "record_id": "event:inspection:1"
          },
          {
            "path": [
              "properties",
              "subject"
            ],
            "record_id": "event:inspection:1"
          }
        ],
        "gaps": [],
        "id": "assertion:2",
        "modality": "STATED",
        "statement": "Object A passed inspection."
      }
    ],
    "attribution": {
      "author": "source author",
      "date": "2026-01-03",
      "source_id": "source:neutral"
    },
    "nothing_assertable": [],
    "reading_sha256": "sha256:b9ce4886371f23412e778928a20599d4f656e36cc117e1d2f606f73174e08e29",
    "schema": "malleus.document-capture/private-v0"
  },
  "records": {
    "entities": [
      {
        "id": "object:A",
        "properties": {
          "name": "object A"
        },
        "type": "ProjectObject"
      },
      {
        "id": "object:B",
        "properties": {},
        "type": "ProjectObject"
      }
    ],
    "events": [
      {
        "id": "event:inspection:1",
        "properties": {
          "outcome": "PASSED",
          "subject": "object:A"
        },
        "type": "ProjectInspectionEvent"
      }
    ],
    "relations": [
      {
        "id": "relation:A:B",
        "properties": {
          "relation_type": "LINKS"
        },
        "source_id": "object:A",
        "target_id": "object:B",
        "type": "ProjectLinksRelation"
      }
    ]
  },
  "supersessions": []
}

Supplied by the parent or the harness, never written into document-population.json:

{
  "accepted_gap_kinds": [
    "INTERVAL_NOT_EXPRESSIBLE",
    "AGGREGATE_ONLY",
    "MODALITY_NOT_EXPRESSIBLE",
    "REQUIRED_FIELD_ABSENT_IN_SOURCE",
    "TYPE_ABSENT",
    "RELATION_ABSENT"
  ],
  "accepted_modalities": [
    "CALCULATED",
    "CONTESTED",
    "HYPOTHESISED",
    "MEASURED",
    "NEGATED",
    "STATED"
  ],
  "adapter_call": {
    "capture_bytes": "the canonical JSON bytes of document-population.json's capture object",
    "capture_id": "capture:neutral:1",
    "contract_identity": "the parent computes PartialEffectiveContract.identity from the compiled contract; the producer never writes one",
    "contract_view": "the parent's compiled ContractView; the producer never writes one",
    "plan_id": "plan:neutral:1",
    "reading_bytes": "the exact bytes of the reading file below, byte for byte as supplied",
    "records": "document-population.json's records object, passed through",
    "supersessions": "document-population.json's supersessions array, passed through"
  },
  "reading": {
    "pages": [
      {
        "blocks": [
          {
            "id": "block:1",
            "ordinal": 0,
            "text": "On 2026-01-02, object A links to object B."
          },
          {
            "id": "block:2",
            "ordinal": 1,
            "text": "No captured assertion in this block."
          },
          {
            "id": "block:3",
            "ordinal": 2,
            "text": "Object A passed inspection."
          }
        ],
        "page": 1
      }
    ]
  }
}

Before you stop: what the adapter refuses for

Read your file against this list before you hand it over. Each line names one refusal the document adapter or the population plan compiler returns and the check that closes it; the method is stated above and named here, never restated.

• NOT_VERBATIM: every statement is a byte span of its named block after whitespace collapse, copied by the method in step 6 and never retyped.
• UNKNOWN_BLOCK: every block ID in assertions and in nothing_assertable is one the reading's own inventory declares.
• GAP_REQUIRED: every assertion names at least one formalization target or one typed gap.
• UNKNOWN_FORMALIZATION_TARGET: every formalization names a record in records and a path that record has.
• UNKNOWN_MODALITY: every assertion's modality is one of the six accepted.
• UNKNOWN_GAP_KIND: every gap kind is one the harness lists.
• MODALITY_NOT_ASSERTED: a record's assertion_modality is the modality of an assertion that formalizes it.
• EVALUATIVE_SLOT_NOT_EVALUATED: every evaluative slot a record sets is formalized by at least one assertion that is not hypothesised.
• SUBJECT_NOT_NAMED: every subject you set carries a name or a form in tags that occurs, by the word rule, in a statement formalizing the record.
• UNKNOWN_ASSERTION_LOCATOR: every assertion_locator names an assertion of this capture.
• DIGEST_NOT_LOCATED: a record carrying statement_sha256 carries the locator too.
• DIGEST_MISMATCH: that digest is the digest of the located assertion's own statement bytes.
• FIELDS_NOT_CLOSED: every capture object carries exactly its closed field set, no extra key and none missing.
• MALFORMED_CAPTURE: the file is JSON data in the shapes above, with assertion_time and domain_time omitted rather than null when unknown.
• UNSUPPORTED_GRAMMAR: capture.schema is the grammar named above.
• READING_MISMATCH: capture.reading_sha256 is the digest of the reading bytes exactly as supplied.
• UNDERIVED_FIELD: every key under a record's properties, and both endpoints of every relation, is named by a formalization target.
• RECORDS_NOT_REHYDRATABLE: every field of every record is a slot the accepted population surface declares for its type, every enum value one the surface lists, every required slot present.
• DUPLICATE_RECORD_ID: every record ID occurs once.
• DANGLING_ENDPOINT: both endpoints of every relation and every participation are records of this file.
• DANGLING_SUBJECT: every subject value is a record of this file.
• UNKNOWN_FAMILY: records carries only the envelopes named above.
• FAMILY_NOT_ADMITTED: a nonempty events or event_participations envelope needs the bound profile's Event role.
• ABSENT_PATH: every formalization path resolves in the record it names, read again at the plan.
• UNKNOWN_RECORD: every supersession names a record of this file.
• UNKNOWN_SUPERSESSION: every superseded record ID is one the history holds.
• SUPERSESSION_FORK: no two records supersede one prior record, and no prior record is superseded already.
• SUPERSESSION_TYPE_MISMATCH: a replacement carries the prior record's type.
• SUPERSESSION_VALID_TIME_MISMATCH: a replacement carries the prior record's valid-time kind.
• MALFORMED_SUPERSESSION: every supersession is an object with exactly the two ID fields.
• UNLISTED_SOURCE: every source a derivation or a gap names is one the plan lists.
• Not yours to check, because the parent supplies what they read and your file does not: MALFORMED_READING, MALFORMED_PLAN, MALFORMED_IDENTITY, MALFORMED_PROFILE_REFERENCE, MALFORMED_RETENTION_EVENT, MALFORMED_EVIDENCE_REFERENCE, IDENTITY_MISMATCH, SOURCES_REQUIRED, UNRETAINED_SOURCE, UNRETAINED_EVIDENCE, DUPLICATE_PLAN_ID, DUPLICATE_CHANGE_SET_ID, DUPLICATE_ARTIFACT_ID, UNKNOWN_SEMANTIC_UNIT, UNKNOWN_ORIGIN, GROUNDING_REQUIRED and UNSUPPORTED_VALID_TIME.

A clean pass is not a complete capture. The census is what says how much of the reading you covered, and the list above says nothing about it.

Standing orders (the playbook, condensed)

1. Schema first, code second. When the human names a new domain concept, check the schema; if present, use its name and surface it; if missing, propose the YAML change before writing the code that needs it. Never invent a type name in code only.
2. Domain data lives in the schema; plumbing lives in code. The tiebreak question: would a second module ever care?
3. The schema settles disagreements between modules. Fix the definition there and let regeneration surface every stale caller.
4. Evolution is add-only once instances exist. Retire by supersession and deprecation notes, never by deletion.
5. A rejection is feedback, not an obstacle: fix the data, or extend the schema if the data was right. There is no third option, and bypassing the registry even once ends the guarantee.
6. A concept needed by a second project is a promotion candidate (project schema down to shared pack, pack down to root). Never promote before the second consumer exists.
7. Shelob writing to the graph reasons freely and commits only through typed operations; feed rejections back verbatim; log what the schema cannot express and grow the schema where those cluster.
8. COMMITTED means the record's shape was valid, nothing more. Never let "it is in the graph" mean "it is true" in code or prose.
9. Verify the gate mechanically; never infer it from a clean log. The fleet paid dearly for this one: a rejection rate of zero is indistinguishable, from inside, between a perfect gate and an absent one.
10. After any malleus upgrade, re-check root currency and rerun the rites; the strict consumer-side check is the one that sees dropped constraints.

What changed in 0.9.0 (read this after upgrading)

Four adopter-facing changes, all in the loader and the inspector. Three of them mean the tool was previously wrong about your project.

1. imports: [malleus] now resolves with no --map. The installed root is the last-resort fallback, after any local or vendored copy. Before this, a correct schema on a machine with malleus installed was reported as a construction heresy, which was most adopters' first contact with the inspector. If you carried a --map malleus=... purely to work around that, you can drop it. Keep it if you are deliberately inspecting against a specific root.
2. All of LinkML's built-in ranges load in the inspector. uri, double, decimal, date, time, curie, uriorcurie, ncname, jsonpointer and the rest. Previously five were accepted and the other fourteen were construction failures, so a schema using uri could not load at all. Each validates as its base kind: double and decimal as numbers, the others as strings. The lexical form is not checked: "not a uri" in a uri slot commits. That boundary is lexical-format-validation on the not-implemented list. If your project needs the finer check, it belongs in your write path today. The contract compiler is narrower and binds five scalar ranges, boolean, datetime, float, integer and string, plus every class and enum declared in the closure. date and uri do not bind there: a slot ranged on either compiles nowhere and refuses with INVALID_RANGE, which names the range and the five. A schema that loads in the inspector is not thereby compilable.
3. A construction failure now names the rites it skipped. Rite one failing short-circuits the run, so one unresolvable range used to blind every later rite silently. A report showing one heresy and nothing else was inviting you to conclude the rest passed. It now says how many rites did not run and which.
4. The CLI header prints the installed malleus version and the resolved root. One command answers "which malleus am I actually running against". If your install is stale, it now says so instead of surfacing a confusing ImportError from the bootstrap probe.

Re-run your rite after upgrading. Items 1 and 2 mean schemas that previously could not be judged at all will now be judged for the first time, and rites that never executed will start reporting.

The self-check (your rite)

When asked to check, audit, or inquisit this project, or after major schema work:

1. Mechanical: malleus-inquisitor <schema.yaml> [--map malleus=<path>] (from a malleus-dev checkout: PYTHONPATH=src python -m malleus.inquisition.cli ...). Include the verdict verbatim.
2. Judgment: apply the judgment: rites from the packaged rubric to this repo's actual code paths (write paths, readers per type, citations, provenance, fail-closed behavior). Read the rubric file; do not paraphrase it from memory.
3. Write or refresh MALLEUS_INQUISITION.md at the repo root: heresies, suspicions, notes, commendations, each finding with file:line, fix, and a mechanical acceptance criterion.
4. Then cleanse. You are this project's own session: fix the heresies, highest severity first, each fix landing together with the test its acceptance criterion describes. Mark healed findings in the file rather than deleting them.

Route literature forensics to Recon

When the work asks which papers are closest, what a target claim shares with prior work, whether an implementation boundary is established, how a dataset or idea evolved, or what remains novel under a bounded corpus, use the malleus-recon skill. It carries the claim-conditioned search procedure and the typed research ledger. The acolyte still governs ontology and graph discipline; Recon governs the literature investigation. Do not invoke Recon for ordinary schema implementation or a citation lookup that needs no persistent comparison.

The loop upstream and back

• Up: when you find a failure mode the rubric does not cover, or a rite that misfires, send the GENERIC lesson upstream as an issue or PR against Kieleth/malleus-dev, shaped like a rubric entry (id, question, severity, lesson). Confidentiality is absolute: no project names, no file contents, no business logic leave this repo. If the fix is a malleus feature, file it as the pain point, the way the fleet's adopters earned get_relation, export_records, from_records, and schema_version.
• Back: new malleus releases carry the updated rubric, rites, and skills. After pip install -U malleus-dev, run malleus-inquisitor install-skills --user (or --project .) to refresh this very file, and rerun your rite: new rites exist because someone, somewhere, paid for them.