@agenticprimitives/ontology 1.0.0-alpha.4 → 1.0.0-alpha.40

package/dist/vault-records.js

@@ -0,0 +1,777 @@
+// WHAT A VAULT RECORD KEY MEANS — spec 356 W1.
+//
+// A person's Home lists their organization's vault faithfully and uselessly:
+//
+//   coordination.endeavor:end_05b57d9e-… · updated 2026-09-04 03:38:02   show
+//   org.invite:agent:0x8c5cddca…          · updated 2026-09-04 00:16:11   show
+//
+// Every one of those keys IS something the T-box already has a class for — an Endeavor, an invitation, a
+// roster. Nothing said which was which, so the only reader that could interpret a vault was a person who
+// already knew the codebase, and every new question about vault data meant a new hand-written tool with
+// its own gate (spec 356 §0).
+//
+// This is the missing sentence, and it is DATA bound BY IRI (spec 355 §1) rather than a switch statement:
+// the class must exist in the T-box or `check:ontology-bindings` fails the build. The code may not invent
+// domain vocabulary.
+//
+// WHAT THIS IS NOT: it is not permission. Knowing that `directory.data` holds a roster says nothing about
+// who may read it — the delegation decides that, per subject, per record (spec 277, ADR-0041). A binding
+// narrows what a question CAN MEAN; it never widens what an asker may see.
+// Namespaces inlined rather than imported from ./index — index re-exports this file, so reading NS back
+// would hit it in TDZ (the same cycle `party-roles.ts` and `grounded-vocabulary.ts` document).
+import { CONTACT_PROFILE_PROPERTIES } from './contact-fields.js';
+const APORG = 'https://agenticprimitives.dev/ns/org#';
+const APCOORD = 'https://agenticprimitives.dev/ns/coordination#';
+const APFUL = 'https://agenticprimitives.dev/ns/fulfillment#';
+const APMSG = 'https://agenticprimitives.dev/ns/messaging#';
+const APAR = 'https://agenticprimitives.dev/ns/agent-resolution#';
+const APDEL = 'https://agenticprimitives.dev/ns/delegation#';
+const APGOV = 'https://agenticprimitives.dev/ns/governance#';
+const APS = 'https://agenticprimitives.dev/ns/skill#';
+const APROF = 'https://agenticprimitives.dev/ns/profile#';
+const AP = 'https://agenticprimitives.dev/ns/core#';
+const APCTX = 'https://agenticprimitives.dev/ns/context#';
+const APIX = 'https://agenticprimitives.dev/ns/interaction#';
+const APHH = 'https://agenticprimitives.dev/ns/household#';
+const APCON = 'https://agenticprimitives.dev/ns/contact#';
+const APCR = 'https://agenticprimitives.dev/ns/credential#';
+const APEXEC = 'https://agenticprimitives.dev/ns/execution#';
+const APEST = 'https://agenticprimitives.dev/ns/estate#';
+const APPC = 'https://agenticprimitives.dev/ns/privacy-credential#';
+const APINF = 'https://agenticprimitives.dev/ns/inference#';
+const APATT = 'https://agenticprimitives.dev/ns/attestation#';
+const APACTOR = 'https://agenticprimitives.dev/ns/actor#';
+const APVR = 'https://agenticprimitives.dev/ns/verification-receipt#';
+const PROV = 'http://www.w3.org/ns/prov#';
+const PPLAN = 'http://purl.org/net/p-plan#';
+const EPPLAN = 'https://w3id.org/ep-plan#';
+const APEVAL = 'https://agenticprimitives.dev/ns/evaluation#';
+const DQV = 'http://www.w3.org/ns/dqv#';
+/**
+ * The record kinds this substrate stores, each bound to what it IS.
+ *
+ * Deliberately not exhaustive over every key a vault may hold: an unbound key is UNCLASSIFIED, which is an
+ * honest state and the one that keeps this table from becoming a place to invent meanings. A question over
+ * an unbound kind is refused by name (spec 356 §2.3), never answered from a guess.
+ */
+export const VAULT_RECORD_BINDINGS = [
+    // ── Coordination (spec 332/334) ───────────────────────────────────────────────────────────────
+    // The events stream is matched BEFORE the endeavor itself: `coordination.endeavor:events:<id>` also
+    // starts with `coordination.endeavor:`, and the first match wins.
+    // An endeavor's event log: a projection OVER an Endeavor, not a class of its own. The T-box declares no
+    // EndeavorEvent, and inventing one so a binding compiles is the exact drift this gate exists to stop —
+    // it was here until the check started reading record bindings. You ask about endeavors; the log is how
+    // one of them got where it is.
+    { match: { prefix: 'coordination.endeavor:events:' }, class: `${APCOORD}Endeavor`, label: 'endeavor history', plural: 'endeavor history', ownedBy: 'either', role: 'index' },
+    { match: { prefix: 'coordination.endeavor:' }, class: `${APCOORD}Endeavor`, label: 'endeavor', plural: 'endeavors', ownedBy: 'either' },
+    { match: { exact: 'coordination.requests' }, class: `${APCOORD}EndeavorRequest`, label: 'request for work', plural: 'requests for work', ownedBy: 'either' },
+    // ── The parties' own evidence of a transfer (spec 360) ────────────────────────────────────────
+    // A payment's StepReceipt is AUTHORITY evidence and lives in the audit sink. This is the different
+    // artifact the two PARTIES hold: what Alice can point at to say she paid, and what tells Bob he was
+    // paid, to which treasury, in what amount. Keyed by the transaction, because that is the one identifier
+    // both sides can check against the chain rather than take on trust.
+    { match: { prefix: 'payment.receipt:' }, class: `${APIX}PaymentReceipt`, label: 'payment receipt', plural: 'payment receipts', ownedBy: 'either',
+        properties: {
+            payer: `${APIX}receiptPayer`,
+            payee: `${APIX}receiptPayee`,
+            asset: `${APIX}receiptAsset`,
+            amount: `${APIX}receiptAmount`,
+            txHash: `${APIX}receiptTx`,
+        },
+    },
+    // ── Organization membership (spec 324, ADR-0025) ──────────────────────────────────────────────
+    // The ROSTER an organization keeps of its own members. This is the record `organization.membership.list`
+    // reads today through its own hand-written invoker — W4 retires that in favour of this binding.
+    { match: { exact: 'directory.data' }, class: `${APORG}DirectoryListing`, label: 'member listing', plural: 'member listings', ownedBy: 'organization' },
+    { match: { prefix: 'org.invite:agent:' }, class: `${APORG}MembershipInvitation`, label: 'membership invitation', plural: 'membership invitations', ownedBy: 'organization' },
+    // Spec 401 — a person's contact: their own record of an agent they let in, with the grant they signed (membership on a person).
+    { match: { prefix: 'contact:' }, class: `${APORG}Contact`, label: 'contact', plural: 'contacts', ownedBy: 'person' },
+    { match: { exact: 'org.applications' }, class: `${APORG}MembershipApplication`, label: 'membership application', plural: 'membership applications', ownedBy: 'organization' },
+    // THE MEMBERSHIP ITSELF — spec 325's shape, in the organization's own vault. Distinct from the
+    // invitation, which the T-box files under "Enrollment instruments (NOT membership)": an invitation is
+    // how somebody came to be admitted, and satisfying one creates nothing. The membership is the record
+    // that they ARE admitted, carrying the role assignment and the delegation that materialises it.
+    //
+    // Keyed `org.membership:member:<address>` — inside the `vault:org.membership:*` scope the DO grant
+    // already carries, and clear of `org.membership:local-names`, which is a name map and not a member.
+    {
+        match: { prefix: 'org.membership:member:' }, class: `${APORG}OrganizationMembership`,
+        label: 'member', plural: 'members', ownedBy: 'organization',
+        // Spec 325's shape, field for field — this is what "readable by the ontology" looks like in practice.
+        properties: {
+            memberAgent: `${APORG}memberAgent`,
+            organizationAgent: `${APORG}organizationAgent`,
+            roleAssignment: `${APORG}hasRoleAssignment`,
+            'roleAssignment.assignedRole': `${APORG}assignedRole`,
+            'roleAssignment.materializedByDelegation': `${APORG}materializedByDelegation`,
+            // Spec 427 — the role a membership carries, as the organization offered it. Words and references:
+            // no gate reads any of them.
+            'roleAssignment.roleDefinitionId': `${APORG}roleDefinitionId`,
+            'roleAssignment.roleName': `${APORG}roleName`,
+            'roleAssignment.roleDescription': `${APORG}roleDescription`,
+            'roleAssignment.scope': `${APORG}roleScope`,
+            'roleAssignment.accessRole': `${APORG}accessRole`,
+            'roleAssignment.skillPackRefs': `${APORG}offeredSkillPack`,
+            'roleAssignment.assignedBy': `${APORG}assignedBy`,
+            'roleAssignment.assignedAt': `${APORG}assignedAt`,
+            'roleAssignment.roleSetAt': `${APORG}roleSetAt`,
+        },
+    },
+    // THE PERSON'S OWN CONTACT RECORD (spec 371 §2.2) — the private one of the three records that answer to
+    // "profile". Its fields are the ONE list in `contact-fields.ts`; the map here is derived from it, so an
+    // Ask that can change a name can change a street address, and the record's write allow-list agrees.
+    {
+        match: { exact: 'impact-profile' }, class: `${APCON}ContactProfile`,
+        label: 'contact profile', plural: 'contact profiles', ownedBy: 'person',
+        properties: { ...CONTACT_PROFILE_PROPERTIES, 'contact.location.precision': `${APCON}locationPrecision` },
+    },
+    // A PERSON's own record of who they are connected to — private, a vault credential and never an
+    // on-chain edge (ADR-0025). This is what answers "what organizations am I associated with".
+    {
+        // WHO THEY LIVE WITH, as they record it (spec 363 W4). PRIVATE TIER by construction: it is not on
+        // chain, not derivable from chain state, and may never reach the discovery KB (ADR-0040). One record
+        // per person holding their own household — not a shared roster, because two people's records can
+        // disagree and the honest model says whose you are reading.
+        match: { exact: 'household.data' }, class: `${APHH}Household`,
+        label: 'household', plural: 'household', ownedBy: 'person',
+        properties: {
+            'members[].agent': `${APHH}householdMember`,
+            'members[].role': `${APHH}householdRole`,
+            'members[].kin': `${APHH}kinRelation`,
+        },
+    },
+    { match: { exact: 'relationships.data' }, class: `${APORG}OrganizationMembership`, label: 'organization you belong to', plural: 'organizations you belong to', ownedBy: 'person',
+        // The map is KEYED by the organization — the thing a reader most often gets wrong here.
+        properties: {
+            'orgs{}': `${APORG}organizationAgent`,
+            'orgs{}.orgName': `${APORG}localLabel`,
+            'orgs{}.delegations[]': `${APORG}materializedByDelegation`,
+        },
+    },
+    // ── Content (spec 347 / the field artifacts) ──────────────────────────────────────────────────
+    { match: { prefix: 'content.artifact.' }, class: `${APFUL}Artifact`, label: 'artifact', plural: 'artifacts', ownedBy: 'either',
+        properties: {
+            'kind': `${APFUL}artifactKind`,
+            'commitment': `${APFUL}bodyHash`,
+        },
+    },
+    // ── Conversation (spec 313/316) ───────────────────────────────────────────────────────────────
+    // A message BODY is the content of one message; a topic is the conversation it sits in.
+    { match: { prefix: 'message.body:' }, class: `${APFUL}Message`, label: 'message', plural: 'messages', ownedBy: 'either' },
+    { match: { prefix: 'conversation.topic:' }, class: `${APMSG}DiscussionTopic`, label: 'discussion', plural: 'discussions', ownedBy: 'either' },
+    // ── Relationship credentials (spec 410 §8) ───────────────────────────────────────────────────
+    // The countersigned form of a relationship, one copy in each party's vault; the revocation likewise.
+    { match: { prefix: 'relationships.credential:' }, class: `${AP}RelationshipCredential`, label: 'relationship credential', plural: 'relationship credentials', ownedBy: 'either',
+        properties: { kind: `${AP}relationshipKind` },
+    },
+    { match: { prefix: 'relationships.revocation:' }, class: `${AP}RelationshipCredential`, label: 'relationship revocation', plural: 'relationship revocations', ownedBy: 'either',
+        properties: { credential: `${AP}revokes` },
+    },
+    // ── Governance of the common model (spec 410 §10) ────────────────────────────────────────────
+    { match: { prefix: 'ontology.meaning:' }, class: `${APGOV}LocalMeaning`, label: 'local meaning of a common term', plural: 'local meanings', ownedBy: 'organization',
+        properties: { term: `${APGOV}ofTerm`, organization: `${APGOV}heldBy`, relation: `${APGOV}mappingRelation` },
+    },
+    { match: { exact: 'ontology.adopted' }, class: `${APGOV}AdoptedVersion`, label: 'adopted ontology version', plural: 'adopted ontology versions', ownedBy: 'either',
+        properties: { manifestDigest: `${APGOV}manifestDigest`, adoptedAt: `${APGOV}adoptedAt`, proposalRef: `${APGOV}proposalRef` },
+    },
+    { match: { prefix: 'ontology.steward:' }, class: `${APGOV}Steward`, label: 'steward of a term', plural: 'stewards', ownedBy: 'either',
+        properties: { subject: `${APGOV}stewards`, stewardAgent: `${APGOV}stewardAgent`, charterRef: `${APGOV}charterRef` },
+    },
+    // ── Delegation lineage (spec 410 §1.2) ───────────────────────────────────────────────────────
+    // A key-signed wire re-issued for a credential rotation, and which wire it replaces. The delegator's vault holds
+    // it; the delegate fetches the head of the lineage from the delegator's agent. Never a grant of anything new.
+    { match: { prefix: 'delegation.lineage:' }, class: `${APDEL}Delegation`, label: 'delegation re-issued for a rotation', plural: 'delegations re-issued for a rotation', ownedBy: 'either',
+        properties: { supersedes: `${APDEL}supersedes` },
+    },
+    // ── Resolution (spec 338) ─────────────────────────────────────────────────────────────────────
+    { match: { exact: 'resolution.grants' }, class: `${APAR}PrivateResolutionGrant`, label: 'way to reach someone', plural: 'ways to reach people', ownedBy: 'either',
+        // The held record names WHOSE agent it opens; the address itself comes from the resolver, per use.
+        properties: {
+            'grants[].owner': `${APAR}permitsDiscoveryOf`,
+        },
+    },
+    { match: { exact: 'resolution.requests' }, class: `${APAR}AgentConnectionInvitation`, label: 'request for a way to reach an agent', plural: 'requests for a way to reach an agent', ownedBy: 'either' },
+    // ── What an agent IS and CAN DO ───────────────────────────────────────────────────────────────
+    { match: { exact: 'capabilities.data' }, class: `${APS}CapabilityCatalog`, label: 'capability', plural: 'capabilities', ownedBy: 'either',
+        // The record is the catalogue; each ENTRY is a claim, so its fields map to SkillClaim's properties.
+        properties: {
+            '[].relation': `${APS}claimRelation`,
+            '[].label': `${APS}semanticType`,
+        },
+    },
+    { match: { exact: 'skills.data' }, class: `${APS}SkillClaim`, label: 'skill claim', plural: 'skill claims', ownedBy: 'either',
+        properties: {
+            '[].definitionId': `${APS}definitionId`,
+            '[].subject': `${APS}claimSubject`,
+            '[].issuer': `${APS}claimIssuer`,
+            '[].relation': `${APS}claimRelation`,
+        },
+    },
+    // ── The person's Security section (spec 422 §3.1 / §3.3 / §9.3) ──────────────────────────────
+    // The chain is the SET of credentials; this record is their LABELS (device name, created, kind) keyed by
+    // digest or address. A label whose chain entry is gone renders as retired; a chain entry with no label
+    // renders as unlabelled — the record never decides what signs for her.
+    { match: { exact: 'security.credentials' }, class: `${APCR}CredentialFacet`, label: 'sign-in credential', plural: 'sign-in credentials', ownedBy: 'person', role: 'index',
+        properties: { '[].kind': `${APCR}credentialKind` } },
+    // The emails and phones that open this home and are told when something changes. Never a signer.
+    { match: { exact: 'security.channels' }, class: `${APCR}ChannelFacet`, label: 'contact channel', plural: 'contact channels', ownedBy: 'person', role: 'index' },
+    { match: { exact: 'impact-profile' }, class: `${APROF}AgentProfile`, label: 'profile', plural: 'profile', ownedBy: 'either',
+        // Observed records carry only `contact`, which the T-box has no property for — see the coverage ledger.
+        properties: {
+            'displayName': `${APROF}displayName`,
+            'description': `${APROF}description`,
+        },
+    },
+    // An index over the artifacts, not a thing beside them.
+    { match: { exact: 'content.catalog' }, class: `${APFUL}Artifact`, label: 'content index', plural: 'content index', ownedBy: 'either', role: 'index' },
+    // ── The card studio (spec 347) ────────────────────────────────────────────────────────────────
+    { match: { prefix: 'agent-cards:' }, class: `${AP}A2AAgentCard`, label: 'agent card', plural: 'agent cards', ownedBy: 'either' },
+    // ── The playbook an agent runs under (spec 354) ───────────────────────────────────────────────
+    {
+        match: { exact: 'archetype.assignment' }, class: `${APS}ArchetypeAssignment`,
+        label: 'playbook', plural: 'playbook', ownedBy: 'either',
+        properties: {
+            archetypeId: `${APS}assignedArchetype`,
+            definitionDigest: `${APS}definitionDigest`,
+        },
+    },
+    // ── Run provenance (spec 381) — the durable half of a run's record, in the ACTING agent's vault ──
+    // One activity per step: what ran, under which authority, what receipt it left (by digest). Never the
+    // arguments, results or words — those are the task object's rebuildable copy (ADR-0055).
+    // Spec 389 — the record IS the graph: a JSON-LD document whose top-level node is the run's
+    // ep-plan:ExecutionTraceBundle and whose `graph` holds the run, its steps, what they used and what they
+    // generated. The field names are the context's terms (`run-provenance.jsonld`), so every field below is
+    // the same IRI the context maps it to — bound twice on purpose, checked once by the build.
+    {
+        match: { prefix: 'run.provenance:' }, class: `${EPPLAN}ExecutionTraceBundle`,
+        label: 'run provenance', plural: 'run provenances', ownedBy: 'either',
+        properties: {
+            wasAttributedTo: `${PROV}wasAttributedTo`,
+            wasInformedBy: `${PROV}wasInformedBy`,
+            hasTraceElement: `${EPPLAN}hasTraceElement`,
+            'graph[].startedAtTime': `${PROV}startedAtTime`,
+            'graph[].endedAtTime': `${PROV}endedAtTime`,
+            'graph[].endedAt': `${APEXEC}endedAt`,
+            'graph[].wasAssociatedWith': `${PROV}wasAssociatedWith`,
+            'graph[].actedOnBehalfOf': `${PROV}actedOnBehalfOf`,
+            'graph[].used': `${PROV}used`,
+            'graph[].usedDelegation': `${APVR}usedDelegation`,
+            'graph[].generated': `${PROV}generated`,
+            'graph[].wasGeneratedBy': `${PROV}wasGeneratedBy`,
+            'graph[].wasInformedBy': `${PROV}wasInformedBy`,
+            'graph[].wasAttributedTo': `${PROV}wasAttributedTo`,
+            'graph[].correspondsToStep': `${PPLAN}correspondsToStep`,
+            'graph[].isStepOfPlan': `${PPLAN}isStepOfPlan`,
+            'graph[].isPrecededBy': `${PPLAN}isPrecededBy`,
+            'graph[].hasStep': `${APEXEC}hasStep`,
+            'graph[].runRef': `${APEXEC}runRef`,
+            'graph[].intentDigest': `${APEXEC}intentDigest`,
+            'graph[].completionState': `${APEXEC}completionState`,
+            'graph[].receiptDigest': `${APEXEC}receiptDigest`,
+            'graph[].usedPlanContentHash': `${APEXEC}usedPlanContentHash`,
+            'graph[].realizesCapability': `${APEXEC}realizesCapability`,
+            'graph[].authorityDecision': `${APEXEC}authorityDecision`,
+            'graph[].afterApproval': `${APEXEC}afterApproval`,
+            'graph[].chainDigest': `${APEXEC}chainDigest`,
+            'graph[].accountabilityRoot': `${APEXEC}accountabilityRoot`,
+            'graph[].actorContext': `${APEXEC}actorContext`,
+            'graph[].delegatedToAgent': `${APEXEC}delegatedToAgent`,
+            'graph[].errorClass': `${APEXEC}errorClass`,
+            'graph[].traceId': `${APEXEC}traceId`,
+            'graph[].spanId': `${APEXEC}spanId`,
+            // Spec 410 §2 — what the adapter saw of the effect (which end committed it, and what it can show).
+            'graph[].observedOutcome': `${APEXEC}observedOutcome`,
+            'graph[].providerRef': `${APEXEC}providerRef`,
+            'graph[].observedAt': `${APEXEC}observedAt`,
+            // Spec 410 §4.4 — the estate the run was performed in, when the vault it lives in no longer implies it.
+            'graph[].estate': `${APEXEC}estate`,
+            // Spec 414 A1 — the trace from the door: how the run arrived, the model calls, the variant, the starting state,
+            // the governing skill contract and the harness-capability engagements (ids and numbers only).
+            'graph[].arrivedBy': `${APEXEC}arrivedBy`,
+            'graph[].doorKind': `${APEXEC}doorKind`,
+            'graph[].a2aMessageId': `${APEXEC}a2aMessageId`,
+            'graph[].a2aContextId': `${APEXEC}a2aContextId`,
+            'graph[].a2aTaskId': `${APEXEC}a2aTaskId`,
+            'graph[].hasModelInvocation': `${APEXEC}hasModelInvocation`,
+            'graph[].invocationRole': `${APEXEC}invocationRole`,
+            'graph[].modelId': `${APEXEC}modelId`,
+            'graph[].modelProvider': `${APEXEC}modelProvider`,
+            'graph[].promptTemplateDigest': `${APEXEC}promptTemplateDigest`,
+            'graph[].tokensIn': `${APEXEC}tokensIn`,
+            'graph[].tokensOut': `${APEXEC}tokensOut`,
+            'graph[].routeReason': `${APEXEC}routeReason`,
+            'graph[].underVariant': `${APEXEC}underVariant`,
+            'graph[].variantDigest': `${APEXEC}variantDigest`,
+            'graph[].plannerKind': `${APEXEC}plannerKind`,
+            'graph[].routePolicy': `${APEXEC}routePolicy`,
+            'graph[].harnessBuild': `${APEXEC}harnessBuild`,
+            'graph[].capabilityToggle': `${APEXEC}capabilityToggle`,
+            'graph[].fromStartingState': `${APEXEC}fromStartingState`,
+            'graph[].startingStateDigest': `${APEXEC}startingStateDigest`,
+            'graph[].governedBySkill': `${APEXEC}governedBySkill`,
+            'graph[].hasEngagement': `${APEXEC}hasEngagement`,
+            'graph[].hasEngagement[].ofCapability': `${APEXEC}ofCapability`,
+            'graph[].hasEngagement[].engagementEffect': `${APEXEC}engagementEffect`,
+            'graph[].hasEngagement[].capabilityVersion': `${APEXEC}capabilityVersion`,
+            'graph[].hasEngagement[].offeredCandidate': `${APEXEC}offeredCandidate`,
+            'graph[].hasEngagement[].chose': `${APEXEC}chose`,
+            'graph[].hasEngagement[].rejectedNeighbour': `${APEXEC}rejectedNeighbour`,
+            'graph[].effectProduces': `${APEXEC}effectProduces`,
+            'graph[].effectSucceeded': `${APEXEC}effectSucceeded`,
+            'graph[].decisionPoint': `${APEXEC}decisionPoint`,
+            'graph[].decisionRule': `${APEXEC}decisionRule`,
+            'graph[].artifactBytes': `${APEXEC}artifactBytes`,
+            'graph[].artifactDigest': `${APEXEC}artifactDigest`,
+            'graph[].actingAgent': `${APACTOR}actingAgent`,
+            'graph[].originatingAgent': `${APACTOR}originatingAgent`,
+            'graph[].rootPrincipal': `${APACTOR}rootPrincipal`,
+            'graph[].qualifiedAssociation[].hadPlan': `${PROV}hadPlan`,
+            'graph[].qualifiedAssociation[].hadRole': `${PROV}hadRole`,
+            'graph[].qualifiedAssociation[].agent': `${PROV}agent`,
+        },
+    },
+    // ── Run anchor (spec 410 §4.4) — WHERE the run's bundle is anchored, beside the bundle, in the same vault ──
+    // A bundle cannot carry its own digest's anchor; the citation is this second record. For an act performed in
+    // another estate it is the record that says which chain to ask (`anchorRegistry` is chain-qualified) and which
+    // estate it was (`estate`). A claim about where to look — the holder recomputes the digest and reads the registry.
+    {
+        match: { prefix: 'run.anchor:' }, class: `${APEXEC}ReceiptAnchor`,
+        label: 'run anchor', plural: 'run anchors', ownedBy: 'either',
+        properties: {
+            digest: `${APEXEC}anchorDigest`,
+            registry: `${APEXEC}anchorRegistry`,
+            anchoredBy: `${APEXEC}anchoredByAgent`,
+            txHash: `${APEXEC}anchorTransaction`,
+            estate: `${APEXEC}estate`,
+        },
+    },
+    // ── Run measurements (spec 414 A2) — numbers about a run, from its trace alone, beside its provenance ──
+    // One apeval:RunMeasures record per run: a measuring activity that used the run's bundle, and one DQV measurement per
+    // metric (and per step where the number is a step's). Descriptive, never judged; no words (shape M3).
+    {
+        match: { prefix: 'run.measures:' }, class: `${APEVAL}RunMeasures`,
+        label: 'run measurements', plural: 'run measurements', ownedBy: 'either',
+        properties: {
+            wasDerivedFrom: `${PROV}wasDerivedFrom`,
+            wasAttributedTo: `${PROV}wasAttributedTo`,
+            hasMeasurement: `${APEVAL}hasMeasurement`,
+            'graph[].used': `${PROV}used`,
+            'graph[].generated': `${PROV}generated`,
+            'graph[].wasAssociatedWith': `${PROV}wasAssociatedWith`,
+            'graph[].computedOn': `${DQV}computedOn`,
+            'graph[].isMeasurementOf': `${DQV}isMeasurementOf`,
+            'graph[].value': `${DQV}value`,
+            'graph[].unit': `${APEVAL}unit`,
+            'graph[].wasGeneratedBy': `${PROV}wasGeneratedBy`,
+        },
+    },
+    // ── An assessment of a run (spec 438 §5) — a SEPARATE signed assertion, never an edit to the run ──
+    // 414 §3.4 fixed the shape of a judgment and left the record to "a later spec"; 438 is it. The run record is
+    // immutable evidence of what happened; this is somebody's judgment OF it, bound to the subject by digest and to
+    // a criteria revision that pre-dates the subject (J2). A correction is a new assessment with `supersedes` — the
+    // earlier one stays readable, because a record of opinions that can be rewritten is not a record. J1 still holds:
+    // no verifier, admission stage or mandate reads one. Signed by the evaluator's SESSION key under its own wire
+    // (the service-agent-signing rule), or by a person's SA at her Home.
+    {
+        match: { prefix: 'run.assessment:' }, class: `${APEVAL}Assessment`,
+        label: 'run assessment', plural: 'run assessments', ownedBy: 'either',
+        properties: {
+            subject: `${PROV}used`,
+            recordDigest: `${APEXEC}anchorDigest`,
+            criteriaRevision: `${APEVAL}criteriaRevision`,
+            criterionDigest: `${APEVAL}criterionDigest`,
+            evaluator: `${PROV}wasAssociatedWith`,
+            evaluatorKind: `${APEVAL}judgeKind`,
+            evaluatorImplementation: `${APEVAL}evaluatorImplementation`,
+            supersedes: `${APEVAL}supersedes`,
+            'results[].outcome': `${PROV}generated`,
+        },
+    },
+    // ── What a second agent needs to carry on (spec 438 §3) — the continuation package for an Endeavor ──
+    // Objective, open decisions, live commitments, and the runs attached so far with their digests and evidence
+    // status. It carries NO MANDATE: the agent that picks the work up acts under its own authority, or not at all.
+    // That is the whole reason this is a record and not a handoff token.
+    {
+        match: { prefix: 'endeavor.continuation:' }, class: `${APCOORD}Endeavor`,
+        label: 'continuation package', plural: 'continuation packages', ownedBy: 'either',
+        properties: {
+            // The objective is the Endeavor's OutcomeSpecification — the observable success definition that already
+            // exists, not a prose restatement of it. An agent picking the work up is told what "done" means in the
+            // same terms the assessment will be judged against (spec 438 §5).
+            outcomeSpecification: `${APCOORD}hasOutcomeSpecification`,
+            'commitments[]': `${PROV}wasAssociatedWith`,
+            'runs[].runRef': `${APEXEC}workRef`,
+            'runs[].recordDigest': `${APEXEC}anchorDigest`,
+            'runs[].evidenceStatus': `${APEXEC}hasEvidenceStatus`,
+        },
+    },
+    // ── A dispute over a receipt (spec 410 §10) — one Interaction under dispute/1.0.0, held by BOTH parties ──
+    // Every exchange is one signed unit by its author; a steward's determination closes it; it reverses nothing.
+    {
+        match: { prefix: 'interaction.dispute:' }, class: `${APIX}Interaction`,
+        label: 'dispute', plural: 'disputes', ownedBy: 'either',
+        properties: {
+            profileVersion: `${APIX}profileVersion`,
+            'exchanges[].performative': `${APIX}performative`,
+        },
+    },
+    // ── The run's pointer to the dispute that cites it (spec 410 §10, `apexec:disputedBy`) ──
+    {
+        match: { prefix: 'run.dispute:' }, class: `${APEXEC}ServiceExecution`,
+        label: 'run dispute', plural: 'run disputes', ownedBy: 'either',
+        properties: {
+            disputedBy: `${APEXEC}disputedBy`,
+        },
+    },
+    // ── Run artifacts (spec 391) — a step's raw result, too large for the run's record, in the ACTING agent's vault ──
+    // The body a resume or a person fetches under the agent's grant; the receipt's outputDigest commits to it.
+    {
+        match: { prefix: 'run.artifact:' }, class: `${APEXEC}RunArtifact`,
+        label: 'run artifact', plural: 'run artifacts', ownedBy: 'either',
+        properties: {
+            digest: `${APEXEC}artifactDigest`,
+            bytes: `${APEXEC}artifactBytes`,
+        },
+    },
+    // ── Build artifacts (spec 398 §9 / ap-build B3) — what one build run left, in the WORKSPACE's vault ──
+    // The files the model wrote and the test evidence as recorded; the PR opened from it names this record.
+    {
+        match: { prefix: 'build.run:' }, class: `${APEXEC}BuildArtifact`,
+        label: 'build run', plural: 'build runs', ownedBy: 'either',
+        properties: {
+            repository: `${APEXEC}buildRepository`,
+            base: `${APEXEC}buildBase`,
+            task: `${APEXEC}buildTask`,
+            summary: `${APEXEC}buildSummary`,
+            'evidence.command': `${APEXEC}testCommand`,
+            'evidence.exitCode': `${APEXEC}testExitCode`,
+            'evidence.outputTail': `${APEXEC}testOutputTail`,
+            model: `${APEXEC}buildModel`,
+            digest: `${APEXEC}artifactDigest`,
+        },
+    },
+    // ── Build promotions (spec 398 §9.4 / ap-build B5) — the exact tuple a steward's signature was over ──
+    {
+        match: { prefix: 'build.promotion:' }, class: `${APEXEC}BuildPromotion`,
+        label: 'build promotion', plural: 'build promotions', ownedBy: 'either',
+        properties: {
+            repository: `${APEXEC}buildRepository`,
+            commit: `${APEXEC}promotedCommit`,
+            configDigest: `${APEXEC}promotedConfigDigest`,
+            environment: `${APEXEC}promotedEnvironment`,
+            migration: `${APEXEC}permittedMigration`,
+            promotedUnder: `${APEXEC}promotedUnder`,
+        },
+    },
+    // ── The agent's budget (P1.4) — what it may do in a day, declared by its steward ──
+    {
+        match: { exact: 'agent.budget' }, class: `${APCTX}AgentBudget`,
+        label: 'agent budget', plural: 'agent budget', ownedBy: 'either',
+        properties: { asksPerDay: `${APCTX}asksPerDay`, vaultCallsPerDay: `${APCTX}vaultCallsPerDay` },
+    },
+    // ── The town's model gateway (spec 434) — inference.svc's OWN records: policy, entitlements, receipts ──
+    // A receipt is evidence that a call occurred and what it cost, never that it was authorized; an entitlement is the
+    // service's own policy over its own resource, never a delegation (G8). `assertedAgent` is what the caller SAID.
+    {
+        match: { prefix: 'inference.receipt:' }, class: `${APINF}InferenceReceipt`,
+        label: 'inference receipt', plural: 'inference receipts', ownedBy: 'either',
+        properties: { profile: `${APINF}profileId`, profileVersion: `${APINF}profileVersion`, provider: `${APINF}modelProvider`, model: `${APINF}modelId`, principal: `${APINF}principal`, assertedAgent: `${APINF}assertedAgent`, costMicroUsd: `${APINF}costMicroUsd`, attempt: `${APINF}attempt`, fallbackOf: `${APINF}fallbackOf`, reconciliation: `${APINF}reconciliationState`, outcome: `${APINF}outcome`, purpose: `${APINF}purpose`, estate: `${APINF}estate`, clientKind: `${APINF}clientKind` },
+    },
+    { match: { prefix: 'inference.profile:' }, class: `${APINF}ModelProfile`, label: 'model profile', plural: 'model profiles', ownedBy: 'either', properties: { id: `${APINF}profileId`, 'servesCapability[]': `${APINF}servesCapability` } },
+    { match: { prefix: 'inference.model:' }, class: `${APINF}ModelCatalogEntry`, label: 'model catalog entry', plural: 'model catalog entries', ownedBy: 'either', properties: { provider: `${APINF}modelProvider`, model: `${APINF}modelId`, enabled: `${APINF}enabled` } },
+    { match: { prefix: 'inference.client:' }, class: `${APINF}ClientEntitlement`, label: 'inference client', plural: 'inference clients', ownedBy: 'either', properties: { principal: `${APINF}principal`, estate: `${APINF}estate`, kind: `${APINF}clientKind` } },
+    { match: { prefix: 'inference.policy-change:' }, class: `${APINF}PolicyChange`, label: 'inference policy change', plural: 'inference policy changes', ownedBy: 'either', properties: { recordKey: `${APINF}changedRecord`, reason: `${APINF}reason` } },
+    // ── Spec 435 / 436 / 437 — standing, manifests, the Town Ask's records ──
+    // The agent's own copy of its TownStanding VC (the chain holds the hash): read to show and renew; no gate reads it.
+    { match: { prefix: 'town.standing:' }, class: `${APATT}TownStanding`, label: 'town standing', plural: 'town standings', ownedBy: 'either', properties: { town: `${APATT}standingTown`, estate: `${APATT}standingEstate`, steward: `${APATT}standingSteward`, validUntil: `${APATT}standingValidUntil` } },
+    // A service's own signed MCP tool manifest, as published; a holder pins its digest on `connector.mcp:` (spec 404).
+    { match: { prefix: 'mcp.manifest:' }, class: `${APAR}McpToolManifest`, label: 'MCP tool manifest', plural: 'MCP tool manifests', ownedBy: 'either', properties: { 'server.url': `${APAR}manifestServerUrl` } },
+    { match: { prefix: 'mcp.bundle:' }, class: `${APAR}McpToolBundle`, label: 'MCP tool bundle', plural: 'MCP tool bundles', ownedBy: 'either' },
+    // The Town Ask (spec 436 §5.5, 437): the context agents' memory of the Pulse — counts, never a person.
+    { match: { prefix: 'pulse.day:' }, class: `${APINF}TownPulse`, label: "day's pulse", plural: 'daily pulses', ownedBy: 'either', properties: { day: `${APINF}pulseDay` } },
+    { match: { prefix: 'pulse.sample:' }, class: `${APINF}TownPulse`, label: 'pulse sample', plural: 'pulse samples', ownedBy: 'either' },
+    { match: { prefix: 'estate.checklist:' }, class: `${APINF}StandingChecklist`, label: 'standing checklist', plural: 'standing checklists', ownedBy: 'either' },
+    { match: { prefix: 'estate.manifest:' }, class: `${APINF}EstateManifest`, label: 'estate manifest', plural: 'estate manifests', ownedBy: 'either' },
+    // ── External MCP servers as connectors (spec 404) — the holder's own; the token is NOT in the record ──
+    {
+        match: { prefix: 'connector.mcp:' }, class: `${APCTX}McpConnector`,
+        label: 'MCP connector', plural: 'MCP connectors', ownedBy: 'either',
+        properties: {
+            name: `${APCTX}connectorName`,
+            url: `${APCTX}connectorUrl`,
+            'server.name': `${APCTX}serverName`,
+            attachedAt: `${APCTX}attachedAt`,
+            'tools[].kind': `${APCTX}toolKind`,
+        },
+    },
+    // ── Conversation memory (spec 370 P7) — what the agent RESOLVED for the owner lately, in their vault ──
+    {
+        match: { exact: 'conversation.recent' }, class: `${APCTX}ConversationMemory`,
+        label: 'recent conversation', plural: 'recent conversations', ownedBy: 'person',
+        properties: {
+            'turns[].at': `${APCTX}recalledAt`,
+            'turns[].parties[].agent': `${APCTX}recalledParty`,
+            'turns[].parties[].raw': `${APCTX}recalledWords`,
+        },
+    },
+    // ── Learned memory (spec 358 W5) — what the owner TOLD the agent, in their own vault ────────────
+    {
+        match: { prefix: 'preference:' }, class: `${APCTX}LearnedPreference`,
+        label: 'thing you told me', plural: 'things you told me', ownedBy: 'person',
+        properties: {
+            subject: `${APCTX}preferenceSubject`,
+            trigger: `${APCTX}preferenceTrigger`,
+            learnedAt: `${APCTX}learnedAt`,
+        },
+    },
+    // ── Confirmation memory (spec 385; bound here by spec 394) — which "David" the owner chose, per scope ──
+    {
+        match: { exact: 'confirmation.preferences' }, class: `${APCTX}ConfirmationMemory`,
+        label: 'remembered choice', plural: 'remembered choices', ownedBy: 'person',
+        properties: {
+            'entries[].agent': `${APCTX}confirmedParty`,
+            'entries[].word': `${APCTX}confirmedWords`,
+            'entries[].capability': `${APCTX}confirmedFor`,
+        },
+    },
+    // ── Playbook memory — the agent's own counts on the subjects of one skill family ───────────────
+    {
+        match: { prefix: 'playbook.memory:' }, class: `${APCTX}PlaybookMemory`,
+        label: 'playbook memory', plural: 'playbook memories', ownedBy: 'either',
+        properties: {
+            family: `${APCTX}memoryFamily`,
+            rounds: `${APCTX}memoryRounds`,
+        },
+    },
+    // ── Card-room study records — the person's own play, read by a named coach service under a grant ──
+    {
+        match: { exact: 'cardroom.hand' }, class: `${APCTX}CardRoomHandRecord`,
+        label: 'hand record', plural: 'hand records', ownedBy: 'person',
+        properties: { hands: `${APCTX}handsRecorded` },
+    },
+    { match: { exact: 'cardroom.style' }, class: `${APCTX}CardRoomStyleRecord`, label: 'playing style', plural: 'playing styles', ownedBy: 'person' },
+    { match: { exact: 'cardroom.read' }, class: `${APCTX}CardRoomPlayerRead`, label: 'player read', plural: 'player reads', ownedBy: 'person' },
+    {
+        match: { exact: 'cardroom.note' }, class: `${APCTX}CardRoomCoachNote`,
+        label: 'coach note', plural: 'coach notes', ownedBy: 'person',
+        properties: { 'entries[].by': `${APCTX}coachedBy` },
+    },
+    { match: { exact: 'cardroom.client' }, class: `${APCTX}CardRoomCoachClient`, label: 'coaching client', plural: 'coaching clients', ownedBy: 'either' },
+    { match: { prefix: 'cardroom.hands:' }, class: `${APCTX}CardRoomHandRecord`, label: 'a day’s hands', plural: 'days of hands', ownedBy: 'person' },
+    { match: { exact: 'cardroom.prefs' }, class: `${APCTX}CardRoomPreferences`, label: 'card-room preferences', plural: 'card-room preferences', ownedBy: 'person' },
+    // Who the person is as a player — ONE record across games (cr:PlayerProfile in the card-room ontology).
+    { match: { exact: 'cardroom.profile' }, class: `${APCTX}CardRoomPlayerProfile`, label: 'player profile', plural: 'player profiles', ownedBy: 'person' },
+    // A CLUB, kept by its own workspace agent (apctx:CardRoomClub…): the profile, the rule it meets by, and
+    // the nights as they diverge from the rule. The roster is the organization's own membership records.
+    { match: { exact: 'cardroom.club.profile' }, class: `${APCTX}CardRoomClub`, label: 'club', plural: 'clubs', ownedBy: 'organization' },
+    { match: { exact: 'cardroom.club.schedule' }, class: `${APCTX}CardRoomClubSchedule`, label: 'club schedule', plural: 'club schedules', ownedBy: 'organization' },
+    { match: { exact: 'cardroom.club.nights' }, class: `${APCTX}CardRoomClubNights`, label: 'club nights', plural: 'club nights', ownedBy: 'organization' },
+    // A MISSION, kept by its own organization (apctx:CardRoomMission…): the presence a card room's map shows,
+    // the steward's signed covenant, and the confidential contact — written in the registration ceremony.
+    { match: { exact: 'cardroom.mission.presence' }, class: `${APCTX}CardRoomMission`, label: 'mission presence', plural: 'mission presences', ownedBy: 'organization' },
+    { match: { exact: 'cardroom.mission.covenant' }, class: `${APCTX}CardRoomMissionCovenant`, label: 'mission covenant', plural: 'mission covenants', ownedBy: 'organization' },
+    { match: { exact: 'cardroom.mission.contact' }, class: `${APCTX}CardRoomMissionContact`, label: 'mission contact', plural: 'mission contacts', ownedBy: 'organization' },
+    // ONE CABINET PER GAME: hold'em's study records are the bare names above; every other game's carry the
+    // family — canasta's here, the same classes, a different coach's grant.
+    {
+        match: { exact: 'cardroom.canasta.hand' }, class: `${APCTX}CardRoomHandRecord`,
+        label: 'canasta round record', plural: 'canasta round records', ownedBy: 'person',
+        properties: { hands: `${APCTX}handsRecorded` },
+    },
+    { match: { exact: 'cardroom.canasta.style' }, class: `${APCTX}CardRoomStyleRecord`, label: 'canasta playing style', plural: 'canasta playing styles', ownedBy: 'person' },
+    { match: { exact: 'cardroom.canasta.read' }, class: `${APCTX}CardRoomPlayerRead`, label: 'canasta player read', plural: 'canasta player reads', ownedBy: 'person' },
+    {
+        match: { exact: 'cardroom.canasta.note' }, class: `${APCTX}CardRoomCoachNote`,
+        label: 'canasta coach note', plural: 'canasta coach notes', ownedBy: 'person',
+        properties: { 'entries[].by': `${APCTX}coachedBy` },
+    },
+    { match: { prefix: 'cardroom.canasta.hands:' }, class: `${APCTX}CardRoomHandRecord`, label: 'a day’s canasta rounds', plural: 'days of canasta rounds', ownedBy: 'person' },
+    // ── Standing instructions (spec 394) — the owner's declared defaults, per room ──────────────────
+    {
+        match: { exact: 'standing.instructions' }, class: `${APCTX}StandingInstruction`,
+        label: 'standing instruction', plural: 'standing instructions', ownedBy: 'person',
+        properties: {
+            'entries[].capability': `${APCTX}instructionCapability`,
+            'entries[].arg': `${APCTX}instructionArgument`,
+            'entries[].value': `${APCTX}instructionValue`,
+            'entries[].context': `${APCTX}instructionContext`,
+            'entries[].at': `${APCTX}declaredAt`,
+        },
+    },
+    // ── Declared routines (spec 402 W3 · 323 W6) — the owner's routines as a record that travels ─────
+    {
+        match: { exact: 'routines.data' }, class: `${APCTX}DeclaredRoutine`,
+        label: 'declared routine', plural: 'declared routines', ownedBy: 'person',
+        properties: {
+            'entries[].ask': `${APCTX}routineAsk`,
+            'entries[].every': `${APCTX}routineEvery`,
+            'entries[].declared.saidAs': `${APCTX}routineSaidAs`,
+            'entries[].declared.tz': `${APCTX}routineZone`,
+        },
+    },
+    // ── The person's preferences (spec 403 W2/W4) — nudges and how to answer ─────────────────────────
+    {
+        match: { exact: 'person.preferences' }, class: `${APCTX}PersonPreferences`,
+        label: 'preferences', plural: 'preferences', ownedBy: 'person',
+        properties: { 'notify.email': `${APCTX}nudgeByEmail`, 'answer.style': `${APCTX}answerStyle`, 'answer.language': `${APCTX}answerLanguage` },
+    },
+    // ── Remembered facts (spec 402 W1) — what the owner's agent knows about the owner ────────────────
+    {
+        match: { exact: 'memory.facts' }, class: `${APCTX}RememberedFact`,
+        label: 'remembered fact', plural: 'remembered facts', ownedBy: 'person',
+        properties: {
+            'entries[].fact': `${APCTX}factWords`,
+            'entries[].source': `${APCTX}factSource`,
+            'entries[].learnedAt': `${APCTX}learnedAt`,
+            'entries[].from': `${APCTX}learnedFrom`,
+        },
+    },
+    // ── What an estate vouches for, with its opening (spec 410 §4; ap-federation F1) ──────────────────
+    // Held in the vault of the agent that anchors the estate's roots — its registry agent. ADR-0055 decides
+    // it: the blind exists nowhere else, so wiping this store leaves roots nobody can ever prove a leaf
+    // against. A rebuild is fine; this would be a bereavement. The Durable Object stays as the serving
+    // projection, rebuilt from these records and never their only copy.
+    {
+        match: { prefix: 'federation.projection-submission:' }, class: `${APEST}ProjectionSubmission`,
+        label: 'projection submission', plural: 'projection submissions', ownedBy: 'either',
+        properties: {
+            set: `${APEST}projectionSet`,
+            digest: `${APEST}vouchedDigest`,
+            blind: `${APEST}leafBlind`,
+            subject: `${APEST}leafSubject`,
+            submittedBy: `${APEST}submittedBy`,
+            source: `${APEST}submissionSource`,
+            submittedAt: `${PROV}generatedAtTime`,
+            expiresAt: `${APEST}vouchExpiresAt`,
+            'retired.at': `${PROV}invalidatedAtTime`,
+            'retired.reason': `${APEST}retiredReason`,
+            estate: `${APEXEC}estate`,
+        },
+    },
+    // ── Anonymous credentials (tbox/privacy-credential.ttl; specs 304 / 305 / 443 W5) ───────────────────
+    // THE HOLDER'S records: a credential made to be proved about, the custodied device key it is bound to, the
+    // holder secret her pairwise accounts derive from. ADR-0055 decides each: lose the credential and the issuer
+    // holds only its digest; lose the device key and no presentation can ever be made; lose the secret and every
+    // pairwise account at every verifier is unreachable. Bereavements, all three — vault records, never a cache.
+    // None of these is read by any gate: the mandate is judged per signature by the presentation release (ADR-0041).
+    {
+        match: { prefix: 'credential.anonymous:' }, class: `${APPC}AnonymousCredential`,
+        label: 'anonymous credential', plural: 'anonymous credentials', ownedBy: 'person',
+        properties: {
+            issuerKeyId: `${APPC}facetKeyId`,
+            digest: `${APPC}credentialDigest`,
+            claimSchema: `${APPC}claimSchema`,
+            deviceKeyThumbprint: `${APPC}deviceKeyThumbprint`,
+            issuedAt: `${PROV}generatedAtTime`,
+        },
+    },
+    {
+        match: { prefix: 'credential.device-key:' }, class: `${APPC}DeviceKey`,
+        label: 'device key', plural: 'device keys', ownedBy: 'person',
+        properties: { thumbprint: `${APPC}deviceKeyThumbprint`, createdAt: `${PROV}generatedAtTime` },
+    },
+    { match: { prefix: 'credential.holder-secret:' }, class: `${APPC}PairwiseAccount`, label: 'holder secret (pairwise accounts derive from it)', plural: 'holder secrets', ownedBy: 'person' },
+    // Her standing `credential.present` wire — a delegation, kept under its own family because what it bounds (venues,
+    // programs, facets) is this module's vocabulary. The release judges it per signature (ADR-0041); no gate reads it.
+    {
+        match: { prefix: 'credential.presentation-mandate:' }, class: `${APPC}PresentationMandate`,
+        label: 'presentation mandate', plural: 'presentation mandates', ownedBy: 'person',
+        properties: { audiences: `${APPC}mandateAudience`, predicateDigests: `${APPC}mandatePredicateDigest`, issuerKeyIds: `${APPC}mandateIssuerKeyId`, maxPresentations: `${APPC}maxPresentations`, issuedAt: `${PROV}generatedAtTime` },
+    },
+    // THE ISSUER'S records: its key facets (public documents, kept with their attestation uid so a rotation knows what
+    // to revoke) — the live set's leaves are `federation.projection-submission:` rows in the `live-credential` set.
+    {
+        match: { prefix: 'credential.issuer-facet:' }, class: `${APPC}IssuerKeyFacet`,
+        label: 'issuer key facet', plural: 'issuer key facets', ownedBy: 'organization',
+        properties: {
+            keyId: `${APPC}facetKeyId`,
+            thumbprint: `${APPC}facetPublicKeyThumbprint`,
+            facetHash: `${APPC}facetHash`,
+            attestation: `${APPC}anchoredBy`,
+            validFrom: `${APPC}facetValidFrom`,
+            validUntil: `${APPC}facetValidUntil`,
+        },
+    },
+    // THE DOOR'S record of a predicate held — beside the admission decision; the digests, never the bundle.
+    {
+        match: { prefix: 'door.credential:' }, class: `${APPC}PredicateAdmissionEvidence`,
+        label: 'predicate admission', plural: 'predicate admissions', ownedBy: 'either',
+        properties: {
+            issuerKeyId: `${APPC}facetKeyId`,
+            predicateDigest: `${APPC}evidencePredicateDigest`,
+            nullifierGrade: `${APPC}evidenceNullifierGrade`,
+            statusSequence: `${APPC}evidenceStatusSequence`,
+            verifierPlacement: `${APPC}verifierPlacement`,
+            at: `${PROV}generatedAtTime`,
+        },
+    },
+    // ── At the company's door (tbox/identity.ttl; spec 442 §3 / §4 / §8) ────────────────────────────
+    // What a person's agent holds for the doors it presents at. ADR-0055 decides each: lose the key binding and
+    // the service cannot present until the agent signs a new one (a credential, rebuilt by a ceremony, kept here
+    // because the ceremony is the owner's act); lose the pairwise secret and every company's `sub` is unreachable
+    // forever; lose an account link and the person is signed out at that company. The binding and the link are
+    // credentials the Security section LISTS (spec 422) — never the identity, never a Worker secret, read by no
+    // verifier (ADR-0041): what the agent may DO at a door is a mandate, judged per step.
+    {
+        match: { prefix: 'identity.client-key-binding:' }, class: `${AP}ClientKeyBinding`,
+        label: 'client key binding', plural: 'client key bindings', ownedBy: 'either',
+        properties: {
+            clientId: `${AP}clientId`,
+            jwkThumbprint: `${AP}jwkThumbprint`,
+            alg: `${AP}jwsAlgorithm`,
+            custodyEpoch: `${AP}boundUnderCustodyEpoch`,
+            notBefore: `${AP}bindingNotBefore`,
+            notAfter: `${AP}bindingNotAfter`,
+        },
+    },
+    // The secret her pairwise subjects derive from — one record, per person; a rotation is a new `sub` everywhere.
+    { match: { exact: 'identity.pairwise-secret' }, class: `${AP}PairwiseSubject`, label: 'pairwise secret (company subjects derive from it)', plural: 'pairwise secrets', ownedBy: 'person' },
+    {
+        match: { prefix: 'identity.external-account-link:' }, class: `${AP}ExternalAccountLink`,
+        label: 'account at a company', plural: 'accounts at companies', ownedBy: 'person',
+        properties: {
+            issuer: `${AP}pairwiseIssuer`,
+            pairwiseSubjectDigest: `${AP}pairwiseSubjectDigest`,
+            scopes: `${AP}grantedScope`,
+            grantedAt: `${AP}accountGrantedAt`,
+            expiresAt: `${AP}accountExpiresAt`,
+            lastUsedAt: `${AP}accountLastUsedAt`,
+        },
+    },
+    // ── PROJECTIONS, not things (role: 'index') ───────────────────────────────────────────────────
+    // Listed so that "not askable" is a DECISION on the record rather than an absence in this table. A
+    // question answered from an index is a question answered from a cache.
+    { match: { exact: 'conversation.index' }, class: `${APMSG}Conversation`, label: 'conversation index', plural: 'conversation index', ownedBy: 'either', role: 'index' },
+    { match: { exact: 'coordination.index' }, class: `${APCOORD}Endeavor`, label: 'endeavor index', plural: 'endeavor index', ownedBy: 'either', role: 'index' },
+    { match: { exact: 'inbox.data' }, class: `${APMSG}Conversation`, label: 'inbox', plural: 'inbox', ownedBy: 'either', role: 'index' },
+    { match: { exact: 'org.membership:local-names' }, class: `${APORG}OrganizationMembership`, label: 'local name map', plural: 'local name map', ownedBy: 'organization', role: 'index' },
+];
+/** What this record key IS, or `undefined` when nothing binds it. Longest match first, so a family and the
+ *  narrower family inside it (`…endeavor:` and `…endeavor:events:`) cannot be confused for one another. */
+export function bindingForRecordType(recordType) {
+    const key = recordType.trim();
+    const exact = VAULT_RECORD_BINDINGS.find((b) => b.match.exact === key);
+    if (exact)
+        return exact;
+    return [...VAULT_RECORD_BINDINGS]
+        .filter((b) => b.match.prefix && key.startsWith(b.match.prefix))
+        .sort((a, b) => (b.match.prefix.length - a.match.prefix.length))[0];
+}
+/** The kinds a question may be ASKED about — label → class. The askable set is this, never the model's. */
+export function askableRecordKinds() {
+    const seen = new Set();
+    const out = [];
+    for (const b of VAULT_RECORD_BINDINGS) {
+        // An index is not a thing to ask about — see `VaultRecordRole`.
+        if ((b.role ?? 'entity') !== 'entity' || seen.has(b.class))
+            continue;
+        seen.add(b.class);
+        out.push({ label: b.label, plural: b.plural, class: b.class });
+    }
+    return out;
+}
+/** Every record type bound to this class — what a query over a kind must actually read. */
+export function recordTypesForClass(classIri) {
+    return VAULT_RECORD_BINDINGS.filter((b) => b.class === classIri);
+}
+//# sourceMappingURL=vault-records.js.map