@agenticprimitives/ontology 1.0.0-alpha.37 → 1.0.0-alpha.39

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/versions.adoption.json

@@ -150,6 +150,24 @@
       "steward": "richardpedersen3@gmail.com",
       "publishedAt": "2026-10-15",
       "note": "spec 305 W2 / zkID alignment §4 (Z3): `apest:projectionSet` gains `live-credential` — a credential issuer's live set, anchored as the issuer's own row on EstateProjectionRegistry (first root slot, charterHash = the issuer tag). Comment-only T-box change; no class or property added or removed."
+    },
+    {
+      "manifestDigest": "0xdf7e54bdb37e5e0a299abb001c4e9ec41430f875c37f41f6cfde69353951f9fb",
+      "steward": "richardpedersen3@gmail.com",
+      "publishedAt": "2026-10-15",
+      "note": "Anonymous credentials — tbox/privacy-credential.ttl (appc:, 0.1.0), specs 304 / 305 / 442 §7.2 / 443 W5 and the zkID alignment waves Z1–Z4 as live at ap-federation's door. New classes: IssuerKeyFacet (anchoredBy an attestation; subject an org or service, never a person) · IssuerRow (the issuer's tagged live-credential root on neutral ground; its leaves are apest:ProjectionSubmission in the live-credential set; revocation = retire + re-anchor) · AnonymousCredential (⊑ apvc:VerifiableCredential; issuedUnder a facet, boundToDeviceKey) · DeviceKey (custodied; signs only under a mandate) · PairwiseAccount (what a verifier sees; NO property to the person, on purpose) · ProofRequest / PredicateProgram / Predicate (the verifier's own question, digested) · PrivatePresentation (answers · presentedUnder · provesPredicate · carriesNullifier · carriesStatus · madeUnderMandate · presents — the last three the holder's record only) · Nullifier (graded: asserted < in-circuit) · CredentialStatusPresentation (statusOf an IssuerRow at a sequence the verifier READ) · PresentationMandate (⊑ apdel:Delegation; audiences · predicate digests · facets · maxPresentations) · PresentationRelease (⊑ prov:Activity; one judgement per device-key signature) · VerifierPolicy (what a door asks and accepts, incl. nullifierWindowSeconds and verifierPlacement) · PredicateAdmissionEvidence (the predicate held, beside an apix:AdmissionReceipt; evidence, never authority). Codelists: presentationSuite, issuerKeySuite, nullifierGrade, predicateOp, verifierPlacement, proofGrade (identity · standing · predicate). Doctrine: proof is evidence, the mandate is authority, the receipt binds the two; no claim value and no link to the person anywhere in the vocabulary."
+    },
+    {
+      "manifestDigest": "0xf5494ddf4f9001f02919cc56d6ab6dd71d4e5a1b5b7efcaa68031f5d21680881",
+      "steward": "richardpedersen3@gmail.com",
+      "publishedAt": "2026-10-15",
+      "note": "apvc: reconciled — five T-box modules (agreement, attestation, fulfillment, payment, privacy-credential) and mappings/spine-standards.ttl bound the prefix to /ns/credential# (apcr's namespace, the CONTROL credentials) while NS.apvc, context.jsonld and the collaboration crosswalk said /ns/verifiable-credential#; and no module declared apvc:VerifiableCredential at all. Now one IRI (verifiable-credential#) everywhere and the class declared once in attestation.ttl (⊑ prov:Entity; owl:equivalentClass w3cvc:VerifiableCredential in the mapping). Every subClassOf apvc:VerifiableCredential axiom in the spine now points at a declared class. No term renamed; the prefix moved."
+    },
+    {
+      "manifestDigest": "0xf1f4359aba735b1cae1ac5f4439d4bd71460a9b5b6a89aed40481e80346f5730",
+      "steward": "richardpedersen3@gmail.com",
+      "publishedAt": "2026-10-15",
+      "note": "spec 442 §11 W0 — tbox/identity.ttl gains the four terms for a person's agent at a company's door (ap:, the core namespace; prov: prefix added): ClientKeyBinding (a Smart Agent's signed statement that one JWK may PRESENT for it at external doors under one custody epoch — a credential, not a delegation; atl:clientKeys on chain) · PairwiseSubject (what one company calls the person: HKDF over a vault secret salted by the issuer; no property to the person, as appc:PairwiseAccount) · ExternalOperation (PAP operation / ACP session / UCP checkout seen from our side — an INTENT whose digest a mandate binds; never an approval) · ExternalAccountLink (the account at one company and the credentials it left behind; a vault record the Security section lists and revokes). Properties: clientId, jwkThumbprint, jwsAlgorithm, boundUnderCustodyEpoch, bindingNotBefore/After, pairwiseIssuer, pairwiseSubjectDigest, operationAuthority, operationId, operationRevision, termsDigest, accountGrantedAt/ExpiresAt/LastUsedAt, grantedScope. Bound in vault-records.ts: identity.client-key-binding: · identity.pairwise-secret · identity.external-account-link:. Doctrine: approval is a signature, never an assertion; the person is never the client_id; protocol vocabulary (poppy.json, DPoP, Idempotency-Key) stays in ap-federation (spec 443). Nothing here is read by any verifier."
     }
   ]
 }