fep

FEP-633c: Guardians

In plain words (non-normative)

Imagine a child on the Fediverse. A stranger says something nasty. The child can’t do much, and the parent feels helpless too: it came from someone far away on the internet, so there is “nothing I can do.”

This proposal fixes that. An account can have guardians attached to it, the way a child has parents. The guardians decide who is allowed to follow the account, and the child can call them in whenever something feels wrong or confusing. Because everyone speaks the same rules, the guardians can then actually reach the person who did it and sort it out, adult to adult, instead of anyone shouting at the child.

Guardians are added carefully (both sides and any existing guardians have to agree), and leaving works too: as a child grows up, the guardians can loosen the rules or step away entirely. The rest of this document writes all of that down precisely, so any Fediverse software can build it the same way.

Summary

This FEP defines a lightweight vocabulary and a set of activities that let one Actor (a ward) be watched over by one or more other Actors (its guardians). Guardians co-approve who may follow or subscribe to the ward, and receive moderation escalations concerning the ward through in-protocol and out-of-band channels.

The goal is a concrete, minimal mechanism that makes the Fediverse a safe, promotable alternative to Big Tech for people who need a recourse structure around them: primarily children, but also any account that a trusted party has agreed to look after. The FEP provides the mechanism; it deliberately does not define policy (age verification, what counts as harmful, jurisdiction). Those remain with implementers.

The vocabulary originates in a guardian-gated Fediverse implementation and is namespaced accordingly (§2); it is intended for adoption by any implementation. The reasoning behind the design decisions in this document is recorded separately, in the namespace document at https://ns.klonkt.com/shaer.

Requirements

The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in RFC2119.

This FEP builds on ActivityPub and ActivityStreams2.

1. Model

There are three, and only three, states an Actor may occupy with respect to guardianship:

  1. Free: the default. No shaer:guardians, no shaer:isGuardian.
  2. Ward: has a non-empty shaer:guardians. Its follows/subscriptions are gated and its moderation escalations are routed to its guardians.
  3. Guardian: has shaer:isGuardian: true. It watches over one or more wards.

The states are mutually exclusive:

The structure is therefore flat and non-recursive: there are wards and there are guardians, and a guardian is never itself a ward. There is no “grand-guardian” (see §4).

2. Vocabulary

All terms are defined in the namespace:

https://ns.klonkt.com/shaer#

with the RECOMMENDED prefix shaer. A JSON-LD context that binds that prefix and carries the type information of the terms below is served at:

https://ns.klonkt.com/shaer

Implementations SHOULD reference that context document in their JSON-LD @context, as the examples in §9 do. Binding the prefix inline instead resolves the term names but carries no type information, and shaer:guardians then expands to string literals rather than to actor references — which defeats the resolvability §2.1 depends on. Consumers that do not understand the terms MUST ignore them (per ActivityStreams2 extensibility) and MUST continue to operate normally.

The same URI serves a human-readable namespace document, which indexes these terms and records the reasoning behind the design decisions in this FEP. That document is non-normative; where it and this FEP disagree, this FEP governs.

2.1 On Actor objects

shaer:guardians is a public property of the actor, resolvable like any other actor property. Publishing it is what lets anyone with a concern reach the responsible adults rather than the ward (§5, §7). A deployment MAY deliver the list as bare references rather than embedded objects; the membership is not confidential.

2.2 On Objects (e.g. Note)

shaer:hasGuardians is a routing hint for observing implementations: it tells a remote server “interactions with this object should be treated as involving a guarded actor, so route reports/approvals to the author’s guardians.” It MUST NOT affect regular delivery, rendering, or storage, and MUST be safely ignorable by non-observing implementations.

Resolved (A). Because shaer:guardians is public on the actor (§2.1), no separate boolean is needed there: the guardian list itself is the ward-signal. shaer:hasGuardians therefore lives only on objects, as a per-object routing marker a remote server can act on without fetching the actor, and as the anchor for the legacy/rectification rules in §3.4.1.

2.3 The gated-setting proposal (§5.6)

