Namespace https://litlfred.github.io/cat-harness/v0/ns/. Machine-readable: index.jsonld.
cat-harness:FshGutsNode FshGutsNode — One item in the trashcan: something deprecated or thrown away, kept and addressable rather than deleted, and deliberately absent from the rendered site. Carries where it used to live, so it is not an orphan.cat-harness:Instance Instance — A repository carrying a harness declaration — it names itself, its published stub, and the directories it holds.cat-harness:Folio Folio — A repository that authors folio content — it declares a content type, and `folio_init` wrote its config. Distinct from an Instance: this repository's `cat-harness/` is an Instance and is not a Folio.cat-harness:SushiProject SushiProject — A repository SUSHI will build — FSH compiled to a FHIR implementation guide. Minted here because SUSHI publishes no logical model for its own config; this is our name for the membership, not a claim to define SUSHI.cat-harness:Convention Convention — A standing rule an actor must hold while performing a task, bound to a process, a lane or an activity rather than loaded unconditionally. Resolution is first-binding-wins along that order, not a merge, so a reader asking why a rule applies here gets one answer.cat-harness:QaAttestation QaAttestation — One subject's QA judgements — pair attestations, voice reviews, agent and human verdicts, bibliography verifications — kept as one `qa-attestations/v1` file in a layer's attestations store, each judgement pinned to the hash it attested so a stale one is detectable. The judgement half of a QA verdict: unlike a derived result, it cannot be regenerated.cat-harness:Voice Voice — A named editorial voice: a `folio-voice/v1` set of writing rules, each citing the passage of an ingested source or the knowledge-graph node it was read from. Opt-in per folio: shipping a voice does not apply it.cat-harness:Requirement Requirement — A stated need a change must satisfy, elicited and signed off in the CRDM process before implementation begins. Distinct from the issue that tracks it and the bean that plans the work.cat-harness:TranslationSource TranslationSource — One gettext source of a layer's translations: a `.po` catalogue of one locale's translated strings, or the `.pot` template it is made from. The input to injection; the rendered output declares its own `lang`.cat-harness:Lane Lane — A swimlane of one BPMN process: part of that process, naming the Role its tasks are performed in (`bindsRole`, BPMN's `partitionElementRef`). Not itself a role — a role is a registry node, and many lanes in many processes name it (#1168, B9b; owner, 2026-10-16).cat-harness:LaneUsage LaneUsage — One appearance of a glossary concept as a swimlane in one BPMN process — the process it is in, the label that process gave the lane, and that lane's own documentation. A usage is an occurrence, not a term: it is regenerated wholesale and never retired, while a concept is a term somebody may have cited.cat-harness:Theme Theme — A theme a layer derived from a source it holds — a served stylesheet or a style guide's stated rules: a palette and, for a sticky, its art, every value citing where it was measured. Kind `sticky`, `webpage` or `publication`.cat-harness:SkillPackage SkillPackage — A directory of skills shipped and versioned together.cat-harness:SoftwareLibrary SoftwareLibrary — An outside software package a layer's code imports, as its lockfile pins it: the version, the registry tarball and its digest, the SPDX licence, and the files that import it.cat-harness:Tool Tool — A Node Instance describing a program an Actor may run while carrying out a Task: what it takes, what it produces, and how to run it.cat-harness:Schema Schema — A schema definition, itself a node in the knowledge graph rather than an island beside one.cat-harness:ExternalSchema ExternalSchema — A published specification this corpus conforms to or reads — BPMN, DMN, ODRL, PROV-O — recorded by name and edition rather than copied in.cat-harness:Decision Decision — A DMN decision — a table that computes a gateway's branch from supplied facts, rather than a judgement somebody makes.cat-harness:Capability Capability — Something an actor's environment provides — a binary, a service, a credential — probed rather than assumed.cat-harness:Image Image — A declared picture belonging to an instance, carrying its role, its layout and any text region.cat-harness:RoleGraph RoleGraph — The role registry as a graph — every role, what it inherits, and the lanes it binds.cat-harness:FolioGraph FolioGraph — Authored content — the folio itself, rendered to a website.cat-harness:FshGutsGraph FshGutsGraph — The published export of an instance's fsh-guts tree: deprecated and throwaway structured content, reachable by name only.cat-harness:PreviewGraph PreviewGraph — A staging target: the same folio built for review rather than for release.cat-harness:UnknownGraph UnknownGraph — A declared graph typology nothing recognises — reported as its own state, never silently treated as empty.cat-harness:Block Block — One addressable unit of a folio's content — a paragraph, a theorem, a table — typed further by its block kind.cat-harness:SourceDocument SourceDocument — An external source a library holds — a paper, a report, a dataset — that blocks are ingested from and cite.cat-harness:WebPage WebPage — A page of a published site, as a node whose sections and assets are its parts.cat-harness:graphTypology/archimate archimate — ArchiMate models a layer holds, as Archi `.archimate` files (plain XML or Archi's zipped archive), named by `cat-archimate.config.json` (cat-harness's `archimate` subgraph). Every view, element and relationship in a model is a node of its own: a page and an IRI, keyed by Archi's own id, and every view is drawn as SVG from the model's diagram.cat-harness:graphTypology/attestations attestations — QA attestations — the judgements a QA family carries across runs (pair attestations, voice reviews, agent and human verdicts, bibliography verifications and human reviews), one `qa-attestations/v1` file per subject, mirroring the derived family's tree. Kept on main where deleting derived results cannot reach them; each entry pins the hash it attested, so a stale one is detectable.cat-harness:graphTypology/auto-docs auto-docs — Derived indexes over the other graphs — one page per auto-doc TYPE crossed with each SUB-GRAPH that type reaches. A sub-graph of `docs`, written by `scripts/gen-auto-docs.ts` and never by hand. Distinct from `docs` itself by the one question that settles the layer: a docs page is re-authored, an index is regenerated.cat-harness:graphTypology/basic-cdn-site basic-cdn-site — A published static site on a CDN that serves files by path only (GitHub Pages): its routes, the commit it was built from, and its files as archive entries. Built from the renderable graphs its directory names, and deployed by the Tool its storage names.cat-harness:graphTypology/bean-defs bean-defs — Work items — one Markdown file each, in the layout the `beans` CLI reads, carrying `$schema: bean/1.0.0` in its front matter. Authored and edited by people and agents.cat-harness:graphTypology/bean-notes bean-notes — Bean notes — one Markdown file per pull request per bean, `$schema: folio-bean-note/v1` in its front matter, named `<bean>--<date>--<branch>.md` so two pull requests never write one path. Indexed by a generated README.cat-harness:graphTypology/beans beans — The work plan — what is being worked on, and where each running BPMN instance got to. Its inner directories are declared by `beans/beans.json`.cat-harness:graphTypology/binary-release binary-release — Published binary releases -- one `folio-binary-release/v1` document per release, carrying its id, version and origin, and for each asset the size, the sha256 where one is known, where it is fetched from, and what became of it. Never the bytes: the schema is strict throughout, and a file a deploy phase deleted must still say where to get it back and why it went.cat-harness:graphTypology/block-kinds block-kinds — The block kinds a harness's adapter owns, one node per kind carrying its label prefix, RDF types, profile and builder. Discovered across the instances; no module lists them.cat-harness:graphTypology/board-positions board-positions — Where each note sits on each board — `board-positions.json`, keyed by board then by note id, in board units. The layout layer, which points at notes and is never pointed back at. Schema: `schemas/ui/board-positions.ts`.cat-harness:graphTypology/boards boards — Boards — one JSON file each, carrying `"$schema": "folio-board/v1"`. A board is a diagram OF a folio: it declares what it shows, and a folio with no board is complete. Schema: `schemas/ui/board.ts`.cat-harness:graphTypology/building-blocks building-blocks — Building-block catalogues -- layers and blocks (tools, systems, standards, trust networks) with their jurisdiction and what each is, the targets of a journey step's `uses` edges.cat-harness:graphTypology/business-processes business-processes — BPMN that describes work as content (a guideline's business processes), drawn by the processes viewer and never run.cat-harness:graphTypology/cache cache — CI caches -- one `cache/1.0.0` node per cache a layer declares: key recipe, trust class, location, producer, consumers, save policy, verify and budget. Never the entries; the stored key, size and hit rate come from the daily cache report, so staleness is computed, never claimed.cat-harness:graphTypology/cat-harness cat-harness — A Subgraph holding a Harness's own parts, such as Skills, Processes and Roles, where one directory holds more than one of them.cat-harness:graphTypology/catalogue catalogue — A remote catalogue modelled by reference — communities, collections and items of a corpus the layer does not hold. Every node declares whether its bytes are here (`materialized`), elsewhere (`referenced`) or unestablished (`unknown`), with no default. Distinct from `library`, which is content that IS here.cat-harness:graphTypology/cdn-site cdn-site — A published site on a CDN that also controls media types, redirects and headers: a `basic-cdn-site` plus those three. No instance declares one yet.cat-harness:graphTypology/code code — Source code -- the modules, scripts and entry points an instance holds. Declared so that code is scannable at all: an undeclared file is one no checker has a reason to look at. Being declared here says nothing about whether a Tool node claims it, which is a separate question and a separate axis.cat-harness:graphTypology/code-list code-list — Closed sets of codes — adjudication answers, the namespaces this project mints — one file per list, every code carrying its definition and source, published as SKOS.cat-harness:graphTypology/conjectures conjectures — A paper folio's open-problem register: one `folio-conjecture-register/v1` node per conjecture block, tracking its formal-vs-identification classification, DMN-computed status lifecycle, Lean stub, critical-path theorems that assume it (`lean-formal-graph` reverse edges), and work-traceability attempts.cat-harness:graphTypology/content-adapters content-adapters — The block vocabularies a harness owns, one node per vocabulary carrying its companion roles and whether the platform's code types it. Discovered across the instances; no module lists them.cat-harness:graphTypology/device-screen device-screen — Device screens -- what one person sees on one device at a journey step, as typed data-only blocks (QR code, passcode, verdict, record list, consent), drawn as a device mock.cat-harness:graphTypology/doc-group doc-group — A named group of the documentation's own pages — one folder, one heading in the Pages list. A sub-graph of `docs`.cat-harness:graphTypology/docs docs — Documentation ABOUT the knowledge graph — how the harness works, what its directories hold, how a process runs. Rendered by the plain just-the-docs pipeline. Distinct from `folio`, which is content an author CREATES using the graph; the difference is the SUBJECT, not the format. An L1 library's catalogue is `library/`; a note about it is a `folio`; the page explaining how ingestion works is `docs`.cat-harness:graphTypology/document-kinds document-kinds — Document kinds — named structures of sections (fixed or semi-fixed) that a document authored with a harness follows, one `document-kind/1.0.0` JSON each, plus computed `document-kind-coverage/1.0.0` reports of how a subject realises one. Every kind and section names its sources; `computedFrom` names the declared graphs a section derives from.cat-harness:graphTypology/editor-checkers editor-checkers — The checks and editor settings a harness provides to the ✍ suggest editor, one node per content profile, each naming the code (`path.ts#Export`) the editor loads for that profile's blocks.cat-harness:graphTypology/external-schema external-schema — The specifications this instance depends on — one record per specification, pinning the EDITION in use, with the operative terms derived from the corpus rather than hand-listed; and, beside a record, the pinned edition's own codes where something resolves against them.cat-harness:graphTypology/fhir-artifact-index fhir-artifact-index — The artefact index of a published FHIR Implementation Guide, reconstructed from its published output — every artefact by canonical URL and published representation, with the IG API's JSON Schema / JSON-LD sidecars as an overlay where the IG publishes them. No IG publishes such an index itself, so every field records which file it came out of.cat-harness:graphTypology/fhir-core-definitions fhir-core-definitions — The FHIR core specification's definitions for each stable release (R4 4.0.1, R4B 4.3.0, R5 5.0.0), with HL7's publication as the authority: resources, complex and primitive datatypes and the root types, one graph per release keyed by canonical URL (http://hl7.org/fhir/StructureDefinition/<id>). A pins node names HL7's own hl7.fhir.<release>.core package at its hl7.org URL, by sha1 and sha512; a manifest per release lists every definition with HL7's published URL for it, its kind, base and the sha256 of its bytes in HL7's package; a class model per release is the UML derived from that package, which HL7 publishes only as pictures, citing the definition and element of every class and attribute.cat-harness:graphTypology/folio folio — Authored content, rendered to a website by the just-the-docs pipeline.cat-harness:graphTypology/health health — Repository health reports — one `health-report/v1` document per sweep, carrying every check's three-state verdict, the thresholds it applied and the basis each threshold was chosen on. Generated by `test/health/run.ts`; never hand-edited.cat-harness:graphTypology/ig-annex ig-annex — Annexes an IG's narrative pages load on demand: an `annexes.json` (`ig-annexes/v1`) naming, for each annex, the page it belongs on, the file beside the declaration that holds it, and the columns its table shows before a row is opened. The IG site build (`stage-ig-sites.ts`, and `ig-repo-site.ts compose` for an IG repository's own site) copies each file to `assets/annex/` and mounts `ig-annex.js` on the page. A `.md` annex is appended to its page as written, so its links address that page (`shownOnPublishedPages`); `check:ig-annex-links` judges them from there.cat-harness:graphTypology/ig-artifact-jsonld ig-artifact-jsonld — One JSON-LD node per artefact of a FHIR Implementation Guide, written from its artefact index beside the artefact's thin page (`artifact/<Type>-<id>.jsonld`): the FHIR RDF class, Dublin Core and schema.org identity, each representation as a `schema:MediaObject`, and PROV for a compiled copy. It is the asset a thin artefact page renders. Beside them, one index node (`artifact/index.jsonld`, `folio-ig-artifact-index-jsonld/v1`) lists every artefact in the Publisher's order, each entry naming its node: what the thin `artifacts` and `toc` pages draw.cat-harness:graphTypology/ig-ast ig-ast — The IG Publisher's abstract syntax tree of a FHIR Implementation Guide (its resources, their dependency edges and the build plan), ingested into the folio that uses the IG. One branch per IG package id; the IG's own source need not be materialised.cat-harness:graphTypology/ig-metadata-index ig-metadata-index — The IG Publisher's own metadata exports for one published IG, harvested verbatim — ValueSet→CodeSystem edges, CodeSystem `uses`, and extension/profile usage paths. Each export declares whether it was present, absent or never looked for, and a `uses` field that upstream declared and left empty is recorded as exactly that.cat-harness:graphTypology/ig-pages ig-pages — The pages of a FHIR Implementation Guide mirror, generated from its artefact index and the chrome of its template chain. Carried beside `docs` on the same directory: `docs` is how the site mounts them, and this kind is what says they are derived.cat-harness:graphTypology/interaction interaction — How a person wants to be asked — read at session start, never written by a process.cat-harness:graphTypology/issue-marks issue-marks — How far an agent has read an issue — the comment id and the edit time it accounted for.cat-harness:graphTypology/l1-extraction l1-extraction — What the recommendation-extraction skill read out of ONE library entry, held beside it at `library/<entry>/l1-extraction/` when the same instance holds the entry, or at `l1-extractions/<entry>/` when the entry lives in another instance (smart-base's handbook extraction, whose source moved to who-iris on 2026-10-30, who-iris#107): the L1 A-Box graph (`l1.json`, JSON-LD against the WHO SMART L1 ontology), the L2 scenario candidates derived from it (`scenarios/scenario-candidates.l2.json`), and the curation, vocabulary and run context that produced them. A sub-graph of `library`: nested in an entry, it is published with the entry beside the entry's manifest; held apart, its own viewer (`scripts/gen-l1-extraction-pages.ts`) publishes it. It is never a folder named for an entry another library holds, which reads as a second copy of that entry and makes the library ingest refuse the duplicate slug.cat-harness:graphTypology/lake-cache lake-cache — Prebuilt Lake artefacts for a Lean package, one branch per package and toolchain on the Lean folio's own repository, restored so a build starts warm. Declared by the folio that builds the Lean package; this harness owns the kind and the tool.cat-harness:graphTypology/lean lean — A folio's Lean 4 formalisation: Lake packages, their modules and the declarations in them. Declared by the folio that holds the packages; this harness owns the kind, the Lean tools and the rendering (doc-gen4 HTML wrapped in the harness rail).cat-harness:graphTypology/library library — L1 source content — one `<bib-slug>/` per ingested document, holding `sections/*.md`, `structure.json` and, where the source was scanned, `ocr/page-NNN.txt`. Every knowledge-graph reference to a source resolves through here, never to a loose path or a bare URL.cat-harness:graphTypology/memory memory — Durable facts an agent carries between sessions. Read during a process, never written by one.cat-harness:graphTypology/merge-queue merge-queue — A merge steward's DECISIONS about an open pull request — priority, rank or override with its reason, a hold with its expiry, the train it joined, an ejection with its evidence. Never a fact GitHub owns: CI, mergeability, labels and the head SHA are read live and refused by name here.cat-harness:graphTypology/merge-reviews merge-reviews — The adversarial review verdict on a pull request's head, one file per head sha.cat-harness:graphTypology/methodology methodology — Judgement methodologies, adopted whole and kept independent — parallel ways to reach a decision, selected by context.cat-harness:graphTypology/notes notes — A folio's derivation notes, scoping docs and ledgers as declared context, not rendered content.cat-harness:graphTypology/openapi openapi — OpenAPI 3 documents a layer holds, each verbatim beside a provenance node naming the repository, path and commit it was ingested from (cat-harness's `openapi` subgraph). Every operation in a document is a node of its own: a page and an IRI under the layer's docs.cat-harness:graphTypology/pipeline-plugins pipeline-plugins — The generic pipeline slots a harness fills, one node per slot naming the table of implementations; registered for a folio through its dependency tree.cat-harness:graphTypology/policies policies — W3C ODRL 2.2 policies: which Actor may do which action, scoped by Process, Task and Role constraints. Actions are the folio profile in skills/permissions/permissions.json.cat-harness:graphTypology/proposals proposals — Proposals for the harness's own features — initial analysis, MVP, options — argued before anything is agreed. A sub-graph of `docs`. When the feature ships, its proposal is MOVED to `requirements` and filed against the `Requirement` schema.cat-harness:graphTypology/qa qa — QA verdicts and their projections — kg-qa audits, block and translation QA, qa-witness documents for the docs site, the viewer-navbar audit, result roll-ups and test runs; every `$schema` family is named in `nodeSchemas`, which is the list — a count here would be a second one, and it was already wrong by one before `viewer-nav-qa/v1` was added. Generated; never hand-edited.cat-harness:graphTypology/qa-checkers qa-checkers — The QA checkers a harness provides, one node per criterion naming the table that holds the code; registered for a folio through its dependency tree.cat-harness:graphTypology/qa-report qa-report — QA reports -- one `qa-report/v1` document per tool run, carrying the tool's own successes, warnings and errors, the files it processed, the files it EXPECTED and the ones that were missing, plus the provenance and toolchain versions upstream records nowhere. Generated by the run; never hand-edited.cat-harness:graphTypology/references references — Bibliographic references, one folio-reference/v1 node per work: a CSL-JSON item at `references/<key>`, the IRI every `\cite{key}` already points at, read as Dublin Core and BIBO through its JSON-LD.cat-harness:graphTypology/requirements requirements — What the harness promises, one document per shipped feature, each carrying a `Requirement` in its front matter. A sub-graph of `docs`. Test runs point at these statements by `req:<slug>#<key>`.cat-harness:graphTypology/session-state session-state — A session's context — the acting actor, the instances it has open, and what it waits on.cat-harness:graphTypology/session-survey session-survey — Published surveys of a commit window — one JSON file each, carrying `"$schema": "folio-session-survey/v1"` and the window's two edge commits, so a later session can compute what it is NOT covered for instead of re-deriving the whole range (bean `6ptx`).cat-harness:graphTypology/sme-case-verdict sme-case-verdict — SME review case/verdict pairs — one `sme-case-verdict/1.0.0` document per reviewed decision-support worked case or indicator-definition cohort, recording attributable human SME identity and review date (bean `vljz`).cat-harness:graphTypology/software-library software-library — Outside libraries a layer imports or vendors -- one generated `software-library` node per library per layer, with the version and sha512 its `bun.lock` pins, its SPDX licence, its range, whether it is a dev dependency, the files that import it and the shim that types it. Shares its core with `tool-release`.cat-harness:graphTypology/subscribed-harnesses subscribed-harnesses — The state directories of each harness instantiated from a KG subscription, one home per subscription and harness, kept apart from the read-only snapshots.cat-harness:graphTypology/substrate-snapshot substrate-snapshot — The root declaration of each Knowledge Graph this instance subscribes to, cached byte for byte at the pinned commit with its fixity, and what the substrate judgement found in it; and each chosen subgraph or asset materialised from it, with its fixity, provenance and gate answers.cat-harness:graphTypology/sweep-marks sweep-marks — When a sweep step last ran — one JSON per check, carrying `"$schema": "folio-sweep-mark/v1"`, so a skipped `check:session-staleness` is visible after the terminal scrolls (bean `rq8s`).cat-harness:graphTypology/swimlane-glossary swimlane-glossary — A Subgraph recording every term a Knowledge Graph's Processes have ever named, and when each stopped being used, so a retired term is never silently reused.cat-harness:graphTypology/test-data-fixed test-data-fixed — Fixed test data sets — one `test-data-fixed/1.0.0` document per curated set (`kind: "fixed"`), living in its own declared directory separate from `test-data-generated` and self-identifying from the file content rather than the path (bean `vm6m`).cat-harness:graphTypology/test-data-generated test-data-generated — Generated test data recipes — one `test-data-generated/1.0.0` document per recipe (`kind: "generated"`, `template`, `params`, `seed`, `specialisation`, `sha256`), never stored materialised, living in a declared directory separate from `test-data-fixed` (bean `vm6m`).cat-harness:graphTypology/test-plan test-plan — Test plans -- one `test-plan/v1` document per plan, in the FHIR R5 TestPlan shape: the system-under-test kind and version range, the `req:` requirements it is evidence for, test cases whose assertions are criterion ids, fixed (reviewed) or generated (template + params + seed) test data, and the certification rule as a DMN reference.cat-harness:graphTypology/test-report test-report — Test reports -- one `test-report/v1` document per run of a plan against a system under test: per-case verdicts in the block-qa entry shape, a rollup for that ONE plan that may not disagree with its cases, and never a total across plans. `running` is never a pass, and the system under test never writes its own verdict. Generated by the run.cat-harness:graphTypology/themes themes — Themes derived from an instance's own sources — one Theme node each, carrying `kind: sticky | webpage | publication`. The palette vocabulary is shared across every kind and only the geometry varies; every value cites where it was measured.cat-harness:graphTypology/todo-feedback todo-feedback — Feedback items — todos raised against a specific block, carrying the submitter's identity. Read by the `todo-review` skill.cat-harness:graphTypology/todo-items todo-items — Todo nodes — one file each, carrying `"$schema": "todo/1.0.0"`. Authored by people and by agents on their behalf.cat-harness:graphTypology/todos todos — Human actors' outstanding work — content, owned by the folio, tagged by role, process, task and identity. Its inner directories are declared by `todos/todos.json`.cat-harness:graphTypology/tool-release tool-release — External tool releases -- one `folio-tool-release/v1` document per tool at one version, with its sha256, its source (an OCI image only by digest), its SPDX licence, how to run it, and the runtimes that release needs, injected rather than inherited -- and the named `folio-tool-profile/v1` sets a run selects. A profile never names a runtime.cat-harness:graphTypology/tools tools — Tool definitions — themselves nodes in the KG, per the repo taxonomy.cat-harness:graphTypology/translation-sources translation-sources — POT templates, PO catalogues and their `TranslationNode` manifests, one directory per target locale. The INPUT to injection; the rendered output is ordinary content that declares its own `lang`.cat-harness:graphTypology/typologies typologies — The graph typologies a harness declares it owns, one node per kind, so no central registry names another harness's subgraph types. Loaded across the instances on first use.cat-harness:graphTypology/uml uml — UML class diagrams of each named sub-graph a harness declares, derived from the node schemas its graph typologies register — PlantUML and Mermaid from one model.cat-harness:graphTypology/uploads uploads — The incoming queue — raw files as dropped, before ingestion. NOT L1, and not greppable as corpus: a document here reads as absent to every consumer.cat-harness:graphTypology/user-scenario user-scenario — User scenarios as journey maps -- one file per journey: ordered steps, per actor what they do and feel, pain points, enablers, the record's trust state, and edges to user stories, BPMN tasks, requirements, FHIR examples, the building blocks each step uses and its DAK assets; a DAK user scenario, composed of other journeys in order.cat-harness:graphTypology/validators validators — The validators a harness's code provides, one node each naming the graph typology and $schema family it checks and the Zod export that checks it, joined onto the kinds on first use.cat-harness:graphTypology/vocab-mapping vocab-mapping — Vocabulary mappings — which source field becomes which target predicate, with its stated relationship, one ConceptMap-shaped table per source and target; representable from and producible as a FHIR ConceptMap.cat-harness:graphTypology/voice-vendors voice-vendors — Vendor voice profiles — a base voice specialised for one agent vendor, `folio-voice/v1` with `extends` naming the base. A sub-graph of `voices`, declared from within by `voices.json`, each vendor declared by `vendors.json`.cat-harness:graphTypology/voices voices — Editorial voice profiles — one JSON each, carrying `"$schema": "folio-voice/v1"`. Every rule cites the ingested source or KG node it was derived from. Opt-in per folio.cat-harness:graphTypology/waiver waiver — Confirmations a person granted in advance — each naming one gate, scoped to a session or a process run, each expiring.cat-harness:graphTypology/web-annex web-annex — A WHO publication's web annexes, L1 or L2, held as data in the knowledge graph rather than as the files WHO attaches to the publication: a DAK's core data dictionary workbook as JSON (`dak-data-dictionary/v1`, loaded on demand by the IG site's annex view), and the declared mapping from its generic personas to the swimlanes of its business-process figures (`dak-swimlanes/v1`). Every node says which publication it is an annex of (`annexOf`: a library entry when one is held, else the parent's IRIS handle), what the publication calls it (`label`, e.g. "Web Annex A"), its own IRIS handle only when WHO gave it a record (`iris`), and the document-kind section it serves (`section`, e.g. `dak#core-data-elements` or `l1#annexes`).cat-harness:graphTypology/web-app web-app — A web app held as source and published as its own chrome-less page, built at publish by the web-app-build Tool and loaded only when a reader opens its route.cat-harness:graphTypology/workflow-state workflow-state — Running BPMN instances — one JSON file each, carrying `"$schema": "folio-workflow-instance/v1"`. Owned by the interpreter, never hand-edited.cat-harness:graphTypology/workshop workshop — Workshops over journeys -- modules, learning objectives, questions for the room per journey step, reference tables, printable sheets, job aids and readings.cat-harness:partOf partOf — The node this one belongs to.cat-harness:inPackage inPackage — The skill package a skill ships in.cat-harness:inSubgraph inSubgraph — The DECLARED DIRECTORY a node was projected from — the named subgraph it belongs to, as a link to that directory's own node rather than a bare id. Derived from the instance's declaration, longest path prefix winning, and INHERITED through `partOf` for nodes that have no path of their own (a ProcessNode is part of a diagram, not a file). A node with no value belongs to no declared directory — vocabulary nodes are minted from the namespace rather than from any file — and that absence is reported as its own state rather than folded into a default. Its own term, NOT `dcterms:isPartOf`: membership of a subgraph is a view of the graph, while `partOf` is structural containment, and one predicate for both made the two indistinguishable once compacted (bean `3f5f`).cat-harness:hasMember hasMember — A node a named subgraph DIRECTLY contains: the deepest subgraph directory holding the node's source path, or its `partOf` parent's subgraph when it has no path. Transitive membership is not a second property — it is this one, followed through `hasSubgraph` (bean `c1m4`).cat-harness:hasSubgraph hasSubgraph — A child named subgraph: a directory directly inside this one. The index names it by IRI; the hydrated file nests it, members and all.cat-harness:payload payload — Where a node's heavy content is published: an immutable, content-addressed file at `<BASE_URL>/payload/sha256/<hex>`, the hex being the SHA-256 of its bytes. A subgraph file carries this link in place of the body (bean `f233`).cat-harness:sha256 sha256 — The lower-case hex SHA-256 digest of a payload's bytes — also its IRI's last segment.cat-harness:bytes bytes — The size of a payload, in bytes.cat-harness:localId localId — The node's own identifier within its file, before any IRI is minted.cat-harness:module module — The source module a node was projected from.cat-harness:path path — A declared directory's path, relative to the instance root.cat-harness:assetRole assetRole — What a declared asset is FOR, as the instance names it — `instance-readme`, `agent-instructions`. A literal, and not the swimlane Role, which is a node with skills.cat-harness:typeIri typeIri — The IRI of a node's type, so a consumer need not parse the `@type` string.cat-harness:statement statement — What a convention REQUIRES, in one line. Distinct from rdfs:comment, which is prose about the node: this is the rule itself, and a consumer filtering for enforceable text needs the two apart.cat-harness:rationale rationale — Why a convention holds, so a reader can tell whether it still does. Kept separate from the statement deliberately — a rule and its justification collapsed into one field is a rule nobody can retire, because nothing is left that says what would falsify it.cat-harness:applies applies — The surfaces a convention governs — `typescript`, `bpmn`, `commit-message`. A filter, not prose, and open rather than enumerated: a closed set would have to be edited before a convention about a new surface could exist.cat-harness:nodeKind nodeKind — Which kind of node this is, where the type alone is not specific enough.cat-harness:graphTypology graphTypology — The kind of graph a directory declares it holds.cat-harness:holdsGraph holdsGraph — A graph typology found in this directory.cat-harness:renderable renderable — Whether a directory's contents are published as a website.cat-harness:scans scans — A directory an instance will look in.cat-harness:scope scope — Which root a declared path resolves against — the instance's or the repository's.cat-harness:contentSource contentSource — Where a declared subgraph gets its content — the checkout's own directory, a declared repository branch, or a later kind — as resolved after the instance config's override.cat-harness:contentSourceKind contentSourceKind — Which kind of content source: `directory`, `branch`, or a branch `family`, as a plain value. Its own term, NOT `dcterms:type`: that property's range is a class, and the published subgraph files use it as a link (`holdsGraph`), so a literal under it failed publish-verify's object-link check (ld-object-property-is-a-link, 2026-10-03).cat-harness:contentSourceBranch contentSourceBranch — The repository branch a subgraph's content is read from.cat-harness:keyedBy keyedBy — How entries are keyed on a content branch: one entry per `commit`, or one live copy at the `tip`.cat-harness:keyFrom keyFrom — What the key of a branch FAMILY is, in words (an IG's package id; a Lean package and toolchain): each member branch is the family's prefix followed by one key.cat-harness:familyRepository familyRepository — The remote repository (`owner/repo`) a branch FAMILY is read from. Absent when the family is materialised on the declaring repository itself.cat-harness:sourceDeclaredIn sourceDeclaredIn — Which layer said where a subgraph's content comes from — the declaration, a legacy `storage` field, the instance config's override, or the `directory` default — so an override is never silent.cat-harness:dependents dependents — RETIRED 2026-09-30: whether an instance depending on this one materialised its own copy of a declared directory. Inheritance is now automatic — every instance whose directory exists is a member of the declared subgraph — and whether a dependent gets one created is its graph typology's `perInstance`.cat-harness:movedOn movedOn — When a node was moved into the trashcan.cat-harness:movedFrom movedFrom — Where a node in the trashcan used to live.cat-harness:issue issue — The issue that superseded this node, or that it was written for.cat-harness:bean bean — The work-plan item a node was written under, where there is one.cat-harness:data data — A trashcan node's kind-specific fields, kept whole as JSON because a node's kind is open.cat-harness:nodeCount nodeCount — How many nodes a graph or directory yielded.cat-harness:layer layer — Which layer of the platform mints a term — bootstrap, harness or core. Declared so a JSON-LD processor keeps it: undeclared, it was silently dropped from all 159 vocabulary terms (bean vigi).cat-harness:skipped skipped — A file an exporter looked at and left out, with the reason — so a short output is never mistaken for a small input.cat-harness:flowCount flowCount — How many sequence flows a process carries.cat-harness:actorKind actorKind — Whether an actor is human, agentic or mechanical.cat-harness:actorKinds actorKinds — Which kinds of actor a role admits.cat-harness:reach reach — What this actor can reach off its own machine — internet, egress-restricted or air-gapped. The same vocabulary the deployment declares, at the level of one participant; absent means undeclared, which is not `internet`.cat-harness:hasSkill hasSkill — A skill this role carries.cat-harness:judgementOnly judgementOnly — Whether this role acts by judgement, so no skill can be named for its tasks.cat-harness:actedUpon actedUpon — Retired (owner, 2026-10-16): whether a role was written to rather than performed. A role a machine plays is a real role, and its skills are its contract; readers ignore it.cat-harness:declaresSkill declaresSkill — A skill this package declares.cat-harness:declaresRole declaresRole — A role this registry declares.cat-harness:bindsRole bindsRole — The role a BPMN lane names: the lane's own partitionElementRef, pointing at a <bpmn:resource> whose id is the role id. On the lane, never on the role (#1168; owner, 2026-10-16).cat-harness:hasLaneUsage hasLaneUsage — One appearance of this glossary concept as a swimlane in one process. The scope note lives on the usage rather than on the concept because a note answers what the lane is accountable for IN THIS PROCESS: measured 2026-09-21, all 26 lane names appearing in more than one diagram carry different documentation in each.cat-harness:ofConcept ofConcept — The glossary concept this lane usage is an appearance of.cat-harness:inProcess inProcess — The BPMN process this lane usage appears in.cat-harness:performerVaries performerVaries — Whether this lane declines to name a persona because its performer is whoever invoked the process. A term so marked has no definition, and that absence is an assertion rather than a gap.cat-harness:isA isA — A role this one inherits from, statically and everywhere.cat-harness:roleName roleName — The role's own name, as a lane binds it.cat-harness:mayTakeRole mayTakeRole — A declared role this actor may take on: a link to the Role node from `scenarios/roles.json` (#1168 B8).cat-harness:satisfiesStatement satisfiesStatement — A requirement statement this node discharges, as `req:<requirement>#<statement key>`.cat-harness:performedBy performedBy — The role that performs this activity: the registry Role its lane binds.cat-harness:inLane inLane — The BPMN lane this activity sits in, a Lane node of the same process.cat-harness:requires requires — A skill this activity requires: the activity's own <bootstrap.processes:skill ref>.cat-harness:implementedBy implementedBy — Retired (owner, 2026-10-16): the old name of `requires`.cat-harness:assignments assignments — The role-to-lane bindings a diagram carries.cat-harness:permissionName permissionName — A permission's name, as an actor holds it.cat-harness:hasCapability hasCapability — A capability this actor's environment provides.cat-harness:providesCapability providesCapability — A capability this node makes available.cat-harness:requiresCapability requiresCapability — A capability this node needs before it can run.cat-harness:setupBySkill setupBySkill — The skill that explains how to set up this capability — install, configure, verify. A pointer from an environment probe to a procedure, not a merge of the two kinds.cat-harness:fallbackToCapability fallbackToCapability — The capability that stands in for this one when it is absent. It must not transitively require the capability it replaces — such a substitute is unavailable in exactly the case it exists for.cat-harness:hasInstructions hasInstructions — Whether a skill has an instruction body at all.cat-harness:instructionsPath instructionsPath — Where a skill's instruction body lives, relative to the instance root.cat-harness:readmePath readmePath — Where a declared directory's README lives, relative to the instance root: the page a person reads about that directory.cat-harness:instructionLines instructionLines — How long a skill's instruction body is.cat-harness:fileCount fileCount — How many committed files a declared directory holds, at any depth: published here rather than in its README, where a count conflicted on every merge (bean ba9e).cat-harness:hasIOContract hasIOContract — Whether a skill declares input and output schemas.cat-harness:inputSchema inputSchema — The published schema a skill's input must satisfy.cat-harness:outputSchema outputSchema — The published schema a skill's output satisfies.cat-harness:io io — A skill's input/output contract, taken together.cat-harness:hasManifest hasManifest — Whether a package carries a manifest listing its skills.cat-harness:requirements requirements — The conformance statements this node is held to.cat-harness:satisfies satisfies — A requirement this node satisfies.cat-harness:invoke invoke — How a tool is called.cat-harness:install install — How a tool is obtained, where it is not already present.cat-harness:meta meta — A tool's own descriptive metadata.cat-harness:maintains maintains — An artefact this tool generates and keeps current.cat-harness:maintainsFrom maintainsFrom — The source a maintained artefact is generated from.cat-harness:maintainedBy maintainedBy — The tool that generates and keeps this artefact current.cat-harness:jsonSchema jsonSchema — The published JSON Schema rendering of one of a schema module's public exports.cat-harness:conformsTo conformsTo — A published specification this node's files are written in, e.g. BPMN 2.0 for a process.cat-harness:validator validator — The schema node that runtime-validates a node of this kind.cat-harness:validatorRef validatorRef — The `module#Export` a kind names as its validator, where no schema node for it is in this graph.cat-harness:validatorNotApplicable validatorNotApplicable — Why no runtime validator applies to this kind, and what grades it instead.cat-harness:specVersion specVersion — The edition of a specification this corpus is pinned to.cat-harness:specUse specUse — How the corpus uses a specification: conforms to it, or only reads it.cat-harness:specUrl specUrl — Where a specification is published.cat-harness:namespace namespace — An XML or RDF namespace a specification defines.cat-harness:canonicalDocument canonicalDocument — The document a node's canonical IRI resolves to.cat-harness:bpmnType bpmnType — The BPMN element type a process node was read from.cat-harness:startNode startNode — The node a process begins at.cat-harness:incoming incoming — A sequence flow arriving at this node.cat-harness:outgoing outgoing — A sequence flow leaving this node.cat-harness:from from — The node a sequence flow leaves.cat-harness:to to — The node a sequence flow arrives at.cat-harness:calledElement calledElement — The process a call activity invokes.cat-harness:depiction depiction — A rendered picture of this node, e.g. the SVG drawn from a process's diagram.cat-harness:sourceUrl sourceUrl — Where the file a node was read from can be viewed on its forge.cat-harness:decisionRef decisionRef — The DMN table that computes this gateway's branch.cat-harness:decidedBy decidedBy — The Decision node whose table computes this gateway's branch.cat-harness:hitPolicy hitPolicy — How a DMN decision table picks among matching rules, e.g. FIRST or UNIQUE.cat-harness:enforcement enforcement — Whether a process's steps are strict or advisory.cat-harness:relaxable relaxable — Whether a step may be relaxed by a downstream package.cat-harness:touchesWorkPlan touchesWorkPlan — Whether completing this step performs a work-plan operation.cat-harness:workPlanOp workPlanOp — The work-plan operation a step performs — claim, note or resolve.cat-harness:sourceKind sourceKind — What kind of source a node was read from.cat-harness:sourcePath sourcePath — The file a node was read from.cat-harness:sourceCommitSha sourceCommitSha — The commit the export was taken at.cat-harness:sourceCommitAt sourceCommitAt — When that commit was made.cat-harness:sourceTreeDirty sourceTreeDirty — Whether the working tree had uncommitted changes when the export ran.cat-harness:sourceTree sourceTree — The git tree the export was taken from: what its content is a function of, shared by a pull request's merge commit and main's.cat-harness:sourceLanguage sourceLanguage — The language a locale document's untagged strings are in — its SOURCE language, not the language it was translated into.cat-harness:staging staging — Which build produced this document, when it is a staging preview rather than a release.cat-harness:stagingBranch stagingBranch — The branch a staging preview was built from.cat-harness:stagingSha stagingSha — The commit a staging preview was built from.cat-harness:stagingRef stagingRef — The pull request a staging preview belongs to.cat-harness:stagingRun stagingRun — The CI run that produced a staging preview.cat-harness:changedAssets changedAssets — The nodes a staging preview's graph adds, changes or removes against the graph main publishes, in node order.cat-harness:changedAssetsComparedWith changedAssetsComparedWith — The published main document a changed-assets list was computed against.cat-harness:assetChange assetChange — How a changed asset differs from main: added, changed or removed.cat-harness:assetKind assetKind — The type of a changed asset's node, without its namespace.cat-harness:assetSource assetSource — The repository-relative file a changed asset's node was read from.cat-harness:beforeVersion beforeVersion — The same thing as published on main; absent when it is new on the branch.cat-harness:afterVersion afterVersion — The same thing as published in the staging preview; absent when the branch removes it.cat-harness:renderedPage renderedPage — A rendered page a changed asset's source file maps to, as a before/after pair.cat-harness:renderedPagesUnknown renderedPagesUnknown — Why a changed asset's rendered pages were not mapped one by one — never read as 'renders no page'.cat-harness:generatedNote generatedNote — Which generator wrote this document and how to regenerate it — a statement about the file, not about the graph it frames.cat-harness:counts counts — How many nodes of each type the export produced.cat-harness:omitted omitted — Instance-bound collectors that were NOT run, on a foreign instance's document — so a reader can tell 'this instance has no tools' from 'tools were never looked for'.cat-harness:dependsOn dependsOn — The instances this publishable instance depends on, as FHIR-shaped {packageId, version, uri} records.cat-harness:packageId packageId — A dependency's reverse-DNS id — the identity a consumer resolves.cat-harness:uri uri — A dependency's canonical URL, stable across its versions.cat-harness:dependsOnGaps dependsOnGaps — Dependency edges that could NOT become a record, each with which of the four reasons applies — so a reader can tell 'depends on nothing' from 'depends on things none of which is publishable'.cat-harness:detection detection — How a value was arrived at, where it was inferred rather than declared.cat-harness:ambiguous ambiguous — That more than one answer matched, and none was chosen.cat-harness:label label — The authored label a block is referred to by, kept verbatim beside its minted IRI.cat-harness:kind kind — A block's kind — the name of the `folio-block-kind/v1` node that classifies it.cat-harness:uses uses — A block a reader must have read to follow this one: the editorial prerequisite relation, never derived from proofs.cat-harness:interprets interprets — The block a remark comments on.cat-harness:foreshadows foreshadows — A later block this one prepares the reader for.cat-harness:proofs proofs — A block that proves this one.cat-harness:examples examples — A block that illustrates this one.cat-harness:tag tag — A free label grouping blocks across chapters.cat-harness:defines defines — A term this block defines.cat-harness:leanRef leanRef — The Lean declaration that formalises this block, as a name rather than a link.cat-harness:sorryFree sorryFree — Whether the formal declaration behind this block is complete, with no `sorry`.cat-harness:text text — The path, relative to this document, of the block's prose companion.cat-harness:leanSource leanSource — The path, relative to this document, of the block's Lean companion.cat-harness:blockMeta blockMeta — A block's own metadata, kept verbatim as JSON.cat-harness:licenceRecord licenceRecord — The authored licence record of a library item, including where its licence was searched for.cat-harness:narrative narrative — A figure's or record's drafted narrative with its attribution, kept verbatim as JSON.cat-harness:sourceTechnicalMetadata sourceTechnicalMetadata — Technical metadata of an ingested source file, kept verbatim as JSON.cat-harness:archiveTechnicalMetadata archiveTechnicalMetadata — Technical metadata of an ingested archive, kept verbatim as JSON.cat-harness:sheets sheets — The shape of each sheet of an ingested workbook, kept verbatim as JSON.cat-harness:archiveEntries archiveEntries — The entry list of an ingested archive, kept verbatim as JSON.cat-harness:sheetCount sheetCount — How many sheets an ingested workbook has.cat-harness:entryCount entryCount — How many entries an ingested archive lists.cat-harness:archiveFileCount archiveFileCount — How many files an ingested archive contains.cat-harness:directoryCount directoryCount — How many directories an ingested archive contains.cat-harness:uncompressedBytes uncompressedBytes — An ingested archive's size once unpacked, in bytes.cat-harness:headerVocabulary headerVocabulary — Every column header a tabular record carries, as a set, so a search for a header finds the dataset.cat-harness:headers headers — A table block's column headers, in order.cat-harness:file file — The path, relative to the block, of a figure's image.cat-harness:refs refs — A node an ingested node refers to.cat-harness:sourceDocument sourceDocument — The source document an ingested node was taken from.cat-harness:provenance provenance — How an ingested node was produced.cat-harness:pageStart pageStart — The first page of the source an ingested node covers.cat-harness:pageEnd pageEnd — The last page of the source an ingested node covers.cat-harness:strength strength — The stated strength of an ingested recommendation.cat-harness:systemUnderTest systemUnderTest — The kind, version, and runtime facet of an actor that a test plan executes against.