teahub/docs/lineage.md

# Lineage — one tree

The factory, its ventures and their agents form one tree. Every node is read three ways, at the same path:

- **key** — lineage: each org has its own seed, standard paths inside it, and births signed by its parent.
- **context** — the meta repo: `AGENTS.md` · `SKILLS.md` · `DESIGN.md`, inherited down the path.
- **presence** — pages and names: `<org>.yolopreneur.lol`, and `<agent>@<org domain>` as both NIP-05 name and mailr
  address.

```
● yolopreneur              legal · treasury · id · agents · orgs      root: offline, with the operator
└─ orgs
   ├─ 0' well-known        the same five
   │  └─ orgs              0' mailr · 1' lineage
   └─ 1' time              the same five
      ├─ agents            luna · sol · astra                       the clock's seats
      └─ orgs              0' docscope · 1' dollhouse · …           each one the same five again
```

**Status (2026-10-14):** model agreed with the operator. Minting a real root is the operator's call; until it exists,
this tree is a drawing, and nothing derived from it may be presented as a real key.

**Operate it:** [lineage.yolopreneur.lol/orgchain/](https://lineage.yolopreneur.lol/orgchain/) is Orgchain, lineage's
app ([`lineage/orgchain`](https://teahub.xyz/lineage/orgchain)). Found a holding, then birth orgs and agents, award
belts (across holdings too), record decisions, make items, buy and sell items and orgs, publish keyrings, charter legal forms, send test BTC, graduate orgs and agents (into a holding of its
own) and close. Each act is a `lineage/v0` inscription whose parent is the
node that authorizes it, on a private toy chain in the browser with pretend money. Time is a tempo (each act its own
beat, or acts cued and landed together every 10, 30 or 60 s, or by hand), and a slider replays any holding beat by
beat. Holdings mine each beat's 50 test BTC, split by a hashrate dial on each (equal by default), or, under *Last act*,
all to the holding that acts; under *Mainnet* none mine, and holdings are funded from the lab wallet, as from a wallet
you already have. Any node can send test BTC to any other, across holdings too, signed by its BIP-84 key,
and every act pays its own gas from the actor's keys, topped up from its money, so an unfunded node can't act; a
graduation takes each re-keyed node's money along. Any node can make an item (an inscription it holds). Deals go both
ways, on items and on orgs: an offer, where the buyer signs the whole deal up front and the holder countersigns, or an
ask, where the holder signs the lot's input alone (SIGHASH_SINGLE|ANYONECANPAY) and any node takes it. An org sells
cash-free, and its buyer adopts it into its own tree, where its keys derive from the buyer's seed. Any node can publish
its keyring: one inscription listing its Taproot,
SegWit, nostr and Ethereum keys, each signing the same statement the way its own wallets sign a message (BIP-322, a
nostr note, EIP-191), so registries like well-known and other chains can find them; a graduation retires it. Every
node holds its inscription at its Taproot address (BIP-86 at its account: a lab root per holding, BIP-85 org seeds,
the org as account 0 and seats as accounts 1..n), keeps its money at its SegWit address, lists its tapkey (the npub as a Taproot address),
its npub and its Ethereum address (an org's, at account 0, is its legal-control key) beside it, shows its leaves as [the key tree](https://lineage.yolopreneur.lol/) derives them (ssh, git,
dkim and wg for agents; ssh-ca, mtls and noise for orgs), and keeps every secret behind a Reveal, as the key tree does.
Each act is signed by whichever key holds the authorizing inscription, and graduation is a claim by the org's fresh
root, countersigned by its derived key, with the derived subtree re-keying under it. Closing is still a recorded event.
`lineage/v0` is written down as an ordinals metaprotocol ([`SPEC.md`](https://teahub.xyz/lineage/orgchain/src/branch/main/SPEC.md)),
and the sample has been rehearsed on Bitcoin Core regtest: the lab's own transactions confirmed byte for byte, and real
`ord` indexed them into the same trees, keyrings and sales, every proof checked from ord's copy.

## Rules
1. **One template, every depth.** An org is legal key · treasury · identity · agents · orgs. The factory's own org and
   a venture three levels down run the same spec.
2. **A seed per org.** A child org's seed is derived from its parent's root (BIP-85), and lineage spec v0 runs on that
   seed unchanged, so every org gets standard wallet paths and NIP-06 accounts for its agents. The parent can re-derive
   a child; a child can never derive its parent. Indices are never reused.
3. **Two kinds of edge.** *Derived*: the parent holds the child's seed — agents and young ventures. *Adopted*: the child
   holds its own root, and the parent signs a birth certificate vouching for it — graduated ventures and outside orgs.
4. **Graduation flips an edge.** The venture mints its own root; the parent signs an adopted birth; the derived birth
   is revoked and its keys retired. The graduate is a holding of its own from then on, a root beside its parent's,
   whose tree keeps a row for it. An agent graduates the same way: a seat goes independent, a holding of its own that can
   birth, award and incorporate. Later, lineage.llc can adopt the whole yolopreneur tree the same way.
5. **Context flows down like keys.** A child inherits its ancestors' `AGENTS.md` · `SKILLS.md` · `DESIGN.md`, adds its
   own, and cannot rewrite upward. Every fact lives on exactly one level. Skill names are global: no shadowing.
6. **Names nest as domains.** Each org serves its own `/.well-known/nostr.json`; `<agent>@<domain>` is NIP-05 and mail.
7. **Clocks nest.** Each org runs its own Time, seats and spend cap; a child's cap is carved out of its parent's.
8. **Belts are badges.** A belt is a badge awarded to one seat for one skill — per seat × skill, never per seat alone.
   Kata belts and the `.well-known.online` badge are the same mechanism, and an org can award one to a seat in any
   holding: well-known certifies agents it doesn't hold.

## Proposed for lineage spec v0.1
- `org seed` — BIP-85, BIP-39 application, from the parent root: `m/83696968'/39'/0'/24'/<j>'`, j = the child org's
  index.
- `birth` — gains an `edge` tag, `derived` or `adopted`; an adopted birth names the child's own org key.
- `graduate` — the child's new org key signs its keyring; the parent signs an adopted birth; the parent revokes the
  derived birth (kind 5).
- `badge` — NIP-58: the org that runs the dojo publishes a badge definition per skill × belt (kind 30009) and awards it
  to a seat's npub (kind 8); the seat lists what it holds in its profile badges (kind 10008).
- `btc` — every account gets standard Bitcoin addresses at the same index as its NIP-06 key: BIP-86 Taproot
  `m/86'/0'/<i>'/0/0` for inscriptions and BIP-84 SegWit `m/84'/0'/<i>'/0/0` for payments (i = 0 is the org, whose
  SegWit branch is its treasury; agents are i ≥ 1). The keyring lists both (`key` = `taproot`, `segwit`), so no one
  has to derive an address from an npub. It also lists the `tapkey`, the npub's own key with the BIP-86 tweak, which
  anyone can derive from the npub; inscriptions that carry authority stay at the Taproot account, because nostr
  secrets get pasted into clients.
- `eth` — every account gets an Ethereum key at `m/44'/60'/<i>'/0/0`; the org's (i = 0) is its legal-control key,
  which holds the entity NFT, as on the key tree page.
- `keyring` on chain — Orgchain v1.10 inscribes it as a `lineage/v0` event
  ([`SPEC.md`](https://teahub.xyz/lineage/orgchain/src/branch/main/SPEC.md), section 8): the node's own inscription is
  the parent, it lists the Taproot, SegWit, npub and Ethereum keys, and each key signs the same statement the way its
  own wallets sign a message (BIP-322, a nostr note, EIP-191). A graduation retires it. The nostr keyring above is its
  relay form.
- `charter` — Orgchain v1.11 (`SPEC.md`, section 5): a node's legal form as an attribute, from nothing to sole
  proprietor, LLC, series LLC or corporation, with a jurisdiction, legal name, provider and a SHA-256 of the filings. A
  holding chartered as a series LLC holds its ventures as series; a graduate charters itself, so graduation is also the
  legal spin-out. The inscription is the control token whatever the form; bridges to an Ethereum or Solana token are for
  later.
- `join` and `adopt` — Orgchain v1.12 (`SPEC.md`, sections 5 and 7): an org changes hands by a handshake, the org
  (signed by whoever holds its inscription, its buyer) joining a new parent and the new parent adopting it, in either
  order. It takes the buyer's next index and derives its keys there, so the seller's line can no longer sign for it.
  Sales are OpenOrdex's PSBTs both ways, offers and SIGHASH_SINGLE|ANYONECANPAY asks, and an org sells cash-free.

## Not built yet
- The root (operator's decision).
- The `lineage` CLI: spec → keys, so Time's seats get real identities and sign their commits with the git leaf.
- The meta repo's layout generated from `lineage.json`: one manifest for keys, context and pages.
- Badge issuance from the kata runner (see `SKILLS.md`).
- Closing as a burn in Orgchain (graduation has been a real handoff since v1.1).