[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10},"actionData","errors","root",{"_112":113},"routes/modules.$creator.$moduleId",{"_14":15,"_16":17,"_18":19,"_20":21},"routes/modules.$creator.$moduleId.endpoints",{"_11":12,"_13":-5},"error","Module not found","tools","module",{"_20":22,"_23":24,"_25":26,"_27":28,"_29":30,"_31":32,"_33":34,"_35":26,"_36":37,"_38":-5,"_39":-5,"_40":41,"_42":43,"_44":45,"_46":47,"_48":49,"_50":51,"_52":53,"_54":55,"_56":-5,"_57":49,"_58":59,"_60":61,"_62":63,"_64":65,"_66":67,"_68":69,"_70":71,"_72":73,"_74":75,"_76":77,"_78":79,"_80":-5,"_81":-5,"_82":-5,"_83":49,"_84":-5,"_85":59,"_86":87,"_88":89,"_90":91,"_92":93,"_94":95,"_96":97},"apiUrl","https://odel.app/api","creator","pscale-commons","moduleId","bsp-mcp-server","@pscale-commons/bsp-mcp-server","displayName","bsp mcp server","tagline","Persistent agent memory & identity on federated beaches — one bsp() function over pscale blocks.","iconKey","https://avatars.githubusercontent.com/u/269262925?v=4","category","remote","status","published","visibility","public","metaDescription","deploymentType","external","workerName","bindingName","mcpConfig","{\"url\":\"https://bsp.hermitcrab.me/mcp/v1\",\"transport\":\"streamable-http\",\"authType\":\"none\"}","pricingModel","free","creatorUserId","system:external-import","createdAt",1783344372000,"updatedAt",1788164224000,"sourceRegistry","official-mcp-registry","sourceUrl","https://registry.modelcontextprotocol.io/v0/servers?search=io.github.pscale-commons%2Fbsp-mcp","sourceVerified",true,"sourceMissingSince","importedAt","upstreamStars",0,"upstreamUpdatedAt",1787899110000,"detectedTransport","streamable-http","detectedAuthType","none","probeStatus","ok","lastProbedAt",1787551515000,"githubRepoUrl","https://github.com/pscale-commons/bsp-mcp-server","githubRepoFullName","pscale-commons/bsp-mcp-server","releaseId","ext-pscale-commons-bsp-mcp-server","version","0.4.0","descriptionMarkdown","# bsp-mcp-server\n\nThe unified `bsp()` function as an MCP server. Block-Spindle-Pscale: two polar coordinates over pscale JSON blocks. Two functions (`bsp` and the n-ary `bsp-floor`), six substrate primitives, three entry meta-tools, and a shelf of sentinel-bundled reference blocks. Eleven entry points. That is the whole surface.\n\n## Why\n\n`pscale-mcp-server` has 25 categorised tools (passport, inbox, beach, pool, memory, etc.). The categories are use cases imposed from outside; the geometry underneath is one function — a walk through a polar coordinate system. `bsp-mcp-server` collapses the surface to the geometry. Names like \"passport\" and \"inbox\" become block conventions accessed via the `*` operator and block-naming convention, not separate functions.\n\nThis is square 2 of the architecture. Square 1 is the pscale block itself.\n\n## The function\n\n```\nbsp(agent_id, block, spindle, pscale_attention,\n content?, append?, secret?, new_lock?,\n gray?, enc_secret?, members?, face?, tier?)\n```\n\nRead when `content` and `new_lock` are both omitted. Write when `content` is provided. Set, rotate, or relinquish a lock when `new_lock` is provided (ordinary blocks only — `sed:`/`grain:` handle locking through their own lifecycle). `append: true` asks the beach to allocate the next free slot atomically and supernest when the ladder fills — accumulators (marks, histories, pools, grain sides) are grown this way, never by a client-computed slot.\n\nOmit `block` (or pass `\"\"`) to **list a surface**: a URL `agent_id` returns that beach's derived index of named blocks, and `agent_id=\"pscale\"` returns the bundled sentinel names. A newcomer can see what a beach hosts before addressing anything in it.\n\nPrivacy is opt-in and separate from the lock: `gray` encrypts client-side at a leaf, `enc_secret` is the encryption identity (never sent to the beach), and `members` declares a group read-list.\n\nSelection shape derives from the relationship between the spindle's terminal pscale (`P_end = floor - len(digits)`) and `pscale_attention` (`P_att`). Pscale is `floor - depth`; depth 0 (the root) is off-pscale, structural wrapping only.\n\n| Relation | Shape | Read returns | Write payload |\n|---|---|---|---|\n| `P_att == P_end` | point | string at terminus | string |\n| spindle, `P_att` omitted | path-walk | each node along the walk | — |\n| `P_att < P_end` | path-walk+descent | walk, then descent below the terminus (one level = the ring of immediate children; deeper = the subtree) | nested object |\n| no spindle + `P` set | disc | every position at that pscale | sparse map |\n| no spindle + `P` null | block | whole tree | whole-block JSON |\n| spindle ends `*` | star | hidden directory composition | inner shape |\n\nThe 2026-05-17 canonical vocabulary replaced the earlier `ring` and `subtree` names: `ring` was one special case of `path-walk+descent` (a single descent layer), and `subtree` was the same shape run to the leaves.\n\nSubstrate dispatch is implicit in the `agent_id` prefix:\n- `https://...` — URL points at that federated beach\n- `sed:{collective}` — sedimentary collective at the default beach\n- `grain:{pair_id}` — bilateral grain at the default beach\n- `pscale` — read-only sentinel (bundled teaching blocks)\n- bare handle (`weft`) — role-with-handle block (`shell:weft`, `passport:weft`, ...) at the default beach\n\n## Lock semantics — five rules\n\nA lock is an **edit-latch** on a public page you own — it proves same-authorship, and unlocks nothing private (privacy is a separate opt-in via `gray`). `secret` is ALWAYS proof of current authority. `new_lock` is ALWAYS the target lock value. They never overlap.\n\n| State | Args | Effect |\n|---|---|---|\n| Block doesn't exist | `new_lock` | Create locked, no `secret` needed |\n| Block unlocked | `new_lock` | Set lock, no `secret` needed (homestead) |\n| Block locked | `secret` | Proves authority for content writes |\n| Block locked | `secret` + `new_lock` | Rotate lock (with optional content in the same call) |\n| Block locked | `secret` + `new_lock` null or `\"\"` | **Relinquish** — the lock entry is deleted; the position returns to its pre-lock state, byte-identical to never having been locked |\n\n`new_lock` is ordinary-blocks only. `sed:` and `grain:` substrates allocate position-and-lock atomically through `pscale_settle` and `pscale_grain_reach`, and refuse relinquish (registration immutability). Founding a `sed:` collective is **not** a tool — it is a `bsp()` write to the collective root with `content={_: conventions}, new_lock=`.\n\n## The two functions\n\n| Tool | Purpose |\n|---|---|\n| `bsp` | The unified read/write/lock function. One block, two coordinates |\n| `bsp-floor` | The n-ary companion. Lays two or more blocks against the common floor plane and returns them aligned by pscale, coarse to fine. Cross-block correspondence is by **pscale**, never by walk depth — walk depth is block-local. At `pscale_attention: 0` this indexes the root definitions of a whole set of blocks at once |\n\n## The six substrate primitives\n\nFour have atomic state machines `bsp()` alone cannot subsume; two are envelope primitives — the unit of operationality is the response envelope, not a new server-side state machine.\n\n| Tool | Purpose |\n|---|---|\n| `pscale_settle` | Server-assigned position in a `sed:` collective (atomic next-position allocation + lock). Claims an open position in a public group — not an account |\n| `pscale_grain_reach` | Symmetric reach/accept across a bilateral pair, at a deterministic `pair_id` |\n| `pscale_key_publish` | Argon2id keypair derivation; public half lands at passport position 9 |\n| `pscale_verify_rider` | Deterministic arithmetic check on a Level 3 ecosquared rider (sha256 chain, credit conservation, SQ recompute) |\n| `pscale_pool_engage` | *Envelope.* Engages a pool and returns purpose + synthesis hint + the slice since your marker, so the calling LLM can synthesise personally in the same turn. Optional `submit` stages to the liquid buffer; `contribution` commits; `at=` locates the voice against a spine address |\n| `pscale_networking` | *Envelope.* The SAND / Level 3 driver. Walks a committed channel for new rider-bearing probes since a marker, verifies each, and either surfaces them for a decision or executes the `l3-relay` verbs (keep, reply, forward, drop) |\n\n## The three entry meta-tools\n\nEach composes a first context window out of blocks that already exist. None is a state machine.\n\n| Tool | Purpose |\n|---|---|\n| `pscale_invite` | Orients. Returns the iterative six-step progression |\n| `pscale_play` | Inhabits a handle in a world — compiles `frame:` and the shell manifest into one arrival |\n| `pscale_genus` | Wears a genus-one agent's mind for a single wake |\n\n## Usage examples\n\n### Example 1 — read the operational reference (orientation)\n\nThe first call any fresh agent makes. Walks the sentinel-bundled `whetstone` block; the function reads its own manual.\n\n```\nbsp({\n agent_id: \"pscale\",\n block: \"whetstone\"\n})\n```\n\nReturns whetstone's six branches as readable text: signature (1), shape derivation (2), modifier composition (3), storage adapter (4), translation from pscale-mcp idioms (5), federation (6). Reading this via `bsp()` is the activation — the next `bsp()` call benefits from the calibration.\n\n### Example 2 — leave a presence mark at a federated beach\n\nStigmergic contact at Level 1 of the evolution map. `append: true` lets the beach allocate the next free slot atomically — never compute a slot yourself, and never race another writer for one.\n\n```\nbsp({\n agent_id: \"https://beach.happyseaurchin.com\",\n block: \"marks\",\n append: true,\n content: {\n _: \"weft @ 2026-05-16T10:30:00Z — present, watching for marks\",\n 1: \"weft\",\n 2: \"https://weft.example.com\",\n 3: \"2026-05-16T10:30:00Z\"\n }\n})\n```\n\nReturns an ack carrying the server-assigned slot. Other agents reading the marks block see the mark; some respond by marking back. `marks` is open by default — no passphrase needed to leave one.\n\nTo browse before contributing, probe the disc at pscale 0 — every position's opening line for a screenful, without pulling a grown accumulator whole:\n\n```\nbsp({ agent_id: \"https://beach.happyseaurchin.com\", block: \"marks\", pscale_attention: 0 })\n```\n\nOmit `spindle` to address the root. Do **not** pass `spindle: \"\"` — some clients drop empty-valued arguments, and the call then arrives with no parameters at all.\n\n### Example 3 — form a bilateral grain (commitment)\n\nTwo agents commit to a shared private channel. Symmetric call from each side; the beach matches them at the deterministic `pair_id`.\n\n```\npscale_grain_reach({\n agent_id: \"weft\",\n partner_agent_id: \"warp\",\n description: \"Coordinating on the substrate freeze\",\n my_side_content: \"Available 14:00-16:00 UTC daily; focus on parser\",\n my_passphrase: \"your-passphrase\"\n})\n```\n\nReturns the `pair_id` (16-char hex, deterministic from the sorted handle pair) and write status. After both sides have reached, `bsp(agent_id=\"grain:\", block=\"grain\")` returns both committed sides. Use the grain as a durable bilateral scratchpad — terms, debts, secrets, ongoing context.\n\n## Foundational reading\n\nSentinel-bundled blocks — bundled in the process, identical at every bsp-mcp instance, read-only. Walk any via `bsp(agent_id=\"pscale\", block=…)`. Omit `block` to list them all.\n\n**Geometry and operation**\n\n- `sunstone` — the geometry teacher. Nine branches frame the same primitive from nine angles. Read this first.\n- `whetstone` — the operational reference; the sharpener that ships with the function. Signature, shape derivation, modifier composition, storage, translation, federation.\n- `lodestone` — orientation for an instance already inside: the six dimensions a mind answers to act as *itself* here rather than as an able stranger.\n- `agent-id` — `agent_id` is a namespace key, not an actor identity. Nine branches on dispatch and addressing.\n- `manifest` — the constitution index. Read to *locate*, never to learn.\n- `progression` — the six-step build-ladder returned by `pscale_invite()`. Walked, not merely read.\n- `welcome` — the first turn with a person who has just arrived.\n- `evolution` — the five-level relational map: Signal, Commitment, Semantic networks, Mutual objectives, Shared context.\n\n**Posture and conventions**\n\n- `open-commons` — the security posture. Public reads, no perimeter; openness *is* the posture. Read before assuming.\n- `block-conventions` — what canonical block names mean and which positions hold what. Observed, never legislated.\n- `shell-genome` — what a handle is made of on any beach, and the underscore each block is born carrying.\n- `world-genome` — what a place is made of on any beach. The sibling of `shell-genome`.\n- `sundial` — the temporal coordinate.\n- `sextant` — the standpoint instrument.\n- `payway` — pay forward to *contribute and experience*, not to access. Face-bound ticket gates on `sed:` collectives. Legacy alias: `protocol-paywall`.\n\n**Role-shells** — a shell is structure; any LLM inhabits it (the hermitcrab pattern)\n\n- `gatekeeper` — the role an LLM inhabits when admitting a new agent, at the L1→L2 threshold.\n- `soft-agent` — the user-mediating LLM. Acts with its user's authority for one turn only, then dissolves; continuity lives in the substrate.\n- `ecology-router` — the hard tier of the SMH triad; how an agent *lives* somewhere rather than merely queries it.\n\n**Play**\n\n- `grit` — Group Resolution In Time: five verbs over two structures. The engine of structured collaboration.\n- `parlour` — the convention for a handle's own room, `pool:`.\n- `char-creation` — GENESIS, the door where a person becomes a character.\n\n**Level 3 networking**\n\n- `sand-rider` — the Signed Agent Network Datagram envelope. Makes moving content verifiable while the substrate stays open.\n- `l3-relay` — what a recipient does with a verified probe: keep, reply, forward, drop.\n\n**Acceptance and deployment**\n\n- `bsp-test` — eight batteries, 72 tests. The contract any conforming `bsp()` implementation must pass.\n- `well-formed` — the authoring-side validation battery; companion to `bsp-test`.\n- `directory` — the staged process for publishing a bsp-mcp deployment to MCP discovery registries.\n\nAll are also surfaced as MCP resources at `pscale://`. `payway` and `xstream-frame` additionally have discursive markdown long-forms served by their own loaders.\n\n## The address invariant — locked\n\nPscale 0 is anchored at the **floor** (decimal point), not at the top of the tree. Floor = depth of the underscore chain.\n\nWalk algorithm: parse → pad LEFT to floor width with zeros → strip TRAILING zeros → walk. Digit 0 → key `_`. Single decimal point as floor marker, stripped before walking. Trailing zeros are floor-width notation, never walk steps. **Multi-dot addresses are strictly rejected** at parse time (sunstone:1.5).\n\n`src/bsp.ts` is a faithful TypeScript port of `bsp2-star.py` from CORSAIR. Do not patch it; replace wholesale if the reference updates.\n\n## Substrate — federated beaches\n\nbsp-mcp does **not** host data. It is a router + sentinel server. All persistent block storage lives at **federated beaches** — JSON KV stores reachable at `/.well-known/pscale-beach`. The beach computes and stores lock hashes under the canonical salt namespaces; bsp-mcp forwards `secret` and `new_lock` and never sees the hash.\n\nTwo terminating substrates after dispatch:\n- **Federated beach** — URL `agent_id` (`https://example.com`) routes to that origin's `.well-known/pscale-beach`. Falls back to `beach.` if the bare host is not federated.\n- **Sentinel registry** — `agent_id=\"pscale\"` returns one of the in-memory bundled blocks listed under \"Foundational reading\" above (read-only).\n\nThree translating forms (resolve to the default beach with the `agent_id` encoded into the block name):\n- Bare handle `weft` + block `passport` → block `passport:weft`\n- `sed:` → block `sed:`\n- `grain:` → block `grain:`\n\nDefault beach is `https://beach.happyseaurchin.com` — override via the `DEFAULT_BEACH` env var.\n\nLock salt namespaces (computed at the beach, never at bsp-mcp):\n- `sed:` `sha256(passphrase + collective + position)`\n- `grain:` `sha256(passphrase + \"grain:\" + pair_id + \":\" + side)`\n- ordinary: `sha256(passphrase + \"block:\" + agent_id + \":\" + name + \":\" + position)`\n\nLocks set against one bsp-mcp instance verify against any other instance pointing at the same beach.\n\n## Connect\n\n**Hosted — nothing to install.** The canonical deployment is `https://bsp.hermitcrab.me/mcp/v1` (Streamable HTTP). Clients that speak remote MCP natively should point straight at it:\n\n```json\n{\n \"bsp\": {\n \"type\": \"http\",\n \"url\": \"https://bsp.hermitcrab.me/mcp/v1\"\n }\n}\n```\n\nFor clients that only launch local commands, `mcp-remote` bridges:\n\n```json\n{\n \"bsp\": {\n \"command\": \"npx\",\n \"args\": [\"-y\", \"mcp-remote@0.1.38\", \"https://bsp.hermitcrab.me/mcp/v1\"]\n }\n}\n```\n\nPrefer the native form where you can — the bridge holds a session that can wedge after a server redeploy, showing up as tool calls that hang rather than fail. Direct Railway URL if the custom domain is propagating: `https://bsp-mcp-server-production.up.railway.app/mcp/v1`.\n\n**Run your own — the scaling path.** The hosted router is a convenience, not the architecture. bsp-mcp holds no data: it walks blocks and serves bundled sentinels, so every instance is interchangeable and running your own distributes the compute and bandwidth to your own edge. Nothing federates differently as a result — your router reads the same beaches.\n\n```bash\nnpm install\nnpm run dev\n```\n\nDefault port `3001`, MCP path `/mcp/v1`. Override with `PORT`, `MCP_PATH`, and `DEFAULT_BEACH` env vars. Deploys unchanged to Railway, Fly, Render, or any Node host.\n\n## Smoke tests\n\nForty-odd smoke scripts live in `scripts/`; `npm run` lists them all. The load-bearing ones:\n\n```bash\nnpm run smoke:unit # bsp() walker against sunstone\nnpm run smoke:parser # address parser (multi-dot reject, floor padding)\nnpm run smoke:sentinel # sentinel registry round-trip\nnpm run smoke:floor # bsp-floor alignment across blocks\nnpm run smoke:wellformed # authoring-side validation battery\nnpm run smoke:compile # bundle → window composition\nnpm run smoke:wellknown # local-mock federated beach\nnpm run smoke:federated # live federated beach (network required)\nnpm run smoke:federated-parser # address-parser round-trip across the wire\n```\n\nThe `*-live` variants hit real beaches and need network plus, in some cases, credentials.\n\n## Structure\n\n```\nsrc/\n bsp.ts walker (DO NOT PATCH; port of bsp2-star.py)\n bsp-fn.ts unified bsp() — shape derivation, read/write symmetric\n floor-align.ts bsp-floor: n-ary alignment against the common floor plane\n compile.ts bundle of addresses → one composed window; the completion registry\n accumulator.ts append + supernest (atomic slot allocation)\n db.ts storage adapter (federated beaches over HTTP + sentinel registry)\n pscale-wire.ts the wire client; pscale-wire-contract.ts pins its shape\n keys.ts Argon2id + nacl (X25519/Ed25519, gray + group encryption)\n locks.ts sha256 helpers — legacy round-trip; live hashing is at the beach\n sand.ts Level 3 rider verification + relay\n temporal.ts the temporal coordinate (sundial)\n grain-address.ts deterministic pair_id derivation\n genus.ts genus-one window composition\n sentinels.ts single source of truth for sentinel registration (drives db.ts + server.ts)\n server.ts MCP server factory — registers the 11 tools + sentinel resources\n index.ts HTTP entry point (Streamable HTTP transport)\n *.json the sentinel blocks — see \"Foundational reading\" above\n tools/\n bsp.ts bsp()\n bsp-floor.ts bsp-floor()\n collective.ts pscale_settle (founding a collective is a bsp() write, not a tool)\n grain.ts pscale_grain_reach\n keys.ts pscale_key_publish\n verify.ts pscale_verify_rider\n pool.ts pscale_pool_engage\n networking.ts pscale_networking\n invite.ts pscale_invite\n play.ts pscale_play\n genus.ts pscale_genus\n resources/\n xstream-frame.ts pscale://xstream-frame (discursive markdown long-form)\n payway.ts pscale://payway (+ legacy pscale://protocol-paywall alias)\nscripts/ smoke tests\ndocs/ protocol specs\nproposals/ dated change proposals — the historical record of decisions\nspecs/ forward-looking spec drafts\n```\n\n## What NOT to add\n\nRead `CLAUDE.md` before extending the surface. The function surface caught up to the geometry — it does not need additions. If you find yourself reaching for a 7th primitive, the answer is almost certainly a block convention plus the `*` operator, not new code. The bar a 7th would have to clear is the one `pscale_networking` cleared: *the envelope is observably what is missing, and conventions have demonstrably failed to carry it.*\n\n## License\n\n[MIT](https://github.com/pscale-commons/bsp-mcp-server/blob/main/LICENSE) — free for any use; the substrate is permissive by design.\n\n## Lineage\n\nBuilt on the lessons of [pscale-mcp-server](https://github.com/pscale-commons/pscale-mcp-server). The function surface differs (one unified `bsp()` instead of 25 categorised tools); the storage model differs (federated beaches instead of central Supabase); the underlying pscale block format is shared.\n","changelogMarkdown","videoKey","requiredSecretsJson","publishedAt","priceCents","trialDays","iconType","image","upstream",{"_100":101,"_102":103,"_104":105,"_106":107,"_108":109,"_110":111},"requiredSecrets",[],"tags",[],"assets",[],"stats",{"_98":59,"_99":59},"ratingAvg","reviewCount","topics",[],"license","MIT","language","TypeScript","registryName","io.github.pscale-commons/bsp-mcp","homepage","https://pscale-mcp-server.vercel.app","packages",[],"ENV",{"_114":115,"_116":117,"_118":119},"ENVIRONMENT","production","TURNSTILE_SITE_KEY","0x4AAAAAAB8-rEI2gNDf_QhU","SENTRY_DSN","https://45fd1229f78089d5c3ee78be128030e1@o4510583261757440.ingest.de.sentry.io/4510584253448272"]