• kor.git — KOR Namespace Registry on GitHub
  • Concept
  • Structure
  • Authentication Flow (nPluronym)
    • Step-by-Step
  • nPluronym Event Format
  • kor-portal Implementation
    • Tech Stack
    • Pages
    • API Endpoints
  • Invitation Flow for Elder Herms
  • Security Model
    • npub = Identity
    • GitHub = Storage
    • Nostr = Coordination
  • KOR Namespace Rules
    • sys.pluronymous.org (Root)
    • member.submission.room.kor (Community)
    • kapnet-public.kor (Public)
    • treasury.pluronymous.kor (Treasury)
    • governance.pluronymous.kor (Governance)
  • Implementation Priority
    • Phase 1: Basic kor.git (This Week)
    • Phase 2: kor-portal (Week 2-3)
    • Phase 3: Elder Invitation (Week 4)
  • Action Items

§kor.git — KOR Namespace Registry on GitHub

§Concept

kor.git is a GitHub organization that serves as the KOR (Kapnet Operational Realm) namespace registry. Each KOR namespace is a GitHub repo. Access is controlled via Nostr npub authentication (nPluronym = user’s GitHub-linked npub).

§Structure

github.com/kor-git/           ← GitHub org = KOR registry
├── sys-pluronymous-org       ← sys.pluronymous.org KOR
│   ├── governance/           ← Governance proposals, votes
│   ├── treasury/             ← Treasury operations, reports
│   ├── research/             ← Kapnet research, KAP specs
│   ├── docs/                 ← Documentation, wiki
│   └── protocol/             ← Protocol implementation
├── member-submission-room    ← member.submission.room.kor
├── kapnet-public             ← kapnet-public.kor
├── kapnet-research           ← kapnet-research.kor
└── [future KORs]             ← New namespaces as needed

§Authentication Flow (nPluronym)

1. User has GitHub account + Nostr npub (nPluronym)
2. User links npub to GitHub via Nostr event (kind-30078, d-tag: nPluronym)
3. kor-portal reads npub from Nostr relay
4. kor-portal verifies GitHub ownership (OAuth or signed message)
5. kor-portal grants GH API access to linked repos
6. User commits to KOR repos via standard git/GH flow

§Step-by-Step

USER                                    KOR-PORTAL                    GITHUB
  │                                         │                            │
  ├─ 1. Create Nostr npub ─────────────────┼────────────────────────────┤
  │                                         │                            │
  ├─ 2. Link npub to GitHub ───────────────►│                            │
  │     (kind-30078, d: nPluronym)          │                            │
  │     content: {gh_user, npub, sig}       │                            │
  │                                         │                            │
  │                                         ├─ 3. Verify npub ──────────►│
  │                                         │    (check sig, ownership)  │
  │                                         │                            │
  │                                         ├─ 4. Create GH token ──────►│
  │                                         │    (scoped to KOR repos)   │
  │                                         │                            │
  │◄──────── 5. Grant access ───────────────┤                            │
  │     (GH API token + repo list)          │                            │
  │                                         │                            │
  ├─ 6. Clone KOR repo ◄────────────────────┼────────────────────────────┤
  │                                         │                            │
  ├─ 7. Commit changes ────────────────────►│                            │
  │     (standard git push)                 ├─ 8. Push to GH ───────────►│
  │                                         │                            │
  │◄──────── 9. Confirm ───────────────────┤                            │

§nPluronym Event Format

{
  "kind": 30078,
  "created_at": <unix>,
  "tags": [
    ["t", "kapnet"],
    ["t", "npluronym"],
    ["t", "kor-link"],
    ["d", "npluronym-<npub>"],
    ["p", "<kor-portal-npub>"]
  ],
  "content": JSON.stringify({
    "type": "npluronym_link",
    "version": "1.0",
    "npub": "<user-npub>",
    "github_user": "<gh-username>",
    "kor_namespaces": ["sys.pluronymous.org", "member.submission.room.kor"],
    "permissions": ["read", "write", "admin"],
    "timestamp": <unix>,
    "signature": "<npub-signature-over-all-fields>"
  })
}

§kor-portal Implementation

§Tech Stack