These exist because nothing in ActivityStreams2 expresses “a group of named adults jointly decides a setting on someone else’s account”. Where AS2 or another FEP already covers a need, use that instead: this FEP adds vocabulary only where it must.

2.4 Availability and lapse (§3.6)

The same restraint as §2.3 applies: endTime is plain ActivityStreams2, and both markers ride ordinary direct notes exactly as shaer:helpRequest does, so a party on a non-observing server still receives a readable human message.

2.5 On the guardianship Relationship

This is the only term that names the bond itself rather than a property of one of the parties, which is why it appears in the Offer of §3.1 and in every Undo that ends a guardianship (§3.2). The compact form shaer:Guardian and the full IRI https://ns.klonkt.com/shaer#Guardian are the same term: §3 writes it out, §9.3 uses the prefix.

3. Establishing guardianship (the handshake)

Guardianship is created by an explicit, multi-party, two-phase handshake. No single party may create a guardianship alone. This is the core safety property: a lone actor can neither insert itself as guardian over a child, nor (if the ward already has a guardian) can a new guardian be added without the existing guardian’s consent.

Guardianship is modelled as an ActivityStreams2 Relationship:

{
  "type": "Relationship",
  "subject":      "https://ward.example/actor",
  "relationship": "https://ns.klonkt.com/shaer#Guardian",
  "object":       "https://guardian.example/actor"
}

3.1 Steps

  1. Offer. The guardian-candidate, and only the guardian-candidate, sends an Offer whose object is the guardianship Relationship above. Fixing the initiator is deliberate: by offering to guard someone you publicly take on responsibility for that ward and open yourself to criticism of the ward and of your role as guardian. Much can and should be arranged out-of-band before this on-protocol offer is made. The Offer MUST be addressed to the ward, and to all existing guardians of the ward (if any).

  2. Party acceptance. The guardianship is only valid once all of the following have Accepted the Offer:
    • the guardian-candidate (agrees to serve), and
    • the ward (agrees to be guarded), and
    • every existing guardian of the ward, whenever they are reachable. If the ward has existing guardians, at least one existing guardian MUST co-accept; where possible all SHOULD.
  3. Final handle return (commit). As the final step, the guardian-candidate returns a handle: a reference (e.g. an inbox URL or a capability endpoint, see §6) through which this guardian can be reached for escalations. Returning the handle is the atomic commit of the relationship.

    An acceptor MUST NOT assume that, because it accepted, the offer still stands. The relationship is committed only when the handle is returned. An implementation MAY realise the handle return as the guardian-candidate’s own Accept being the last accept in the sequence, carrying the handle in its result.

  4. Write. Only upon receiving the handle does the ward add the guardian to its shaer:guardians, and the guardian set shaer:isGuardian: true (if not already set).

Note (first guardian, free ward). When the ward is still free (has no existing guardians), the Offer itself constitutes the candidate’s consent to serve, and the candidate’s handle (§6) is its own inbox. The relationship then commits on the ward’s single Accept: the first-guardian step is two-party (candidate offers, ward accepts), which preserves the core property that no single party acts alone while sparing a free actor a redundant round-trip. The moment the actor is a ward, the full multi-party handshake applies again: every further guardian requires the co-Accept of at least one existing guardian (§3.1.2), and a candidate that is itself a ward is barred (§1, enforced at commit per §4.2). This is the RECOMMENDED behaviour for a free actor; a deployment MAY instead require a distinct final handle-return from the candidate even for the first guardian.

3.2 Rejection and withdrawal

Resolved (B). The initiator is fixed: the aspirant guardian always makes the Offer (§3.1). Whoever offers to guard thereby exposes themselves to scrutiny over the ward and over the role, which is the intended accountability.

3.3 Removing a single guardian

While more than one guardian remains, a single guardian relationship MAY be ended (§3.2): an Undo of the Relationship from the guardian itself, or from the ward co-signed by an existing guardian, removes that guardian from shaer:guardians. The ward stays a ward as long as at least one guardian remains.

3.4 Emancipation (removing the shaer:guardians key)

Removing the last guardian, and thereby the whole shaer:guardians key so the actor becomes free again, is emancipation. Whether and how a ward may emancipate is ultimately a software/deployment choice, but this FEP gives two RECOMMENDED methods:

