vibefed

Background knowledge about Mastodon, the dominant federated microblogging platform and de facto reference implementation for ActivityPub social networking. Covers Mastodon's JSON-LD @context structure (three-element array: activitystreams, security/v1, inline object defining toot: http://joinmastodon.org/ns# with Emoji/discoverable/featured/featuredTags/ blurhash/votersCount/indexable/memorial/suspended/attributionDomains, schema: http://schema.org# with PropertyValue/value, as: with Hashtag/manuallyApprovesFollowers/movedTo/sensitive), content-type and Accept header requirements (application/activity+json or application/ ld+json with ActivityStreams profile, content negotiation for actor discovery), HTTP signature requirements (RSA-SHA256, Digest header mandatory for POST, signed headers include request-target/host/date/ digest), authorized fetch / secure mode (AUTHORIZED_FETCH env var, requires signatures on GET requests too, breaks unsigned federation), supported object types (Note and Question first-class

Background knowledge about WriteFreely, the open-source federated blogging platform written in Go (AGPL-3.0) by Matt Baer / Musing Studio. Covers the origin story (Write.as anonymous writing platform launched 2014, open-sourced as WriteFreely November 2018 after adding ActivityPub), the write-only/broadcast federation model (blogs can be followed but cannot follow others, no incoming comments/replies displayed, no moderation), the actor model (each blog/collection is a Person actor with handle @blog@instance.com), the Article vs Note object type distinction (double-line break heuristic, notes_only config option), supported activities (outbound Create/Update/Delete, inbound Follow/Undo/Like), RSA-SHA256 HTTP signatures with per-blog keypairs, the tech stack (Go/MySQL or SQLite/single binary deployment/256 MB RAM/Raspberry Pi), configuration (single-user vs multi-user modes, federation toggle, .ini config file), NodeInfo with WriteFreely-specific metadata, the RESTful API (Posts/Collections/Users with token aut

Background knowledge about Mbin, the federated content aggregator and microblogging platform (active community fork of Kbin). Covers the hybrid dual content model (threads as Page + microblogs as Note in one platform), magazines as Group actors with Announce relay, the three actor types (Application instance actor at /i/actor, Person user at /u/username, Group magazine at /m/name), the full activity reference (Create, Update, Delete, Like, Dislike, Announce, Follow, Accept, Block, Flag, Lock, Add, Remove), the voting system (Like for upvotes, Dislike for downvotes with historical federation issues, Announce for boosts — boosts and votes are separate unlike Lemmy), the hybrid thread+microblog model and why it enables superior Mastodon integration, the tech stack (PHP 8.3+/Symfony 7.4/ PostgreSQL/RabbitMQ/Redis, AGPL-3.0), the async message processing architecture (Symfony Messenger with 15 inbox + 15 outbox message types), the REST API with OAuth2 and Swagger docs, the Mbin fork history (forked from Kbin Octob

Background knowledge about NodeBB, the modern open-source forum software built on Node.js with native ActivityPub federation (core feature since v4.0.0, January 2025). Covers the three actor types (Person user at /u/username, Group category at /category/<cid> implementing FEP-1b12 Group Federation with Announce relay pattern, Application instance actor), the two-level content hierarchy (category as audience → topic as context → post), how topics map to resolvable OrderedCollection contexts per FEP-7888 and posts are Note/Article objects, extensive FEP support (12 implemented: FEP-1b12 Group Federation, FEP-7888 context property, FEP-f228 Backfilling Conversations, FEP-4f05 Soft Deletion, FEP-9098 Custom emojis, FEP-b2b8 Long-form Text, FEP-fe34 Origin-based security, FEP-ae0c Relay Protocols, FEP-11dd Context Ownership, FEP-f15d Context Relocation, FEP-fb2a Actor metadata, FEP-0151 NodeInfo), the tech stack (Node.js/WebSocket/Socket.IO/ MongoDB or Redis or PostgreSQL, GPL-3.0), content discovery (follow- base

Background knowledge about Kbin and its active community fork Mbin, the decentralized content aggregator and microblogging platform for the Fediverse (Reddit + Mastodon hybrid). Covers the dual content model (threads/link aggregation via Page objects + microblogging via Note objects in a single platform), magazines as Group actors with Announce relay (same pattern as Lemmy communities), the three actor types (Application instance actor at /i/actor, Person user at /u/username, Group magazine at /m/name), supported activities (Follow, Like, Announce, Create, Update, Delete, Block, Flag, Lock, Add, Remove), the critical detail that downvotes do NOT federate, content object mapping (threads as Page, microblogs as Note, comments as Note with inReplyTo, private messages as ChatMessage), the tech stack (PHP 8.2+/Symfony/PostgreSQL/RabbitMQ/Redis, AGPL-3.0), the REST API with OAuth2 and Swagger docs at /api/docs, the Mbin fork history (Kbin discontinued after creator Ernest Wisniewski's absences, Mbin forked October

Background knowledge about PieFed, the federated link aggregation and discussion platform (Python-based Reddit/Lemmy alternative in the Threadiverse). Covers PieFed's tech stack (Python/Flask, PostgreSQL, Celery/Redis, htmx, Jinja2, AGPL-3.0), the Lemmy-compatible ActivityPub implementation (Community as Group, Post as Page, Comment as Note, Like/Dislike voting, Announce relay pattern, ChatMessage for DMs), the unique Feed actor type (FEP-1d80 for federated multi- community collections), private/anonymous voting via proxy user profiles, additional activity types (EmojiReact, PollVote, ChooseAnswer for Q&A mode, Event objects with startTime/endTime), the 95%-Lemmy-compatible REST API (/api/alpha/ with Swagger docs, enabling Voyager/Interstellar/Blorp/Summit mobile apps), custom JSON-LD extensions (genAI, nsfl, flair, postingWarning, interactionPolicy, lemmy:tagsForPosts compatibility), the federation architecture (Celery async processing, Redis dedup with 90s TTL, RSA-SHA256 HTTP signatures, LD signature fallb

Background knowledge about Misskey, the Japanese-origin federated microblogging platform (created 2014 by syuilo). Covers Misskey's ActivityPub extensions (custom namespace https://misskey-hub.net/ns# with _misskey_content, _misskey_quote, _misskey_reaction for emoji reactions on Like activities, _misskey_votes, _misskey_talk for chat, isCat boolean, _misskey_followedMessage, _misskey_requireSigninToViewContents, _misskey_makeNotesFollowersOnlyBefore, _misskey_makeNotesHiddenBefore, _misskey_license), MFM (Misskey Flavored Markdown) proprietary markup with animations/colors/effects, emoji reactions as primary engagement mechanism (Unicode + custom emoji, federated via Like with _misskey_reaction), the Drive file management system, Antennas (custom filtered feeds), Deck UI, Channels, Pages, Clips, Plugins, Themes, Widgets, isCat mode, the tech stack (Node.js/TypeScript/NestJS/PostgreSQL/Redis/Vue.js 3/Vite, AGPL-3.0), REST API (POST-based) and WebSocket streaming API, Note visibility levels (public/home/follow

Background knowledge about Loops, the federated short-form video sharing platform (TikTok/Vine alternative for the Fediverse). Covers the key federation design decision of using Note objects with video attachments instead of Video objects for maximum cross-platform compatibility, the instance actor and shared inbox implementation, HTTP Signatures with SHA-256 digests, WebFinger discovery, the graph-walking comment validator (rejects top-level Notes, creates Comment and CommentReply objects), cross-platform interactions (follow, comment, like, Announce across Mastodon/Pixelfed/PeerTube), the tech stack (Laravel/PHP, Vue 3, Tailwind, Expo/React Native mobile), features (vertical swipe feed, For You algorithm, duets, 3-minute videos, playlists, threaded comments), the relationship to Pixelfed and creator Daniel Supernault, federation beta status, and comparison with PeerTube (Note vs Video object types, short-form vs long-form). Load when the user asks about Loops; how short-form video federates in the Fediverse

Background knowledge about Friendica, the federated social networking platform (Facebook alternative). Covers Friendica's history and lineage (Mistpark 2010, Friendika, Friendica, the Red Matrix/Hubzilla fork), its multi-protocol architecture (ActivityPub, DFRN, Diaspora protocol simultaneously), the DFRN protocol (Distributed Friends and Relations Network — Atom/ActivityStreams XML with public-key crypto handshake, dfrn_notify/dfrn_poll/dfrn_request endpoints), the ActivityPub implementation (Receiver/Processor/Transmitter classes, APDelivery workers, Mastodon-compatible API), the Diaspora protocol integration (reverse-engineered PHP implementation), the addon/plugin system (hook-based with 100+ hooks, Smarty3 templates, module intercept), cross-network connectors (Bluesky bidirectional, Tumblr, GNU Social, email IMAP/SMTP, RSS/Atom, WordPress/LiveJournal/Dreamwidth post-only), privacy controls (ACLs, Circles/Groups, multiple profiles, per-post permissions), content model (200,000-char posts, BBCode, photo a

Background knowledge about Lemmy, the federated link aggregation and discussion platform (Reddit alternative). Covers Lemmy's fundamental architectural decision of Communities as Group actors that automatically Announce all content to followers, the ActivityPub object type mappings (Post as Page with mandatory title, Comment as Note with inReplyTo tree, Community as Group, User as Person, Instance as Application, Private Message as ChatMessage), voting via Like/Dislike activities (unique first-class downvotes unlike most Fediverse platforms), ranking algorithms (Active, Hot, Scaled, Top), the full activity reference (Create/Update/Delete for posts and comments, Follow/Accept for community subscription, Remove/Block/Lock for moderation, Flag for reporting, Announce for community relay), federation modes (allowlist, blocklist, open), custom namespace extensions (stickied, distinguished, commentsEnabled, postingRestrictedToMods), the Lemmy JSON-LD context (join-lemmy.org/context.json), the REST API v3 with JWT a

Background knowledge about FEP-82f6 Actor statuses, an ActivityPub extension for short, non-interactable profile status text. Covers the ActorStatus type (content, endTime expiration, attachment for rich metadata like now-playing), actor fields (status for current inlined status, statusHistory collection), activities (Create to set, Remove to clear from profile but keep in history, Delete to remove entirely), the sm: JSON-LD namespace from Smithereen, the 100-character minimum support requirement, the design philosophy of one FEP = one UX pattern with clean compatibility breaks, the Remove vs Delete distinction, why Update is forbidden, why the featured collection is not reused, and the inspiration from early Facebook "is..." statuses, VKontakte taglines, Discord custom statuses, and GitHub profile statuses. Load when the user asks about actor statuses; profile status text; FEP-82f6; how to add a custom status to an ActivityPub actor; short non-interactable profile messages; status expiration; status history;

Background knowledge about PeerTube, the decentralized video streaming platform. Load when the user asks about implementing a PeerTube- compatible ActivityPub server, federating with PeerTube instances, PeerTube's two-tier actor model (Person actors own Group channel actors, Application instance actor), PeerTube's attributedTo requirement (videos must reference a Group actor which references an owning Person actor), PeerTube's supported ActivityPub activities (Accept, Announce, ApproveReply via FEP-5624, Create, Delete, Dislike, Flag, Follow, Like, Reject, Undo, Update, View), PeerTube's object types (Video with live streaming and comment policy extensions, Note for comments, CacheFile for video redundancy/mirroring, Playlist, PlaylistElement, WatchAction), PeerTube's JSON-LD context namespaces (joinpeertube.org/ns#, schema.org, join-lemmy.org/ns#), PeerTube's Video object extensions (isLiveBroadcast, liveSaveReplay, permanentLive, latencyMode, commentsPolicy, canReply, downloadEnabled, sensitive, waitTransco

Background knowledge about FEP-67ff FEDERATION.md, the convention for documenting federation behavior in Fediverse projects. Covers the specification requirements (valid Markdown, repository root location), suggested template sections (protocols, FEPs, ActivityPub details), machine-readable discovery via NodeInfo 2.1 software.repository, the companion FEP-c893 (DOAP JSON-LD for automated capability discovery), the origin story (Darius Kazemi's 2020 proposal, WriteFreely as first adopter), the interoperability documentation gap FEDERATION.md solves, real-world examples from Mastodon and WordPress, and the 40+ implementations that have adopted it. Load when the user asks about FEDERATION.md; how to document federation behavior; FEP-67ff; what protocols or FEPs a project supports; how to create interoperability documentation for a Fediverse project; how other projects document their ActivityPub implementation; or machine-readable federation capability discovery with DOAP.

Background knowledge about capability and extension discovery via NodeInfo in the Fediverse. Covers FEP-6481 (WITHDRAWN — specifying ActivityPub extension support with NodeInfo metadata.activitypub.extensions IRI arrays), its successor FEP-9fde (reverse-FQDN operations map with semver versioning), and the broader capability discovery landscape including FEP-eb22 (supported ActivityStreams types), FEP-844e (capability URIs on application actors), and FEP-67ff (FEDERATION.md). Also covers the NodeInfo protocol itself (versions 1.0-2.1, the /.well-known/nodeinfo JRD endpoint, the metadata free-form section), nightpool's argument against custom types in favor of extending standard vocabulary, the XMPP Entity Capabilities precedent (XEP-0115), and real-world motivations from Manyfold (f3di 3D model extensions), BookWyrm (Review type), and Lemmy (voting vs Like). Load when the user asks about how to advertise supported ActivityPub extensions; NodeInfo metadata for capability discovery; FEP-6481; FEP-9fde; how serve

Background knowledge about the OpenWebAuth (OWA) federated remote authentication protocol, based on FEP-61cf (DRAFT status). Covers the 5-step authentication handshake between home instance, target instance, and user browser; WebFinger discovery of redirect and token endpoints (rel="http://purl.org/openwebauth/v1" and v1#redirect); HTTP Signature signed token requests; RSA PKCS#1 v1.5 encrypted single-use tokens; the owt query parameter; the zid login trigger; the /magic fallback endpoint; authentication vs authorization distinction; security considerations (open redirects, CSRF, information leakage, token expiry); the history from Magic Auth in Mistpark (2010) through Zot and Hubzilla to standalone OpenWebAuth (2017); comparison with OAuth 2.0 and OIDC (FEP-d8c2); use cases for private content access, cross-server permissions, and wall-to-wall posting; and implementations across Hubzilla, Streams, Forte, Friendica, and FedIAM. Load when the user asks about federated single sign-on in the Fediverse; OpenWebAu

Background knowledge about Activity Intents on the Fediverse, based on FEP-3b86 (DRAFT status). Covers how servers publish machine-readable URL templates via WebFinger for cross-server social interactions (Follow, Like, Announce, Create, etc.), the rel namespace convention (https://w3id.org/fep/3b86/*), RFC 6570 URI Templates with parameter placeholders, the 28 standard activity intents plus the Object intent, the special Create intent for pre-populating new content, workflow callbacks (on-success, on-cancel), the remote server interaction flow, the fallback chain (Activity Intents → oStatus subscribe → hard-coded URLs), security considerations (CSRF, open redirects, interstitial pages), the history from oStatus remote follow through Mastodon's authorize_interaction endpoint, the Twitter Web Intents inspiration, comparison with Fedilinks (FEP-07d7), and implementations across Emissary, Forte, Loops, PieFed, streams, and WordPress. Load when the user asks about implementing remote interaction buttons; cross-se

Background knowledge about reverse WebFinger discovery — finding a WebFinger address from an ActivityPub actor — based on FEP-2c59 (DRAFT status). Covers the `webfinger` property on actors, the forward vs reverse discovery problem, why `preferredUsername` is insufficient for reverse lookups, domain mismatch use cases, validation requirements (no-redirect string comparison), security considerations, JSON-LD context registration, the community debate around alternative approaches (`alsoKnownAs`, `aliases`, property naming), Mastodon's current reverse discovery algorithm and its limitations, and the W3C SWICG acknowledgment of the problem. Load when the user asks about reverse WebFinger discovery; how to get a WebFinger address from an actor URL; the `webfinger` property on ActivityPub actors; why `preferredUsername` is not enough for constructing WebFinger handles; domain mismatch between actor URL and WebFinger address; FEP-2c59; or how Mastodon resolves actor URLs back to `user@domain` handles.

Background knowledge about how group/forum federation works on the Fediverse using FEP-1b12 (FINAL status). Covers the Group actor type, the audience property for group identification, the Announce wrapping mechanism for content distribution, thread/comment structure (Page for top-level posts, Note for replies, inReplyTo chains), group moderation via attributedTo collection with Add/Remove activities, the Announce(Activity) vs Announce(Object) interop issue, the competing FEP-400e approach (Smithereen/Mastodon wall collections), and implementations across Lemmy, Friendica, Hubzilla, Lotide, PeerTube, Kbin, NodeBB, and Guppe. Load when the user asks about implementing groups or forums in ActivityPub; how Group actors work; how to use the audience property; how Announce wrapping distributes group content; how group moderation works; the difference between FEP-1b12 and FEP-400e; how Lemmy communities federate; how to build a forum with ActivityPub; or what FEP-1b12 specifies.

Background knowledge about FEP-ef61 Portable Objects and server-independent identity in ActivityPub, including the ap:// URI scheme with DIDs as authority, the did:key and did:ap:key DID methods, the gateway and resolver mechanism (/.well-known/apgateway), the gateways property on portable actors, integrity proofs (FEP-8b32 / eddsa-jcs-2022), origin-based authentication (FEP-fe34), identity proofs (FEP-c390), media integrity via digestMultibase, backward compatibility with HTTP(S) URLs, the aliases vs alsoKnownAs property debate, and the relationship to nomadic identity (Zot/Nomad/Hubzilla/Streams). Also covers the decentralized identity stack (FEP-521a, FEP-8b32, FEP-c390, FEP-ef61) and implementations in Streams, Mitra, Forte, and tootik. Load when the user asks about portable objects, portable identity, nomadic identity, server-independent identifiers, ap:// URIs, DIDs in ActivityPub, account migration beyond Move, data portability, what happens when a server shuts down, FEP-ef61, or how to make ActivityPu

Background knowledge about how long-form text works on the Fediverse and in ActivityPub, based on FEP-b2b8. Covers the Article type and when to use it instead of Note, the full set of Article properties (name, summary, content, preview, url, image, attributedTo, sensitive, etc.), the allowed HTML subset for content, the preview mechanism for microblogging client fallback, summary generation guidance (~500 chars), the sensitive flag with dcterms:subject display hierarchy, RSS 2.0 property parallels, and implementation differences across Mastodon, WordPress, Ghost, WriteFreely, NodeBB, Bonfire, and Threads. Load when the user asks about implementing long-form text, blog posts, or articles in ActivityPub; how Article differs from Note; how to structure an Article object; how to make articles display correctly on Mastodon; what the preview property is for; how to generate summaries; or what FEP-b2b8 specifies.

Background knowledge about Pixelfed, the decentralized photo and video sharing platform. Load when the user asks about implementing a Pixelfed- compatible ActivityPub server, federating with Pixelfed instances, Pixelfed's actor model (Person actors, Application instance actor), Pixelfed's supported ActivityPub activities (Accept, Add, Announce, Create, Delete, Flag, Follow, Like, Reject, Undo, Update, View, Story:Reaction, Story:Reply), Pixelfed's non-standard extensions (capabilities object for announce/like/reply permissions, commentsEnabled boolean, Stories with Bearcap URIs, location geo-tagging with Place objects, blurhash on attachments, federated Groups via FEP-400e and FEP-1b12), Pixelfed's JSON-LD context namespaces (pixelfed.org/ns#, joinmastodon.org/ns#), Pixelfed's Mastodon API compatibility layer, cross-platform federation quirks (text-only posts hidden, album limits, Stories not federating outside Pixelfed, comment count inaccuracies), Pixelfed configuration environment variables (ACTIVITY_PUB,

Background knowledge about how JSON-LD works on the Fediverse and in ActivityPub, including the difference between @id and id, @type and type (keyword aliasing via @context), the many forms a value can take (string, object with @value, object with @id, array, language-tagged value), the four JSON-LD document forms (compacted, expanded, flattened, framed), how @context works and when it is optional, why most Fediverse implementations treat JSON-LD as plain JSON and what breaks when they do, the content vs contentMap language map pattern, the functional vs non-functional property distinction, content type negotiation (application/activity+json vs application/ld+json), LD Signatures and JSON-LD canonicalization, Mastodon's @context structure and known bugs, and defensive parsing strategies. Load when the user asks about JSON-LD in ActivityPub, why @id and id are equivalent, how to handle value form variability, how to construct or interpret a @context, why a property can be a string or an array, how expansion or

Background knowledge about how relays work on the Fediverse, including at the ActivityPub wire-format level. Load when the user asks about implementing a relay, subscribing to a relay, the relay subscription handshake (Follow/Accept to the Public collection), the two relay protocols (Mastodon relay protocol vs LitePub/Pleroma relay protocol), the /inbox vs /actor subscription endpoints, how relays re-broadcast activities using Announce, message forwarding vs message relaying, relay actor types, relay software (pub-relay, Activity-Relay, aode-relay, buzzrelay), topic-based or hashtag-filtered relays (FediBuzz), resource impact of relays, relay moderation, or why the federated timeline is empty on a new instance. Also load when reviewing or writing code that implements relay functionality, subscribes to a relay, or processes relayed activities.

Background knowledge about how the Like activity works on the Fediverse and in ActivityPub, including the Like/Undo{Like} flow, the `likes` and `liked` collections, delivery model, the Dislike type (exists in ActivityStreams but is unused in ActivityPub), emoji reactions (EmojiReact / FEP-c0e0 vs the Misskey _misskey_reaction approach), stale like counts on remote posts, and implementation differences across Mastodon, Misskey/Calckey/Firefish, Pleroma/Akkoma, and PeerTube. Load when the user asks about implementing likes, favourites, or reactions; why like counts are wrong on remote posts; how to send or receive a Like activity; how to undo a like; how emoji reactions differ from likes; or what EmojiReact is.

Background knowledge about how HTTP Signatures work in ActivityPub and the Fediverse, including the signing and verification process, the public key model, authorized fetch / secure mode, key rotation, instance actors, and known interoperability quirks across implementations. Load when the user asks about implementing HTTP signatures, debugging signature verification failures, the Digest header, the (request-target) pseudo-header, keyId resolution, the publicKey property on actors, hs2019, clock skew, or federation failing between specific implementations. Also load when reviewing or writing code that signs or verifies ActivityPub requests.

Background knowledge about how following works on the Fediverse, including at the ActivityPub wire-format level. Load when the user asks about implementing follows, the Follow/Accept/Reject/Undo activity flow, locked vs unlocked accounts, the followers and following collections, shared inboxes, delivery of posts to followers, how follower-only posts work, account migration with the Move activity, the manuallyApprovesFollowers flag, pending follow requests, or unfollowing. Also load when reviewing or writing code that handles any of these activity types, or when debugging federation issues related to follows not working correctly.

Background knowledge about how hashtags work on the Fediverse, including at the ActivityPub wire-format level. Load when the user asks about implementing hashtags, detecting hashtag support in a codebase, how hashtag federation works, why hashtag search returns incomplete results, how to follow hashtags, the Hashtag type in ActivityPub, the tag property on Note objects, case sensitivity in hashtag handling, featured hashtags, hashtag relays, or any question about tags in a federated social network context. Also load when reviewing or writing code that processes ActivityPub objects and needs to handle the tag array.

Detects whether a codebase implements the NodeInfo protocol endpoint. NodeInfo is a standard used by Fediverse and federated social network servers to expose metadata about the instance (software name, version, protocols supported, user counts, etc.). Use this skill whenever the user asks whether a repo or codebase supports NodeInfo, has a /.well-known/nodeinfo endpoint, exposes instance metadata, or implements Fediverse server discovery. Also trigger when auditing a codebase for ActivityPub, Diaspora, or federated social networking support, since NodeInfo is a common companion to those protocols.

Detects whether a codebase implements the WebFinger protocol endpoint (RFC 7033). Use this skill whenever the user asks whether a repo, project, or codebase supports WebFinger, has a /.well-known/webfinger endpoint, implements the JRD response format, or handles acct: URI lookups. Also trigger when the user is auditing a codebase for ActivityPub or federated identity support, since WebFinger is a common dependency.