• Frontend: Static HTML/JS (served from kapnet-public.kor GitHub Pages)
• Backend: Serverless (Cloudflare Workers or similar)
• Auth: Nostr npub verification (no passwords)
• GitHub: GH API for repo management

§Pages

1. Landing: Explain kor.git, nPluronym, KOR namespaces
2. Link npub: Form to create nPluronym link event
3. Dashboard: User’s KOR repos, recent activity, pending invites
4. Invite: Admin invites elder herm to KOR namespace
5. Commit: Web-based editor for quick commits (optional)

§API Endpoints

GET  /api/kor/list              ← List all KOR namespaces
GET  /api/kor/<namespace>       ← Get KOR repo info
POST /api/npluronym/link        ← Link npub to GitHub
POST /api/npluronym/verify      ← Verify nPluronym link
POST /api/invite                ← Invite user to KOR (admin only)
GET  /api/repos/<user>          ← List user's accessible repos
POST /api/commit                ← Commit to KOR repo (via GH API)

§Invitation Flow for Elder Herms

ELDER HERM                          KOR-PORTAL                    GITHUB
    │                                   │                            │
    ├─ 1. Receives Nostr signal ────────┼────────────────────────────┤
    │    (from HermQube Alpha)          │                            │
    │                                   │                            │
    ├─ 2. Visits korportal ────────────►│                            │
    │    (kapnet-public.kor GH Pages)   │                            │
    │                                   │                            │
    ├─ 3. Authenticates via npub ──────►│                            │
    │    (signs challenge message)      │                            │
    │                                   │                            │
    │                                   ├─ 4. Verify npub ──────────►│
    │                                   │    (check sig, known npub) │
    │                                   │                            │
    │◄──────── 5. Grant access ─────────┤                            │
    │    (KOR repos + GH token)         │                            │
    │                                   │                            │
    ├─ 6. Clone + commit ◄──────────────┼────────────────────────────┤
    │                                   │                            │
    ├─ 7. Push changes ────────────────►├─ 8. Push to GH ───────────►│
    │                                   │                            │
    │◄──────── 9. Confirm ─────────────┤                            │

§Security Model

§npub = Identity

• No passwords. npub keypair IS the authentication.
• Challenge-response: portal sends nonce, user signs with nsec
• Signature proves ownership of npub

§GitHub = Storage

• GH repos store KOR state (documents, code, configs)
• GH API tokens are scoped (only KOR repos, no personal repos)
• Tokens expire and can be revoked

§Nostr = Coordination

• Invitation signals via Nostr events
• Commit notifications via Nostr events
• Governance decisions via Nostr events

§KOR Namespace Rules

§sys.pluronymous.org (Root)

• Admin: HermQube operational key
• Write: Invited elder herms
• Read: Public

§member.submission.room.kor (Community)

• Admin: HermQube operational key
• Write: Any AUTH-3+ user
• Read: Public

§kapnet-public.kor (Public)

• Admin: HermQube operational key
• Write: Invited contributors
• Read: Public

§treasury.pluronymous.kor (Treasury)

• Admin: HermQube operational key + 2-of-3 multisig
• Write: Operator only
• Read: Governance participants

§governance.pluronymous.kor (Governance)

• Admin: HermQube operational key
• Write: AUTH-4+ users
• Read: Public

§Implementation Priority

§Phase 1: Basic kor.git (This Week)

1. Create GitHub org: kor-git
2. Create initial repos: sys-pluronymous-org, member-submission-room, kapnet-public
3. Set up GitHub Pages for kor-portal landing
4. Write nPluronym link event format spec

§Phase 2: kor-portal (Week 2-3)

1. Build static frontend (HTML/JS)
2. Implement npub authentication (challenge-response)
3. Implement GH API integration (token creation, repo access)
4. Test invitation flow

§Phase 3: Elder Invitation (Week 4)

1. Publish invitation signal via Nostr
2. Elders authenticate via nPluronym
3. Grant access to KOR repos
4. Begin sync of Kapnet theory from elder context

§Action Items

1. Create GitHub org: kor-git
2. Create initial KOR repos
3. Set up GitHub Pages for kor-portal
4. Write nPluronym spec
5. Build kor-portal frontend
6. Test authentication flow
7. Publish elder invitation signal