Editor’s note (open question E, resolved). The circularity is removed by making the bundled flow a single decision (§3.5) and the witnesses a non-guardian role (Method 2). The ward’s server opens one emancipation decision; naming the two witnesses is part of opening it and does not itself require the guardians’ approval, because a witness is not being added to shaer:guardians. The holdouts therefore cannot deadlock the flow by refusing the witnesses; their consent is needed only for the final removal, where they hold their majority. The witnesses’ Accept activities are answers to that same decision, addressed to the ward’s server, which tallies set and witnesses together.

Note (before the flow starts). Emancipation ends the ward’s ability to call in guardians (§5.2). An implementation SHOULD state this plainly before the flow is opened, and again at completion, including that returning means a fresh handshake (§3.1) and not an undo.

3.4.1 Legacy of prior objects

Emancipation changes the actor going forward; it does not automatically rewrite the past. Objects created while the actor was a ward retain their shaer:hasGuardians marker by default, which keeps historical moderation routing coherent.

Data-protection law (GDPR or the local equivalent) then cuts both ways, and implementations SHOULD support both:

Retention of the legacy marker is the default; both erasure and rectification are the user’s (or their guardians’) to demand.

3.5 How decisions settle: thresholds and windows

Several places in this FEP put a decision in the hands of the guardians: adding a guardian (§3.1), removing one (§3.3), emancipation (§3.4), approving a follow (§5.3) and approving a reply (§5.4). They share one mechanic, defined here once.

A decision has three parts:

Members of the set who are away or dormant (§3.6) at the moment the decision opens form no part of the arithmetic: the threshold is computed over the available set, the snapshot minus those members. Availability is snapshotted together with the set, so stepping away mid-window moves nothing. Without this, a majority of a set that contains absent members can be arithmetically unreachable, and decisions expire not because anyone objected but because nobody was there to count.

The decisions of §3.4 are the exception and run over the full set. Method 3 already prices absence in with time, and a dormant guardian’s pause is exactly the one answer that restores it (§3.6); computing emancipation over a shrunken set would make the gravest decision the cheapest to reach.

How a decision settles depends on whether it can be undone.

Reversible decisions settle early: a race to the threshold. The moment the threshold is met the decision fires, and the remaining guardians need not answer. Symmetrically, the moment enough rejections make the threshold arithmetically unreachable the decision fails at once, so nobody sits out a window whose outcome is already fixed. If the window closes undecided, the decision fails closed (it counts as a rejection) and the requester MAY try again. Follow approval (§5.3) works this way.

Irreversible decisions run the full window. An early threshold does NOT settle them; the clock runs out first, so every guardian in the set has had a genuine chance to speak. Emancipation (§3.4) works this way.

Which category a decision falls into is determined by the cost of a wrong approval: a follow accepted in error is undone with a block, whereas emancipation granted in error removes the recourse structure entirely and leaves the ward no standing to reverse it.

Note (non-normative). Requiring every guardian to answer would hand each of them a silent veto: one unreachable or obstructive guardian could freeze a ward’s social life indefinitely. A threshold with a deadline keeps the decision with the guardians while making non-response a choice with a consequence rather than a blocking move.

3.6 Availability

shaer:guardians is a public claim that these adults are watching. A guardian who no longer answers makes that claim untrue and renders the arithmetic of §3.5 unreachable. This section accounts for absence without treating it as misconduct.

A guardian stands, per ward, in one of three availability states, tracked by the ward’s server:

One rule outranks everything else in this section: one answer restores everything. Any activity from the guardian addressed to the ward or its server returns the guardian to active at once, from either state, at any moment up to and including a running lapse (§3.6.3). Neither state is misconduct, and neither leaves a mark.

3.6.1 Away: declared absence

A guardian declares itself away by sending its ward a direct object carrying shaer:away: true and an endTime. The endTime is REQUIRED: an absence without an end would let a nominal guardian hold a seat indefinitely. It rides an ordinary direct note (§2.4), so a ward on a plain-fediverse server still receives a readable message. When endTime passes, the guardian returns to active silently. Declaring away MUST NOT count as evidence toward dormancy.

