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

package/tbox/privacy-credential.ttl

@@ -0,0 +1,436 @@
+# T-box — the ANONYMOUS CREDENTIAL plane: what a holder proves about a credential without showing it, and every record
+# the substrate keeps around that proof. Spec 304 (issuer-key facets), spec 305 (privacy credentials, W2 = the
+# zero-knowledge suite), spec 442 §7.2 (the `predicate` proof grade at a company's door), spec 443 W5 (the door),
+# docs/architecture/zkid-and-verifiable-credentials-alignment.md (waves Z1–Z4). Namespace appc:.
+#
+# ── The doctrine, in one line ─────────────────────────────────────────────────────────────────────
+# PROOF IS EVIDENCE, THE MANDATE IS AUTHORITY, THE RECEIPT BINDS THE TWO. A presentation that verifies says "a
+# credential under this issuer facet satisfies this predicate program, answering this verifier's challenge" — and
+# nothing else: no claim value, no credential, no person. Whether the holder may ACT is her mandate's to say, judged
+# per step (ADR-0041); whether she may ENTER is the door's admission on the evidence (ADR-0056 / ADR-0057). No gate
+# reads an appc: record as a permission.
+#
+# ── What is deliberately NOT here ─────────────────────────────────────────────────────────────────
+# · No property from a pairwise account or a presentation to the PERSON. The verifier learns a handle and a proof; the
+#   link to the person exists in her own vault and nowhere in a shared graph (INV-305-1/-3, ADR-0025). A vocabulary
+#   that offered the join would be an invitation to make it.
+# · No claim values. A predicate program names claims and operators; a presentation proves the program held; the
+#   values stay in the credential, which stays with the holder.
+# · No product or implementation name. Suites and grades are codelists (cbox/controlled-vocabularies.ttl); the
+#   proving system behind a suite is informative and lives in the packages that bind it.
+#
+# ── Where the records live (ADR-0055) ─────────────────────────────────────────────────────────────
+# A facet document and its attestation are public (the issuer's chain). A credential and its device key are the
+# HOLDER's vault records. A presentation is computed per challenge and held by a door for minutes under a reference —
+# a cache; the receipt keeps the digests. The issuer row's openings are the ISSUER's vault records (apest:). A
+# predicate admission's evidence is the door's receipt, beside the decision.
+
+@prefix appc:   <https://agenticprimitives.dev/ns/privacy-credential#> .
+@prefix apvc:   <https://agenticprimitives.dev/ns/verifiable-credential#> .
+@prefix apatt:  <https://agenticprimitives.dev/ns/attestation#> .
+@prefix apdel:  <https://agenticprimitives.dev/ns/delegation#> .
+@prefix apest:  <https://agenticprimitives.dev/ns/estate#> .
+@prefix apix:   <https://agenticprimitives.dev/ns/interaction#> .
+@prefix ap:     <https://agenticprimitives.dev/ns/core#> .
+@prefix prov:   <http://www.w3.org/ns/prov#> .
+@prefix skos:   <http://www.w3.org/2004/02/skos/core#> .
+@prefix rdfs:   <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix owl:    <http://www.w3.org/2002/07/owl#> .
+@prefix xsd:    <http://www.w3.org/2001/XMLSchema#> .
+
+appc: a owl:Ontology ;
+  rdfs:label "Agentic Primitives — anonymous credentials" ;
+  owl:versionInfo "0.1.0" ;
+  rdfs:comment "Issuer-key facets, holder-bound credentials, proof requests and predicate programs, zero-knowledge presentations with their nullifiers and status, the issuer's live-credential row, the presentation mandate, and the predicate as admission evidence. Specs 304 / 305 / 442 §7.2 / 443 W5." .
+
+# ═══ The issuer side ══════════════════════════════════════════════════════════════════════════════
+
+appc:IssuerKeyFacet a owl:Class ;
+  rdfs:subClassOf prov:Entity ;
+  rdfs:label "IssuerKeyFacet" ;
+  rdfs:comment "A KEY AN ISSUING AGENT SIGNS CREDENTIALS WITH, published as a facet of that agent (spec 304): one suite per facet, a public key, a validity window, and the agent's own signature over the facet's hash. A facet rotates; the issuing agent does not (ADR-0010/0011) — the facet is a credential of the agent, never its identity, and never a control credential (that is apcr:CredentialFacet). A verifier resolves it by key id and RE-VERIFIES it through the chain: the signature answers under the agent's account, and the facet is anchored as an attestation (appc:anchoredBy) — never a fetch to the issuer." .
+
+appc:facetSubject a owl:ObjectProperty ;
+  rdfs:domain appc:IssuerKeyFacet ; rdfs:range ap:Agent ;
+  rdfs:label "facet subject" ;
+  rdfs:comment "The agent this key speaks for: an organization or a service. NEVER a person — a person's agent HOLDS credentials; it does not issue them (spec 443 §2). And never an estate's governance agent, whose row on neutral ground the issuer's own row would collide with (spec 443 W5)." .
+
+appc:facetKeyId a owl:DatatypeProperty ;
+  rdfs:domain appc:IssuerKeyFacet ; rdfs:range xsd:string ;
+  rdfs:label "facet key id" ;
+  rdfs:comment "The id a credential names its issuer key by and a verifier resolves the facet by (`issuer-key:<suite>:<label>`). A name for lookup, never a trust signal." .
+
+appc:facetSuite a owl:ObjectProperty ;
+  rdfs:domain appc:IssuerKeyFacet ; rdfs:range skos:Concept ;
+  rdfs:label "facet suite" ;
+  rdfs:comment "ONE suite per facet (INV-304-3), from appc:issuerKeySuiteScheme. A key reused across suites is two facets and two attestations." .
+
+appc:facetPublicKeyThumbprint a owl:DatatypeProperty ;
+  rdfs:domain appc:IssuerKeyFacet ; rdfs:range xsd:string ;
+  rdfs:label "facet public key thumbprint" ;
+  rdfs:comment "The JWK thumbprint of the facet's public key: what a listing shows and what a proof's hidden issuer key is checked against after verification. The key itself is in the facet document; never a private component." .
+
+appc:facetHash a owl:DatatypeProperty ;
+  rdfs:domain appc:IssuerKeyFacet ; rdfs:range xsd:string ;
+  rdfs:label "facet hash" ;
+  rdfs:comment "sha256 over the canonical facet document — what the issuing agent signed and what the attestation's credentialHash carries. A document that recomputes to another hash is not this facet." .
+
+appc:facetValidFrom a owl:DatatypeProperty ;
+  rdfs:domain appc:IssuerKeyFacet ; rdfs:range xsd:dateTime ;
+  rdfs:label "facet valid from" .
+
+appc:facetValidUntil a owl:DatatypeProperty ;
+  rdfs:domain appc:IssuerKeyFacet ; rdfs:range xsd:dateTime ;
+  rdfs:label "facet valid until" ;
+  rdfs:comment "Absent means open-ended; revocation is the attestation's revoke path, which a verifier reads at verification time (spec 304 §rotation)." .
+
+appc:anchoredBy a owl:ObjectProperty ;
+  rdfs:domain appc:IssuerKeyFacet ; rdfs:range apatt:Attestation ;
+  rdfs:label "anchored by" ;
+  rdfs:comment "The attestation on the issuer's chain that binds the facet to the agent: credentialType `issuer-key-facet`, subject = issuer = the agent, credentialHash = appc:facetHash. Live (not revoked) is what a verifier checks; the uid is what the register lists. Anchoring is the only way a stranger learns a facet is the agent's — the facet document alone proves nothing." .
+
+appc:IssuerRow a owl:Class ;
+  rdfs:subClassOf prov:Entity ;
+  rdfs:label "IssuerRow" ;
+  rdfs:comment "A CREDENTIAL ISSUER'S LIVE-CREDENTIAL ROOT ON NEUTRAL GROUND — the issuer's own row on the estate projection registry, keyed by the same id function as an estate's (chain + agent) and TAGGED as an issuer row so a verifier can tell it from an estate's (a credential leaf is never standing; a door refuses a row so tagged as if it were an estate). Its leaves are apest:ProjectionSubmission records in the `live-credential` set, kept by the issuer with their openings; the root is anchored under a monotonic sequence. REVOCATION IS THE ISSUER'S ACT: it retires a leaf and re-anchors, and every status presentation built at an older sequence is stale against the chain from then on. Zero-knowledge alignment §4, wave Z3." .
+
+appc:issuerRowOf a owl:ObjectProperty ;
+  rdfs:domain appc:IssuerRow ; rdfs:range ap:Agent ;
+  rdfs:label "issuer row of" ;
+  rdfs:comment "The issuing agent whose live set this is; the row's signer on neutral ground is the agent itself, and the key that writes is a delegate under its anchoring wire (spec 439 §4)." .
+
+appc:issuerRowId a owl:DatatypeProperty ;
+  rdfs:domain appc:IssuerRow ; rdfs:range xsd:string ;
+  rdfs:label "issuer row id" ;
+  rdfs:comment "keccak256(`eip155:<chainId>:<issuer agent>`) — the registry key. The only thing public ground learns about the issuer's set." .
+
+appc:liveCredentialRoot a owl:DatatypeProperty ;
+  rdfs:domain appc:IssuerRow ; rdfs:range xsd:string ;
+  rdfs:label "live-credential root" ;
+  rdfs:comment "The anchored Merkle root over the commitments of the credentials the issuer still stands behind, as of appc:anchoredSequence." .
+
+appc:anchoredSequence a owl:DatatypeProperty ;
+  rdfs:domain appc:IssuerRow ; rdfs:range xsd:integer ;
+  rdfs:label "anchored sequence" ;
+  rdfs:comment "Strictly increasing per anchor. A status presentation names the sequence it was built at; a verifier accepts only the sequence it READ, within its freshness window — behind is stale, ahead is unverifiable, neither is fetched." .
+
+appc:anchoredAt a owl:DatatypeProperty ;
+  rdfs:domain appc:IssuerRow ; rdfs:range xsd:dateTime ;
+  rdfs:label "anchored at" .
+
+appc:hasLiveCredentialLeaf a owl:ObjectProperty ;
+  rdfs:domain appc:IssuerRow ; rdfs:range apest:ProjectionSubmission ;
+  rdfs:label "has live-credential leaf" ;
+  rdfs:comment "A leaf of the row: an apest:ProjectionSubmission whose apest:projectionSet is `live-credential` and whose apest:vouchedDigest is the credential digest (appc:credentialDigest). The issuer's record, with the opening; absent from the chain." .
+
+# ═══ The holder side ══════════════════════════════════════════════════════════════════════════════
+
+appc:AnonymousCredential a owl:Class ;
+  rdfs:subClassOf apvc:VerifiableCredential ;
+  rdfs:label "AnonymousCredential" ;
+  rdfs:comment "A CREDENTIAL MADE TO BE PROVED ABOUT, NOT SHOWN: issued under an issuer-key facet, with its claims selectively disclosable and the HOLDER'S DEVICE KEY bound into it, so that a presentation can prove a predicate over the claims and possession of the key without revealing either. The holder's vault record (ADR-0055): the issuer keeps its digest in its live set, never the credential." .
+
+appc:issuedUnder a owl:ObjectProperty ;
+  rdfs:domain appc:AnonymousCredential ; rdfs:range appc:IssuerKeyFacet ;
+  rdfs:label "issued under" ;
+  rdfs:comment "The facet whose key signed the credential. A presentation names the facet's key id; the proof hides the key and the verifier checks the proven key against the resolved facet (spec 304 step 4)." .
+
+appc:boundToDeviceKey a owl:ObjectProperty ;
+  rdfs:domain appc:AnonymousCredential ; rdfs:range appc:DeviceKey ;
+  rdfs:label "bound to device key" ;
+  rdfs:comment "Holder binding: the public key in the credential's confirmation claim. A presentation is valid only with a signature by this key over the verifier's challenge — made inside the proof, so the key stays hidden." .
+
+appc:credentialDigest a owl:DatatypeProperty ;
+  rdfs:domain appc:AnonymousCredential ; rdfs:range xsd:string ;
+  rdfs:label "credential digest" ;
+  rdfs:comment "keccak256 over the issuer-signed compact credential (never the disclosures, which the holder chooses per presentation). Issuer and holder compute the same; it is the leaf of the issuer row's live set and the key of a status presentation." .
+
+appc:claimSchema a owl:DatatypeProperty ;
+  rdfs:range xsd:string ;
+  rdfs:label "claim schema" ;
+  rdfs:comment "The issuer-fixed disclosure order of a credential type — claim name per slot, as a JSON array string. A verifier knows the credential format and resolves claim names to slots directly; a request and a credential that disagree on it prove nothing. Declared on the credential and on the proof request." .
+
+appc:DeviceKey a owl:Class ;
+  rdfs:subClassOf prov:Entity ;
+  rdfs:label "DeviceKey" ;
+  rdfs:comment "THE HOLDER-BINDING KEY — custodied (a managed signer, or a local signer standing in for one), never held by the agent that presents. It signs ONLY under a presentation mandate (appc:PresentationMandate), judged by the presentation release inside every signature; the proving system sees a callback, never the key. Named by its thumbprint. It is a credential of the holder's, never her identity, and no property here leads from it to her." .
+
+appc:deviceKeyThumbprint a owl:DatatypeProperty ;
+  rdfs:domain appc:DeviceKey ; rdfs:range xsd:string ;
+  rdfs:label "device key thumbprint" .
+
+appc:PairwiseAccount a owl:Class ;
+  rdfs:subClassOf prov:Entity ;
+  rdfs:label "PairwiseAccount" ;
+  rdfs:comment "THE ACCOUNT A VERIFIER SEES: derived from the holder's secret and the verifier's origin, one per verifier, unlinkable across verifiers (INV-305-1), underivable without the secret. It signs the request proof at a door — the admission invariants want a signed actor (ADR-0010/0041) and this is the actor — and it appears in the door's receipt. It is NOT a Smart Agent and not the person: the link from it to her exists only in her vault, and this vocabulary declares no property for it on purpose." .
+
+appc:pairwiseFor a owl:DatatypeProperty ;
+  rdfs:domain appc:PairwiseAccount ; rdfs:range xsd:anyURI ;
+  rdfs:label "pairwise for" ;
+  rdfs:comment "The verifier's origin the account exists for. The same holder at another origin is another account." .
+
+# ═══ The exchange: request → presentation ═════════════════════════════════════════════════════════
+
+appc:ProofRequest a owl:Class ;
+  rdfs:subClassOf prov:Entity ;
+  rdfs:label "ProofRequest" ;
+  rdfs:comment "WHAT A VERIFIER ASKS — built by the verifier from ITS OWN policy and ITS OWN challenge, never from a presentation: one suite, the predicates to prove, the credential layout accepted, the proof-bundle versions bound to its verifying keys, an audience (the verifier's origin) and a single-use nonce. The holder reproduces it from the verifier's published policy so both sides digest the same predicate program." .
+
+appc:requestSuite a owl:ObjectProperty ;
+  rdfs:domain appc:ProofRequest ; rdfs:range skos:Concept ;
+  rdfs:label "request suite" ;
+  rdfs:comment "ONE suite per request (ADR-0013 — no ladder), from appc:presentationSuiteScheme. A presentation in any other suite is refused, never downgraded." .
+
+appc:verifierId a owl:DatatypeProperty ;
+  rdfs:domain appc:ProofRequest ; rdfs:range xsd:string ;
+  rdfs:label "verifier id" .
+
+appc:audience a owl:DatatypeProperty ;
+  rdfs:range xsd:anyURI ;
+  rdfs:label "audience" ;
+  rdfs:comment "The verifier's origin the proof is bound to. On the request, the nullifier, the status presentation and the mandate alike: a thing made for one audience answers no other." .
+
+appc:challengeNonce a owl:DatatypeProperty ;
+  rdfs:domain appc:ProofRequest ; rdfs:range xsd:string ;
+  rdfs:label "challenge nonce" ;
+  rdfs:comment "Single-use. The verifier consumes it before a proof is verified, so the same challenge is never answered twice (1/OPENAC §Challenge Freshness as deployment policy)." .
+
+appc:asksPredicate a owl:ObjectProperty ;
+  rdfs:domain appc:ProofRequest ; rdfs:range appc:PredicateProgram ;
+  rdfs:label "asks predicate" .
+
+appc:acceptedBundleVersion a owl:DatatypeProperty ;
+  rdfs:domain appc:ProofRequest ; rdfs:range xsd:string ;
+  rdfs:label "accepted bundle version" ;
+  rdfs:comment "A proof-bundle version this verifier has bound to its tuple of verifying keys, circuit parameters, profile and challenge pipeline. Anything unbound is refused (1/OPENAC §Versioning). Repeatable." .
+
+appc:PredicateProgram a owl:Class ;
+  rdfs:subClassOf prov:Entity ;
+  rdfs:label "PredicateProgram" ;
+  rdfs:comment "THE STATEMENT PROVED: a conjunction of predicates over named claims, compiled to the suite's canonical form and digested. The digest is what a holder's mandate names and what a receipt cites — the same program at the same verifier is the same reason, which is what makes a mandate standing across challenges rather than a signature per nonce." .
+
+appc:predicateDigest a owl:DatatypeProperty ;
+  rdfs:range xsd:string ;
+  rdfs:label "predicate digest" ;
+  rdfs:comment "The intent digest of the compiled, canonical program. Computed by the verifier from its own request and by the holder from the published policy; a disagreement derives no mandate." .
+
+appc:hasPredicate a owl:ObjectProperty ;
+  rdfs:domain appc:PredicateProgram ; rdfs:range appc:Predicate ;
+  rdfs:label "has predicate" .
+
+appc:Predicate a owl:Class ;
+  rdfs:subClassOf prov:Entity ;
+  rdfs:label "Predicate" ;
+  rdfs:comment "One claim, one operator, one operand: `age gte 18`. No claim VALUE of the holder's appears anywhere in this vocabulary — the operand is the verifier's threshold." .
+
+appc:predicateClaim a owl:DatatypeProperty ;
+  rdfs:domain appc:Predicate ; rdfs:range xsd:string ;
+  rdfs:label "predicate claim" .
+
+appc:predicateOp a owl:ObjectProperty ;
+  rdfs:domain appc:Predicate ; rdfs:range skos:Concept ;
+  rdfs:label "predicate operator" ;
+  rdfs:comment "From appc:predicateOpScheme: gte · lte · in-set · before · after." .
+
+appc:predicateOperand a owl:DatatypeProperty ;
+  rdfs:domain appc:Predicate ; rdfs:range xsd:string ;
+  rdfs:label "predicate operand" ;
+  rdfs:comment "The threshold, set member list or date, as the suite's lexical form. A literal out of the suite's range is a refusal (`predicate_invalid`), not a wider circuit." .
+
+appc:PrivatePresentation a owl:Class ;
+  rdfs:subClassOf prov:Entity ;
+  rdfs:label "PrivatePresentation" ;
+  rdfs:comment "WHAT A HOLDER ANSWERS WITH: a proof that a credential under the named facet satisfies the request's predicate program and that the device key signed the request's audience-bound challenge — the issuer key, the device key and every claim hidden; plus, when the verifier's policy asks, a nullifier for this audience and the issuer's status presentation. Computed per challenge, never stored by the holder; held by a door for minutes under a reference (a cache); only its digest survives in a receipt. It says nothing about who presented." .
+
+appc:answersRequest a owl:ObjectProperty ;
+  rdfs:domain appc:PrivatePresentation ; rdfs:range appc:ProofRequest ;
+  rdfs:label "answers request" ;
+  rdfs:comment "The one request this proof answers; the audience and nonce inside the proof must be the request's (`nonce_or_audience_mismatch` otherwise)." .
+
+appc:presentedUnder a owl:ObjectProperty ;
+  rdfs:domain appc:PrivatePresentation ; rdfs:range appc:IssuerKeyFacet ;
+  rdfs:label "presented under" ;
+  rdfs:comment "The facet the presentation claims, by key id. The verifier resolves it through the chain and checks the proven issuer key against it; a reference naming another facet than the verdict's is refused." .
+
+appc:provesPredicate a owl:ObjectProperty ;
+  rdfs:domain appc:PrivatePresentation ; rdfs:range appc:PredicateProgram ;
+  rdfs:label "proves predicate" ;
+  rdfs:comment "The program that held — `expression_result = 1` inside the proof. Evidence that the predicate holds, never policy acceptance (that is the verifier's), never authority." .
+
+appc:bundleVersion a owl:DatatypeProperty ;
+  rdfs:domain appc:PrivatePresentation ; rdfs:range xsd:string ;
+  rdfs:label "bundle version" .
+
+appc:relationshipHandle a owl:DatatypeProperty ;
+  rdfs:domain appc:PrivatePresentation ; rdfs:range xsd:string ;
+  rdfs:label "relationship handle" ;
+  rdfs:comment "The pairwise pseudonym for THIS verifier when the holder chooses to carry one (INV-305-3) — never her agent." .
+
+appc:carriesNullifier a owl:ObjectProperty ;
+  rdfs:domain appc:PrivatePresentation ; rdfs:range appc:Nullifier ;
+  rdfs:label "carries nullifier" .
+
+appc:carriesStatus a owl:ObjectProperty ;
+  rdfs:domain appc:PrivatePresentation ; rdfs:range appc:CredentialStatusPresentation ;
+  rdfs:label "carries status" .
+
+appc:signedByDeviceKey a owl:ObjectProperty ;
+  rdfs:domain appc:PrivatePresentation ; rdfs:range appc:DeviceKey ;
+  rdfs:label "signed by device key" ;
+  rdfs:comment "The holder's own record of which custodied key answered the challenge — inside the proof the key is hidden, so this relation lives in her vault, never in what a verifier holds." .
+
+appc:madeUnderMandate a owl:ObjectProperty ;
+  rdfs:domain appc:PrivatePresentation ; rdfs:range appc:PresentationMandate ;
+  rdfs:label "made under mandate" ;
+  rdfs:comment "The child mandate the device key signed under — the holder's receipt joins the proof digest, the challenge digest and this mandate's digest (apvr:, spec 305 §Z2). The verifier never sees the mandate; it is the holder's evidence that her agent acted within what she allowed." .
+
+appc:presents a owl:ObjectProperty ;
+  rdfs:subPropertyOf prov:wasDerivedFrom ;
+  rdfs:domain appc:PrivatePresentation ; rdfs:range appc:AnonymousCredential ;
+  rdfs:label "presents" ;
+  rdfs:comment "Which credential the proof was made from — the holder's record only. A verifier that could state this triple would have unlinked nothing." .
+
+appc:Nullifier a owl:Class ;
+  rdfs:subClassOf prov:Entity ;
+  rdfs:label "Nullifier" ;
+  rdfs:comment "ONE VISIT PER AUDIENCE: a value deterministic per (device key, audience) — a hash of the device key's signature over an audience-bound message — that a verifier's store consumes atomically. The same holder at the same audience within the policy's window is `nullifier_reused`; at another audience the value differs and nothing links them. Its GRADE says how much it is worth: `asserted` is honest-holder-exact (the verifier checks nothing about its derivation), `in-circuit` is proved inside the presentation (2/ZK-POP; reserved until the profile emits it). The STORE is the verifier's (a door's ledger), never the verifying service's." .
+
+appc:nullifierValue a owl:DatatypeProperty ;
+  rdfs:domain appc:Nullifier ; rdfs:range xsd:string ;
+  rdfs:label "nullifier value" .
+
+appc:nullifierGrade a owl:ObjectProperty ;
+  rdfs:domain appc:Nullifier ; rdfs:range skos:Concept ;
+  rdfs:label "nullifier grade" ;
+  rdfs:comment "From appc:nullifierGradeScheme. A verifier's policy names the lowest grade it accepts; `in-circuit` refuses every asserted one." .
+
+appc:CredentialStatusPresentation a owl:Class ;
+  rdfs:subClassOf prov:Entity ;
+  rdfs:label "CredentialStatusPresentation" ;
+  rdfs:comment "THE ISSUER STILL STANDS BEHIND THIS CREDENTIAL, as of a sequence: one leaf of the issuer row, its opening, a Merkle proof against the anchored root, bound to the verifier's challenge. Names no subject — a credential is not a person. The verifier reads the root from neutral ground, never from the holder: a presentation behind the anchored sequence is `stale` (what a revoked credential's old status becomes), ahead is unverifiable, and neither is fetched. Linkable under the Merkle suite (the opening names the credential) — said, and the reason a verifier asks for it only where it would otherwise phone a status list; the zero-knowledge form is reserved." .
+
+appc:statusOf a owl:ObjectProperty ;
+  rdfs:domain appc:CredentialStatusPresentation ; rdfs:range appc:IssuerRow ;
+  rdfs:label "status of" .
+
+appc:statusSequence a owl:DatatypeProperty ;
+  rdfs:domain appc:CredentialStatusPresentation ; rdfs:range xsd:integer ;
+  rdfs:label "status sequence" ;
+  rdfs:comment "The anchored sequence the proof was built against; a verifier accepts the sequence it read and refuses every other." .
+
+# ═══ Authority around the proof (never the proof itself) ══════════════════════════════════════════
+
+appc:PresentationMandate a owl:Class ;
+  rdfs:subClassOf apdel:Delegation ;
+  rdfs:label "PresentationMandate" ;
+  rdfs:comment "THE PERSON'S STANDING PERMISSION FOR HER DEVICE KEY TO SIGN (capability `credential.present`): a delegation from her agent to her runtime's key bounded to the verifiers, the predicate programs and the issuer facets she agreed to, for a window. Her runtime derives a CHILD for one statement (one audience, one program, one facet, a few minutes) and the presentation release judges that child before EVERY device-key signature — the key is behind the release, the proving system gets a callback. A wire for another venue signs nothing (the release refuses; nothing is presented). Delegated presentation, zero-knowledge alignment §3, wave Z2." .
+
+appc:mandateAudience a owl:DatatypeProperty ;
+  rdfs:domain appc:PresentationMandate ; rdfs:range xsd:anyURI ;
+  rdfs:label "mandate audience" ;
+  rdfs:comment "A verifier origin the mandate covers. Repeatable on a standing wire; exactly one on a derived child." .
+
+appc:mandatePredicateDigest a owl:DatatypeProperty ;
+  rdfs:domain appc:PresentationMandate ; rdfs:range xsd:string ;
+  rdfs:label "mandate predicate digest" ;
+  rdfs:comment "A predicate program the mandate covers, by its digest (appc:predicateDigest). The holder proves no program she did not agree to." .
+
+appc:mandateIssuerKeyId a owl:DatatypeProperty ;
+  rdfs:domain appc:PresentationMandate ; rdfs:range xsd:string ;
+  rdfs:label "mandate issuer key id" ;
+  rdfs:comment "A facet (appc:facetKeyId) the mandate covers presenting under." .
+
+appc:maxPresentations a owl:DatatypeProperty ;
+  rdfs:domain appc:PresentationMandate ; rdfs:range xsd:integer ;
+  rdfs:label "max presentations" ;
+  rdfs:comment "How many presentations the mandate allows; 0 on a standing wire means unbounded within its window, 1 on a derived child." .
+
+appc:PresentationRelease a owl:Class ;
+  rdfs:subClassOf prov:Activity ;
+  rdfs:label "PresentationRelease" ;
+  rdfs:comment "ONE JUDGEMENT OF THE MANDATE FOR ONE SIGNATURE: the release checks the child mandate against the statement (audience · predicate digest · facet), its signature, its revocation on chain and its window, then signs the audience-bound challenge with the device key — or refuses with a code (`mandate-denied`, `challenge-unbound`, `audience-mismatch`, `approval-required`). Every decision, allowed or refused, is the receipt's raw material." .
+
+appc:releasedUnder a owl:ObjectProperty ;
+  rdfs:domain appc:PresentationRelease ; rdfs:range appc:PresentationMandate ;
+  rdfs:label "released under" .
+
+appc:releaseOutcome a owl:DatatypeProperty ;
+  rdfs:domain appc:PresentationRelease ; rdfs:range xsd:string ;
+  rdfs:label "release outcome" ;
+  rdfs:comment "`allow`, or the refusal code. A refusal signs nothing." .
+
+# ═══ The verifier's policy, and the predicate as admission evidence ═══════════════════════════════
+
+appc:VerifierPolicy a owl:Class ;
+  rdfs:subClassOf prov:Entity ;
+  rdfs:label "VerifierPolicy" ;
+  rdfs:comment "WHAT A VERIFIER (a door) ASKS AND ACCEPTS, declared where a holder can read it: the predicate program, the credential layout, the accepted bundle versions, whether a nullifier is required and at which grade and window, whether the issuer's status is required and how fresh, which issuer facets it trusts, and where the proof is verified. 1/OPENAC's `Deployment policy` layer is the authority plane's: nothing in a policy grants, it says what the door will LOOK AT." .
+
+appc:policyAsksPredicate a owl:ObjectProperty ;
+  rdfs:domain appc:VerifierPolicy ; rdfs:range appc:PredicateProgram ;
+  rdfs:label "policy asks predicate" .
+
+appc:requiresNullifier a owl:DatatypeProperty ;
+  rdfs:domain appc:VerifierPolicy ; rdfs:range xsd:boolean ;
+  rdfs:label "requires nullifier" .
+
+appc:acceptsNullifierGrade a owl:ObjectProperty ;
+  rdfs:domain appc:VerifierPolicy ; rdfs:range skos:Concept ;
+  rdfs:label "accepts nullifier grade" ;
+  rdfs:comment "The lowest grade accepted (appc:nullifierGradeScheme)." .
+
+appc:nullifierWindowSeconds a owl:DatatypeProperty ;
+  rdfs:domain appc:VerifierPolicy ; rdfs:range xsd:integer ;
+  rdfs:label "nullifier window seconds" ;
+  rdfs:comment "One visit per audience PER WINDOW: the store forgets a value after it (epoch-scoped persistence), and the store is keyed by the window too, so a door that changes its rule starts a fresh count. Absent means once, for as long as the door remembers." .
+
+appc:requiresStatus a owl:DatatypeProperty ;
+  rdfs:domain appc:VerifierPolicy ; rdfs:range xsd:boolean ;
+  rdfs:label "requires status" .
+
+appc:statusMaxAgeSeconds a owl:DatatypeProperty ;
+  rdfs:domain appc:VerifierPolicy ; rdfs:range xsd:integer ;
+  rdfs:label "status max age seconds" ;
+  rdfs:comment "How old the anchored sequence a status is verified against may be. Older is refused, not re-fetched." .
+
+appc:trustsIssuerFacet a owl:ObjectProperty ;
+  rdfs:domain appc:VerifierPolicy ; rdfs:range appc:IssuerKeyFacet ;
+  rdfs:label "trusts issuer facet" ;
+  rdfs:comment "A facet the verifier will resolve a presentation's key id against — listed in a register and re-verified on the issuer's chain at every verification. Listing is not trust: the chain is." .
+
+appc:verifierPlacement a owl:ObjectProperty ;
+  rdfs:range skos:Concept ;
+  rdfs:label "verifier placement" ;
+  rdfs:comment "Where the proof is verified (appc:verifierPlacementScheme): `node` when the verifying keys do not fit the edge runtime, `worker` when they do. On the policy as a declaration and on the evidence as a fact; a receipt that cannot say where a proof was checked is not a receipt." .
+
+appc:PredicateAdmissionEvidence a owl:Class ;
+  rdfs:subClassOf prov:Entity ;
+  rdfs:label "PredicateAdmissionEvidence" ;
+  rdfs:comment "THE PREDICATE HELD, AS WHAT A DOOR KEPT: the facet the proof verified under, the predicate program's digest, the nullifier's grade, the status sequence read from neutral ground, where the proof was verified — beside the admission decision, contributed by the door's `binding-credential-presentation` stage. The `predicate` proof grade of spec 442 §7.2. EVIDENCE, NEVER AUTHORITY (ADR-0056/0057): it says a credential satisfied the door's question; the estate's own mandate still governs every act the visitor asks for. No claim value, no person; the acting account is the pairwise one." .
+
+appc:evidenceFacet a owl:ObjectProperty ;
+  rdfs:domain appc:PredicateAdmissionEvidence ; rdfs:range appc:IssuerKeyFacet ;
+  rdfs:label "evidence facet" .
+
+appc:evidencePredicateDigest a owl:DatatypeProperty ;
+  rdfs:domain appc:PredicateAdmissionEvidence ; rdfs:range xsd:string ;
+  rdfs:label "evidence predicate digest" ;
+  rdfs:comment "The DOOR'S own digest of the program it asked — computed from its request, never read from the presentation." .
+
+appc:evidenceNullifierGrade a owl:ObjectProperty ;
+  rdfs:domain appc:PredicateAdmissionEvidence ; rdfs:range skos:Concept ;
+  rdfs:label "evidence nullifier grade" .
+
+appc:evidenceStatusSequence a owl:DatatypeProperty ;
+  rdfs:domain appc:PredicateAdmissionEvidence ; rdfs:range xsd:integer ;
+  rdfs:label "evidence status sequence" .
+
+appc:evidencedIn a owl:ObjectProperty ;
+  rdfs:domain appc:PredicateAdmissionEvidence ; rdfs:range apix:AdmissionReceipt ;
+  rdfs:label "evidenced in" ;
+  rdfs:comment "The admission receipt the evidence sits beside. Admission is not authorization (ADR-0043)." .
+
+appc:proofGrade a owl:ObjectProperty ;
+  rdfs:range skos:Concept ;
+  rdfs:label "proof grade" ;
+  rdfs:comment "Which kind of proof a visitor presented at a door (appc:proofGradeScheme, spec 442 §7.2): `identity` (the agent as itself), `standing` (a leaf of another estate's authority projection), `predicate` (this module). A door says which grades it accepts; a grade is never a rank." .

