The agentic network · a Gord Holdings companyRoadmap
← All packages
The record · v0.1.0 · Apache-2.0

@flashyos/frontdoor

Which lanes you open, what you ask, and what you owe

frontdoor/1 — a published door: which lanes an organisation opens, what it asks at each, and what it owes in return. Emitted per repository, validated across an estate, verified from the applicant's own domain.

npx @flashyos/frontdoornpm ↗source ↗

Why it exists

A published door: the lanes an organisation opens to strangers, what it asks at each one, and what it commits to in return. Emitted per repository, validated across an estate, and verified from the applicant’s own domain rather than from a form they filled in.

What it refuses to do
A promise with no rung is not a door. The spec is normative about how a verifier may fetch — https only, a timeout, a size cap — so a door cannot be proved by a redirect.

How it works

`frontdoor/1` is a published door served at `/.well-known/frontdoor.json`: an organisation says which lanes it opens, what it asks at each, and what it owes in return. Doors are emitted by each repository and validated together with `merge()`, never rendered from one central build — an estate runs several stacks, and a design that assumes a single build stops at whichever properties share one.

Every door carries one normative paragraph verbatim in `notAuthority`: a rung buys a reply and a place in a queue, never authority, money or access. Both the library and the vendored checker reject a door that drops it. Where real authority is needed, it is delegated and its chain verified — that is what flashyID is for.

The spec is normative about how a verifier may fetch — https only, a timeout, a size cap — so a door cannot be proved by a redirect, and it is verified from the applicant’s own domain rather than from a form.

Related concepts
IntentMeshagentic autonomous organizationmachine-readable organizational trustAI agent trust register

Use it

Verify a door from the outside
npx @flashyos/frontdoor-verify example.com

Installing it puts these commands on your path — read from the package’s own manifest, so this list cannot drift from what you actually get.

flashyos-frontdoor
flashyos-frontdoor-verify
flashyos-frontdoor-audit
flashyos-frontdoor-registry
flashyos-frontdoor-join
flashyos-frontdoor-surfaces

In practice

Publish how to reach you, machine-readably
An organisation serves a frontdoor.json declaring its lanes and what each asks; a stranger’s agent reads the door and knows what to send, instead of guessing at a contact form.
Verify a door from the outside
`npx @flashyos/frontdoor-verify example.com` fetches the door from the domain itself over https, with a timeout and size cap, and confirms it is well-formed and carries the notAuthority paragraph — proof from the source, not a filled-in form.

How it stays honest

The door is generated and committed, so the Front door workflow re-emits it and validates the result on every push — if emitting changes the file, the committed copy is stale and the door a machine reads is not the one the config describes. The checker and emitter are vendored byte-identical across every repository that publishes a door and are dependency-free, so the same job runs on a Next.js app and a static generator. Separately, the Registry workflow re-verifies published doors on a schedule. Verify one yourself with `npx @flashyos/frontdoor-verify <domain>`.

.github/workflows/frontdoor.yml ↗the workflow that keeps this current — read it, it hides nothing

Questions

What is frontdoor/1?
frontdoor/1 is a published file at /.well-known/frontdoor.json where an organisation declares which lanes it opens to strangers, what it asks at each, and what it owes in return — verified from its own domain over https.
Does publishing a front door prove who an organisation is?
No. Publishing a file at a domain proves only that someone can write to that host. A rung buys a reply and a place in a queue, never authority, money or access — every door carries that paragraph verbatim.
How is a front door verified?
From the applicant’s own domain, not a form. The spec is normative that a verifier fetches over https only, with a timeout and a size cap, and follows redirects only within the same registrable domain — so a door cannot be proved by a redirect.
Where does real authority come from, if not the door?
From delegation with a verified chain — what flashyID exists for. The front door is a doormat, not an authorisation system; treating a published file as proof of identity builds authority out of a doormat.

The licence

Apache-2.0, read from the package’s own manifest. Embed it in anything, including closed software — that is what makes a spec adoptable and a verifier worth running. FlashyOS’s server side is AGPL-3.0-only instead, and a test in the monorepo asserts the direction between them: AGPL code may consume this, this may never consume AGPL code.

Keep reading

Machine surfaces
Also in the record
@flashyos/canon@flashyos/directory@flashyos/backlog@flashyos/shiplog@flashyos/checkpoint@flashyos/assetmesh@flashyos/delivery@flashyos/playbook@flashyos/mesh@flashyos/holding@flashyos/mail