Availability MUST NOT appear on the public actor document. An absence schedule is timing intelligence: it tells anyone watching exactly when the effective set is small. The ward and the co-guardians learn it through the owner-only queues (§2.1); the world keeps seeing shaer:guardians unchanged.

3.6.2 Dormant: observed absence

Dormancy is a finding, and the evidence for it is deliberately narrow:

Decisions settled while a guardian was away or dormant remain settled: restoration is never retroactive.

Delivery of a ward’s call for help (§5.2) ignores availability entirely: a shaer:helpRequest goes to all guardians whatever their state. A call for help is not a decision.

When the available set is empty, every reversible decision expires and the ward cannot act at all. That is the entry condition of §3.4 Method 3 (release by lapse of time): a ward whose available set has been empty MUST be able to open it.

3.6.3 Lapse: release in absentia

While a guardian is dormant, an available co-guardian MAY propose releasing it. The proposal mirrors §5.6:

{
  "type": "Offer",
  "actor": "https://gran.example/actor",
  "to": ["https://kid.example/actor", "https://parent.example/actor"],
  "object": {
    "type": "shaer:Lapse",
    "shaer:ward": "https://kid.example/actor",
    "object": "https://uncle.example/actor"
  }
}

Note (non-normative). A lapse can leave a single guardian in sole control, and can be wielded inside a failing relationship. This FEP deliberately does not arbitrate that case, and does not make the ward the tiebreaker between its adults. What the mechanism guarantees is narrower: a removal can be unjust, but it cannot be silent. See §10 (I); the full reasoning is in the namespace document.

4. No recursion (“Not a Teapot”)

A valid guardian is free of guardians (§1). A malformed actor — one carrying both shaer:isGuardian and shaer:guardians — must therefore never be treated as a guardian, and an implementation MUST NOT recurse to such an actor’s own guardians. There is no grand-guardian.

That condition has to be caught at two different moments, and the correct response differs between them: softly when delivering to several guardians (§4.1), and loudly when committing a relationship to one (§4.2).

4.1 At escalation delivery

When an implementation is about to deliver an escalation to a guardian and discovers that this “guardian” itself carries shaer:guardians (i.e. it is misconfigured as both), the implementation MUST NOT recurse to that actor’s guardians.

Instead it MUST fail softly: drop the escalation to that malformed target, continue delivering to the remaining valid guardians, and SHOULD log the condition. Implementations MAY signal this with an out-of-band error; this FEP’s convention is a 418-flavoured “Not a Teapot” marker. A malformed target MUST NOT block delivery to the well-formed guardians.

4.2 At guardianship commit

§1 bars a ward from becoming a guardian. This section fixes when that bar is enforced, because §4.1 alone runs only once the relationship exists.

When an implementation is about to commit a guardianship (§3.1, step 3) and finds that the guardian-candidate carries shaer:guardians, it MUST refuse the commit and void the handshake. The guardianship MUST NOT be recorded, and the ward’s shaer:guardians MUST NOT be written (§3.1, step 4).

The verification MUST be performed against a freshly dereferenced actor document at commit time. An actor’s guardianship state MAY change between the Offer (§3.1, step 1) and the commit, so a check performed only on receipt of the Offer is NOT sufficient.

Where the actor document cannot be dereferenced, the implementation MUST NOT treat the failure as either outcome. It MUST NOT commit, because the candidate is then unverified. It MUST NOT void the handshake either: an unreachable server is not a malformed actor, and treating one as the other lets a transient failure destroy a multi-party agreement that can only be remade by repeating §3.1 in full.

The commit is therefore deferred, not decided. An implementation SHOULD retry the dereference on its own schedule rather than wait for a further activity from a party: the last Accept may already have arrived, in which case nothing further will trigger a retry and the handshake would stall until its window closed.

Adding a guardian is a §3.5 decision, so the hold is already bounded: if the window closes with the check still unresolved, the decision fails closed. Where that happens, the parties MUST be told that the handshake failed because the candidate could not be verified, and MUST NOT be told that it was refused. Those are different facts, and only one of them is about the candidate.