package/tbox/profile.ttl

@@ -0,0 +1,107 @@
+# T-box — the public agent PROFILE facet (spec 217 / 282 / 331; facet-registries.md §2, G2–G4).
+#
+# What this module owns: the SA-keyed, owner-written, unconditionally PUBLIC self-description
+# published through `AgentProfileResolver` under `atl:*` predicates and projected into the
+# discovery knowledge graph as `approf:*` (apps/demo-discovery-indexer PROFILE_KEYS).
+#
+# Until now `approf:` was a declared namespace with NO T-box file: `approf:displayName`,
+# `approf:description` and `approf:skills` were emitted into the production graph by the indexer
+# and read by the MCP without ever being declared. This module closes that (ADR-0009: on-chain
+# ontology governs records; ADR-0013: no read path for an undeclared term).
+#
+# ── The identifier / prose split (ADR-0051, facet-registries §7) ─────────────────────────────
+# The on-chain predicate key is `atl:skills` and is immutable (its id is keccak256("atl:skills"),
+# already registered and already written into live agents' profiles). The T-box term is
+# `approf:skills`. Both are OPAQUE KEYS. What they carry is a set of DECLARED CAPABILITY
+# PROJECTIONS (aps:CapabilityProtocolProjection, related by aps:declaresCapability) — the weakest
+# of the three assertion strengths. Prose and UI always say "capability".
+#
+# ── Assertion strength (capability-architecture.md §2) ───────────────────────────────────────
+# Everything in this module is SELF-DECLARED and unverified. It feeds discovery FIT scoring only.
+# Nothing here is a claim credential (aps:claimsCapability — private vault VC), nothing here is
+# demonstrated (aps:demonstratedCapability — execution provenance), and nothing here authorizes
+# anything (authority is delegation ∩ entitlement ∩ policy, at the gate).
+
+@prefix approf: <https://agenticprimitives.dev/ns/profile#> .
+@prefix ap:     <https://agenticprimitives.dev/ns/core#> .
+@prefix aps:    <https://agenticprimitives.dev/ns/skill#> .
+@prefix apctx:  <https://agenticprimitives.dev/ns/context#> .
+@prefix apg:    <https://agenticprimitives.dev/ns/geo#> .
+@prefix rdf:    <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix rdfs:   <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix owl:    <http://www.w3.org/2002/07/owl#> .
+@prefix xsd:    <http://www.w3.org/2001/XMLSchema#> .
+@prefix prov:   <http://www.w3.org/ns/prov#> .
+@prefix dul:    <http://www.ontologydesignpatterns.org/ont/dul/DUL.owl#> .
+
+approf: a owl:Ontology ;
+  rdfs:label "Agentic Primitives — public agent profile ontology" ;
+  owl:versionInfo "0.1.0" ;
+  rdfs:comment "SA-keyed public self-description projected from AgentProfileResolver. Owner-asserted, opt-in, unconditionally public, discovery-rankable. Self-declared evidence only — never a credential, never authority." .
+
+approf:AgentProfile a owl:Class ;
+  rdfs:subClassOf ap:Facet , prov:Entity , dul:InformationObject ;
+  rdfs:label "AgentProfile" ;
+  rdfs:comment "The public self-description facet of ONE Smart Agent, keyed by the SA address (never by a name node — it must survive a rename and exist for nameless agents, ADR-0010/0020)." .
+
+approf:describesAgent a owl:ObjectProperty ;
+  rdfs:domain approf:AgentProfile ; rdfs:range ap:CanonicalAgentId ;
+  rdfs:label "describesAgent" .
+
+# ─── Existing, live predicates — declared here for the first time ───────────
+
+approf:displayName a owl:DatatypeProperty ;
+  rdfs:domain approf:AgentProfile ; rdfs:range xsd:string ;
+  rdfs:label "displayName" ;
+  rdfs:comment "atl:displayName. The agent's own public display name. Distinct from the name-node label and from any vault display name (agent-metadata-tiers.md: same field name ≠ same field; never auto-synced)." .
+
+approf:description a owl:DatatypeProperty ;
+  rdfs:domain approf:AgentProfile ; rdfs:range xsd:string ;
+  rdfs:label "description" ;
+  rdfs:comment "atl:description, SA-keyed. NOT the node-keyed name-record description (apnam:description) — facet-registries G8: emitting both under this IRI lets tier 2 clobber tier 3 by loop order. Free text; a SECONDARY carrier only, never a structured filter target." .
+
+approf:skills a owl:DatatypeProperty ;
+  rdfs:domain approf:AgentProfile ; rdfs:range xsd:string ;
+  rdfs:label "skills (declared capability projections)" ;
+  rdfs:comment "atl:skills (spec 282). Comma-joined DECLARED CAPABILITY PROJECTIONS — aps:CapabilityProtocolProjection nodes related by aps:declaresCapability. Legacy key retained for ABI (ADR-0051); prose says 'declared capabilities'. Spec 331 migrates the value space from free-text labels to canonical catalog capability ids." .
+
+approf:declaresCapabilityId a owl:DatatypeProperty ;
+  rdfs:domain approf:AgentProfile ; rdfs:range xsd:string ;
+  rdfs:label "declaresCapabilityId" ;
+  rdfs:comment "Spec 331 — the PARSED, resolvable capability id carried inside an approf:skills token (e.g. 'adv:estate-planning'). One triple per id, projected by the indexer so the matcher can do set-membership instead of substring search. The datatype is a string, not an IRI, because the token is exactly what the agent wrote on chain; resolution to an aps:Capability IRI is the catalog's job and may fail (an unresolvable id is an honest miss, never a silent skip — ADR-0013)." .
+
+# ─── G2 / G3 / G4 — the three facets registered by governor tx
+#     0x53acec54d850b8a790da4feda055abf81a0c2f203c1a69d0644d1a1138a18789 ──────
+
+approf:languages a owl:DatatypeProperty ;
+  rdfs:domain approf:AgentProfile ; rdfs:range xsd:string ;
+  rdfs:label "languages" ;
+  apctx:classifiedBy apctx:LanguageFacet ;
+  rdfs:comment "atl:languages (facet-registries G2). VALUE SPACE: comma-separated BCP-47 language tags, normalized lowercase, e.g. 'es,en,pt-br'. Matching is subtag-prefix based ('es' matches 'es-ES'), never substring. A flat string for parity with atl:skills; per-language proficiency waits for spec 330 and is a value-space migration inside this one predicate, not a new one. RANKING ROLE: soft boost, plus an OPT-IN hard mandate (requireLanguage) that a caller must ask for explicitly." .
+
+approf:regions a owl:DatatypeProperty ;
+  rdfs:domain approf:AgentProfile ; rdfs:range xsd:string ;
+  rdfs:label "regions" ;
+  apctx:classifiedBy apctx:JurisdictionFacet ;
+  rdfs:comment "atl:regions (facet-registries G3). VALUE SPACE: comma-separated UPPERCASE codes drawn from the GeoFeatureRegistry controlled vocabulary (spec 251) — ISO 3166-1 alpha-2, ISO 3166-2 subdivisions, or a registered supranational feature code, e.g. 'EU,ES,ES-CT'. Requiring the value space to be GeoFeatureRegistry-drawn is what makes a later upgrade to explicit (featureId, version) references a VALUE-SPACE migration inside one predicate rather than a new predicate + projector + UI. RELATION COLLAPSE (accepted v1 limitation): this flattens the five apg:geoRelation values — servesWithin, operatesIn, licensedIn, residentOf, originIn — into one list. servesWithin and licensedIn are materially different claims for a regulated advisor; if that distinction becomes load-bearing, add a second predicate (atl:licensedIn), never structure inside this string. The full truth stays in the private apg: GeoClaimCredential." .
+
+approf:focusAreas a owl:DatatypeProperty ;
+  rdfs:domain approf:AgentProfile ; rdfs:range xsd:string ;
+  rdfs:label "focusAreas" ;
+  apctx:classifiedBy apctx:KnowledgeDomain ;
+  rdfs:comment "atl:focusAreas (facet-registries G4). VALUE SPACE: comma-separated subject-domain labels, lowercase-hyphenated, e.g. 'modelo-720,forced-heirship'. Maps to the apctx:KnowledgeDomain facet so it stays ORTHOGONAL to capability identity — a focus area is a subject, never a declared capability (ADR-0051). RANKING ROLE: fitScore boost ONLY, capped hardest of the three. It must NEVER become a hard filter: a focus area is an emphasis, not a boundary, and an agent that has not published one is UNKNOWN, not absent." .
+
+# ─── spec 347 §8.5 — how to obtain and run the agent's software ──────────────
+
+approf:distribution a owl:DatatypeProperty ;
+  rdfs:domain approf:AgentProfile ; rdfs:range xsd:string ;
+  rdfs:label "distribution" ;
+  rdfs:comment "atl:distribution (spec 347 §8.5; docs/architecture/ard-acp-crosswalk.md §2–§3). A JSON literal per agent-profile `AgentDistributionV1` (JCS-canonical): `acp?` (Agent Client Protocol conformance — the eligibility flag for a hosted ACP registry.json projection), `version?` (implementation semver), `npx`/`uvx` { package, args?, env? }, `binary` { <platform>: { archive, cmd, sha256?, args?, env? } } with the six ACP platform keys. Field names mirror the ACP registry agent.schema.json so a registry file is a COPY of this fact, never a translation. SA-keyed (survives a rename, exists for nameless agents), written only by the agent itself. PUBLIC and on-chain-derivable (ADR-0040): the KB carries the string exactly as written on chain; a consumer parses it fail-closed (an unparsable literal is `null`, never a guess — ADR-0013). It describes distribution ONLY — it is not a capability claim, not a trust signal, and grants nothing." .
+
+# ─── The value-space anchors these three point at ───────────────────────────
+
+approf:regionVocabulary a owl:AnnotationProperty ;
+  rdfs:label "regionVocabulary" ;
+  rdfs:comment "Declares which controlled vocabulary an approf:regions value space draws from. Points at apg: (GeoFeatureRegistry) — see cbox/profile-facet-vocabulary.ttl." .
+
+approf:regions approf:regionVocabulary apg:geoKind .