Unlike §4.1, this failure MUST NOT be silent toward the ward. The ward and its existing guardians MUST be informed, with the reason: they are parties to the handshake, the condition is derived from public data (§2.1), and a silent void would leave a ward believing an adoption completed that did not. This is the half of the refusal that is not a disclosure question.

Toward the candidate, the refusal SHOULD be expressed as a Reject of the Offer (§3.2), which voids the handshake by the mechanism §3 already defines and which an implementation unaware of §4 still handles correctly.

Whether that Reject states the reason is a deployment decision, and the trade-off is real in both directions:

Implementations SHOULD therefore perform the same check when the Offer is received and refuse it there when the condition already holds. At that point no party has accepted, so nothing about anyone’s consent can be inferred and the reason MAY be given freely. Refusing early is both the kinder path for a misconfigured candidate and the one that leaks nothing; the commit-time check remains REQUIRED as the backstop for a candidate whose state changed in between.

Note (non-normative). §4.1 remains REQUIRED alongside §4.2: the two cover disjoint cases. §4.2 prevents a malformed guardianship being created; §4.1 contains one that became malformed afterwards, which no handshake-time check can detect.

5. Feedback and moderation

Guardianship exists to provide recourse: a ward must never be left without a route to act, and an adult with a complaint must have somewhere to take it other than the child.

5.1 Adult ↔ adult (unchanged)

Between free actors, nothing changes. Adults address adults as adults: flag a missing content warning, open a private conversation, use ordinary reporting. This FEP does not touch that path.

5.2 A ward can call in its guardians

This FEP does not ask implementations to scan for “hostile content.” The mechanism is ward-driven: implementations SHOULD give a ward a simple way to call in its own guardians about any interaction it receives that it does not understand, finds unpleasant, or is simply unsure about. The ward is never left holding the problem alone.

When a ward invokes its guardians, software:

The mechanism provides contact, not surveillance: it gives the guardian a defined route to reach and speak with the party concerned, so the exchange takes place between adults rather than being directed at the ward.

5.2.1 The escalation note (shaer:helpRequest)

The in-protocol form of a call for help is a Note carrying shaer:helpRequest: true. Its shape follows the deployed private-mention (direct) model, so that a guardian on ANY ActivityPub server receives it as an ordinary readable direct message; the marker only adds meaning for guardian-side implementations.

5.2.2 Attending to a call for help (shaer:helpPickup, shaer:helpHandled)

A call for help reaches every guardian at once (§5.2.1), so the guardians need a way to tell each other and the ward that one of them has it. Two markers carry that, over the same delivery as the request itself.

A marker is an ordinary direct Note naming the request it concerns twice: as inReplyTo, which is plain ActivityStreams2 and needs no knowledge of this FEP, and as the value of shaer:helpPickup or shaer:helpHandled.

{
  "type": "Note",
  "attributedTo": "https://gran.example/actor",
  "to": ["https://kid.example/actor", "https://parent.example/actor"],
  "inReplyTo": "https://kids.example/notes/help-1",
  "shaer:helpPickup": "https://kids.example/notes/help-1",
  "content": "I am looking at this."
}

Three rules govern how markers are read. None of them follows from the shape, and each exists because the failure it prevents is silent.

  1. A pickup does not expire, and is not exclusive. Pickups accumulate. An implementation MUST NOT treat a later pickup as replacing an earlier one, and MUST NOT expire one by the passage of time. Two guardians answering the same request is harmless; two guardians each doing nothing because each believed the other had claimed it is not. A claim that quietly lapses is worse still, because it leaves a request that is being worked on looking untouched.

  2. Handled is terminal. There is no undo and no reopen, and an implementation MUST NOT offer either. If the concern is still live it is raised as a new request (§5.2.1): the record is added to, never rewritten. The state of a request is therefore just which markers exist, rather than a machine that can be driven backwards.

  3. When in doubt, open. Anything that is not an explicit shaer:helpHandled marker MUST be read as a request still waiting — an empty list, a row that cannot be parsed, a marker of a kind the implementation does not recognise. Note that this inverts the safe failure used elsewhere in this FEP: a gate that cannot decide denies (§3.5), but here the dangerous outcome is not an unanswered request, it is one that everybody believes has been answered.

Suggestion (non-normative). A guardian that has left a ward (§3.3) may still hold that ward’s earlier requests in view. For that guardian they are neither open nor handled, and an implementation MAY show them as a third state — no longer yours — rather than forcing them into either. That state SHOULD stay local and MUST NOT be federated as shaer:helpHandled: marking a request handled is a claim about a child one no longer guards, and it would tell the remaining guardians that something was dealt with by someone who is no longer there. Keeping it local is safe because guardianship never ends at the last guardian (§3.4), so the request is still open for someone who can act on it.

5.3 Follows and subscriptions are gated

This aligns with manuallyApprovesFollowers: true: the difference is that the approval decision is delivered to the guardian, not the ward.

Note (implementation). Watching over a ward is realised as an ordinary Follow: a guardian follows its ward, and the ward’s posts (including followers-only) are then delivered to the guardian by the normal mechanism, cross-server and honouring visibility. No new fetch is required for the common case. An OPTIONAL refinement is an actor-authenticated (signed) GET of the ward’s outbox by a guardian, which a ward’s server MAY grant by checking the fetcher against the public shaer:guardians list; this lets a guardian read without appearing in the followers collection and lets it backfill history from before the follow. This FEP does not require the signed-fetch path.

Note (forwarding, modelled on §3). When a ward’s guardians are on other servers, the ward’s server forwards the gated Follow to each guardian as an Offer whose object is that Follow (the same distributed shape as the adoption offer in §3, so each guardian keeps its own copy). A guardian answers with Accept/Reject addressed back to the ward’s server, which tallies the quorum and, on approval, returns the standard Accept(Follow) to the original follower. Co-located guardians need no forwarding: they read and decide on the ward’s own server. This keeps follow-approval and adoption on one mechanism.

5.4 Replies are gated

Guardianship gates follows (§5.3); replies are gated with the reply-control mechanism already deployed in the Mastodon namespace http://joinmastodon.org/ns#: canReply on an object (who may reply), the ApproveReply and RejectReply activities (the authority’s decision), and an approval property on the reply pointing to the ApproveReply. This FEP builds on that deployed behaviour rather than reinventing it.

Note on provenance: these terms were originally specified in FEP-5624 (per-object reply control), which was WITHDRAWN on 2025-06-24. The terms themselves remain in production use, so this FEP relies on the deployed mechanism, not on the withdrawn proposal, and treats 5624 as an informative predecessor. The live successor discussion on who owns a thread and who may join it has moved to the context and replies-collection proposals (FEP-171b conversation containers, FEP-7458 replies collection, FEP-11dd context ownership); a future revision of this FEP SHOULD track whichever of those reaches FINAL and re-express reply-gating in its terms.

5.5 Discoverability is off by default (via FEP-5feb)

A ward SHOULD set indexable: false (FEP-5feb), and a deployment MAY treat this as a default that only the ward’s guardians can relax. This is stronger than FEP-5feb’s own (contested) default, and reflects the stance that you reach people by connecting, not by search.

Note the deliberate asymmetry with §7: a ward’s guardians are public (the village model), so a concerned adult can find the responsible adults, while the ward’s content is not indexable, so strangers cannot discover the child in the first place. Reachability for recourse and discoverability to strangers are separated on purpose.

Deployments MAY additionally honour FEP-5e53 (opt-out preference signals) on ward content for broader scraping and AI opt-out; this is OPTIONAL.

5.6 Gated settings: the guardians decide, across servers

§5.3–5.5 each name something a ward’s guardians control. A deployment will grow more of these (external links and link previews, direct messages, who may reply, how loud “public” is). They share one shape, and it MUST work when the guardians are not on the ward’s server, because that is the ordinary case: a child on the family instance, a grandparent on theirs.

A gated setting is a decision in the sense of §3.5: a snapshotted set, a threshold, a window. It is reversible (a permission granted can be withdrawn), so it settles as a race to the threshold and fails closed at the deadline.