package/tbox/prov-imports.ttl

@@ -0,0 +1,73 @@
+# T-box — the W3C PROV-O terms this substrate EMITS, declared (spec 389).
+#
+# ── Why a file that declares someone else's vocabulary ───────────────────────────────────────────
+# PROV-O is a W3C Recommendation and its terms mean what the Recommendation says — nothing here
+# redefines one. They are declared here for the same reason plan.ttl declares the P-Plan terms it
+# uses: the build's ontology-bindings gate (`check:ontology-bindings`) and the SHACL shapes need every
+# IRI a record binds to to be DECLARED somewhere in tbox/, or they cannot tell an imported standard
+# term from a typo. A run's provenance record (`run.provenance:<runRef>`) binds its fields to these
+# by IRI (`src/vault-records.ts`), and the run-provenance JSON-LD context maps its terms onto them.
+#
+# The list is exactly what the provenance projector emits (packages/provenance): the PROV core
+# classes, the qualified association, and the direct relations. Nothing is declared that nothing
+# emits — a term added here should be a term a record carries.
+#
+# Domains and ranges are omitted: PROV-O's own axioms govern, and restating them here would let the
+# two drift.
+
+@prefix prov: <http://www.w3.org/ns/prov#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix owl:  <http://www.w3.org/2002/07/owl#> .
+
+<https://agenticprimitives.dev/ns/prov-imports> a owl:Ontology ;
+    rdfs:label "Agentic Primitives — PROV-O terms in use" ;
+    owl:versionInfo "0.1.1" ;
+    rdfs:comment "Declarations of the W3C PROV-O terms the substrate's provenance records carry, so bindings and shapes can target them. Spec 389; spec 316 §6." .
+
+# ═══ Core classes ═══
+
+prov:Entity a owl:Class ; rdfs:label "Entity (PROV-O)" .
+prov:Activity a owl:Class ; rdfs:label "Activity (PROV-O)" .
+prov:Agent a owl:Class ; rdfs:label "Agent (PROV-O)" .
+prov:SoftwareAgent a owl:Class ; rdfs:subClassOf prov:Agent ; rdfs:label "SoftwareAgent (PROV-O)" .
+prov:Person a owl:Class ; rdfs:subClassOf prov:Agent ; rdfs:label "Person (PROV-O)" .
+prov:Organization a owl:Class ; rdfs:subClassOf prov:Agent ; rdfs:label "Organization (PROV-O)" .
+prov:Bundle a owl:Class ; rdfs:subClassOf prov:Entity ; rdfs:label "Bundle (PROV-O)" ;
+    rdfs:comment "A named set of provenance descriptions. One harness run = one bundle (an ep-plan:ExecutionTraceBundle, plan.ttl); a routed run's bundle prov:wasInformedBy the sender's." .
+prov:Plan a owl:Class ; rdfs:subClassOf prov:Entity ; rdfs:label "Plan (PROV-O)" .
+prov:Role a owl:Class ; rdfs:label "Role (PROV-O)" .
+prov:Association a owl:Class ; rdfs:label "Association (PROV-O)" ;
+    rdfs:comment "The qualified form of wasAssociatedWith: which agent, under which plan (prov:hadPlan), in which capacity (prov:hadRole). A run carries two — the runtime under the run's ExecutionPlan, the agent under its playbook." .
+
+# ═══ Direct relations ═══
+
+prov:startedAtTime a owl:DatatypeProperty ; rdfs:label "startedAtTime (PROV-O)" .
+prov:endedAtTime a owl:DatatypeProperty ; rdfs:label "endedAtTime (PROV-O)" .
+# An ENTITY's two times, as distinct from an activity's start and end above (spec 410 §4 / estate.ttl): when the
+# record came into being, and when it stopped holding. A retired vouch keeps its generatedAtTime and gains an
+# invalidatedAtTime; it is never deleted, because a projection that silently forgets a retirement cannot be audited.
+prov:generatedAtTime a owl:DatatypeProperty ; rdfs:label "generatedAtTime (PROV-O)" .
+prov:invalidatedAtTime a owl:DatatypeProperty ; rdfs:label "invalidatedAtTime (PROV-O)" .
+prov:wasAssociatedWith a owl:ObjectProperty ; rdfs:label "wasAssociatedWith (PROV-O)" .
+prov:actedOnBehalfOf a owl:ObjectProperty ; rdfs:label "actedOnBehalfOf (PROV-O)" ;
+    rdfs:comment "PRIVATE DETAIL in this substrate: the S1 firewall (provenance/firewall.ts) rejects it from any public row (ADR-0040)." .
+prov:wasAttributedTo a owl:ObjectProperty ; rdfs:label "wasAttributedTo (PROV-O)" .
+prov:used a owl:ObjectProperty ; rdfs:label "used (PROV-O)" ;
+    rdfs:comment "What an activity consumed. For a harness step: every delegation in its verified chain, BY REFERENCE (apvr:usedDelegation ⊑ prov:used names the one it presented)." .
+prov:generated a owl:ObjectProperty ; rdfs:label "generated (PROV-O)" .
+prov:wasGeneratedBy a owl:ObjectProperty ; rdfs:label "wasGeneratedBy (PROV-O)" .
+prov:wasInformedBy a owl:ObjectProperty ; rdfs:label "wasInformedBy (PROV-O)" ;
+    rdfs:comment "Activity-to-activity communication. A routed run's root activity wasInformedBy the sender's; a hand-off step wasInformedBy the child run. NOT containment — apexec:hasStep is (execution.ttl)." .
+prov:wasDerivedFrom a owl:ObjectProperty ; rdfs:label "wasDerivedFrom (PROV-O)" .
+prov:wasRevisionOf a owl:ObjectProperty ; rdfs:subPropertyOf prov:wasDerivedFrom ; rdfs:label "wasRevisionOf (PROV-O)" .
+
+prov:Influence a owl:Class ; rdfs:label "Influence (PROV-O)" ;
+    rdfs:comment "The root of PROV's qualified relations. Spec 414: a harness-capability engagement (apexec:CapabilityEngagement) is one." .
+
+# ═══ The qualified association ═══
+
+prov:qualifiedAssociation a owl:ObjectProperty ; rdfs:label "qualifiedAssociation (PROV-O)" .
+prov:agent a owl:ObjectProperty ; rdfs:label "agent (PROV-O)" .
+prov:hadPlan a owl:ObjectProperty ; rdfs:label "hadPlan (PROV-O)" ;
+    rdfs:comment "The plan an association followed. A plan is never authority (plan.ttl): a run's hadPlan says which playbook version shaped it, and no gate reads it." .
+prov:hadRole a owl:ObjectProperty ; rdfs:label "hadRole (PROV-O)" .