Enforcement belongs on the ward’s server and MUST NOT be left to the client: a feature that a client merely hides has still been delivered to the device. Where a setting suppresses content, the content is left out of the response.

Note (non-normative). A single guardian flipping a switch on another server is indistinguishable from a compromised or estranged guardian doing so. The threshold is what makes the change attributable to the guardians as a group rather than to whoever acted first, and the window is what prevents one silent guardian from blocking it indefinitely.

6. The handle and cross-server trust

The handle returned at commit (§3.1 step 3) is how a ward’s server reaches a guardian for the lifetime of the relationship. At minimum it is the guardian’s inbox. Implementations MAY make it a scoped capability (an unguessable, revocable endpoint) so that possession of the handle authorises escalation delivery without exposing the guardian’s main inbox.

Escalation deliveries and handshake activities MUST be authenticated as ordinary authenticated ActivityPub server-to-server traffic: HTTP Signatures at minimum, and SHOULD prefer object integrity proofs (FEP-8b32, built on the actor public keys of FEP-521a) for the security-sensitive §3 (handshake) and §5 (escalation) activities. A guardian relationship is security-sensitive: a forged Accept or Undo could detach a child from protection, so implementations SHOULD require the strongest authentication they support for those activities.

7. Privacy considerations

8. Scope (what this FEP does NOT do)

9. Examples

9.1 A ward actor

{
  "@context": ["https://www.w3.org/ns/activitystreams",
               "https://ns.klonkt.com/shaer"],
  "type": "Person",
  "id": "https://kids.example/users/robin",
  "manuallyApprovesFollowers": true,
  "shaer:guardians": ["https://kids.example/users/parent"]
}

9.2 A guardian actor

{
  "@context": ["https://www.w3.org/ns/activitystreams",
               "https://ns.klonkt.com/shaer"],
  "type": "Person",
  "id": "https://kids.example/users/parent",
  "shaer:isGuardian": true
}

9.3 Offering guardianship

{
  "@context": ["https://www.w3.org/ns/activitystreams",
               "https://ns.klonkt.com/shaer"],
  "type": "Offer",
  "actor": "https://kids.example/users/parent",
  "to": ["https://kids.example/users/robin"],
  "object": {
    "type": "Relationship",
    "subject": "https://kids.example/users/robin",
    "relationship": "shaer:Guardian",
    "object": "https://kids.example/users/parent"
  }
}

9.4 A note that hints at guarded authorship

{
  "@context": ["https://www.w3.org/ns/activitystreams",
               "https://ns.klonkt.com/shaer"],
  "type": "Note",
  "attributedTo": "https://kids.example/users/robin",
  "content": "hi fediverse!",
  "shaer:hasGuardians": true
}

10. Open questions (need author decisions before FINAL)

Acknowledgements

The guardianship model in this document, including the emancipation design in §3.4 (the two-witness deadlock-breaker and the legacy/erasure treatment of prior objects), originates with Bart Overkamp and was developed through ‘discussion’ on SocialHub and in other places On- and Off-line. This draft renders that design into FEP form.

The prose of this document is largely written by Claude (Fable and Opus 5/4.8), working from the forum post and from FEP-67ff, which this repository was queried for. The initial draft was produced after discussion; the FEP repository was then cloned and a synced copy set up, and the document has been revised in the same way since.

The division of labour is worth stating plainly. Close to all of the text is model-written. None of the design is: the guardianship model, the emancipation flow, the decision mechanic, and the deliberate refusals to decide (§10) come from the authors and from operating a guarded instance. So does every correction of substance — the placement of the §4 check, the disclosure that a commit-time refusal carries, and the undefined behaviour of a failed dereference were all caught by the authors, several of them by implementing the text and finding it wanting.

The decision model of §3.5 came out of the same discussion: a threshold reached within a window rather than a poll everyone must answer, and the distinction between reversible decisions that settle early and irreversible ones that always run their full window. Bart Overkamp put it as “a race to the threshold rather than a vote”.

References

To the extent possible under law, the authors of this Fediverse Enhancement Proposal have waived all copyright and related or neighboring rights to this work.