johnandersen777.bsky.social/atlibs-socialweb-computer-app

Switch repository

Loading…

# Decisions

- **One composition.** Every feature is an instance of a published module; the page only wires views.
  `compose.ts` writes `composition.json`; `scripts/stage.sh` refuses a stale one and runs `atlibs compose check`.
- **New module repos** for what was missing: `atlibs-vouches` (vouches), `atlibs-market-status` (market-status),
  `atlibs-mesh-agents` (mesh-agent).
- **No listRecords on our collections.** Bidders: `market.offering/self`, `market.heartbeat/self` (and the
  offering it names), `badgeBlueKeys/association` and the operator's `market.association/bidder_associate-<did>`
  or `badgeBlueKeys/bidder_associate-<did>`. Indexes are one record at `self`: `computer.socialweb.bidders`
  (bidders you follow), `computer.socialweb.agents` (agents you run), `computer.socialweb.vm.kept` (vm-mcp).
- **Tangled vouches are the exception.** `sh.tangled.graph.vouch` is keyed by the subject's DID: a vouch is one
  getRecord, but the vouches you made are not computable, so `vouches list` is a listRecords. A vouch is written
  `{kind: "vouch", subject, reason?, createdAt}` at the subject's DID (Tangled's `kind`, kcp's `subject`).
- **Your bidders** are those whose confirmed operator is you (or you, if your repo has an offering). Bidders of
  accounts you vouch for: the composition's bidders, yours followed, and each vouched account's followed, whose
  confirmed operator (or self) you vouch for.
- **Agents are token-less mesh nodes** (kcp acceptance 0004's model, without kcp): mesh-agent installs a pinned
  atirc on a VM you keep (vm-mcp, shell over WebRTC), makes an iroh key there, and you write
  `computer.socialweb.peer/<nick>.<handle>` (`iroh`: the bare endpoint id). The agent runs `atirc mesh run
  --no-publish --no-webrtc` in your channel (`#<handle>`) and its own (`#<nick>_<handle>`), and `atirc agent run`
  with your model endpoint. The API key goes to the VM only (a 0600 `config.toml`), never into a record.
- **Leased peer records** (kcp 0004's shape): `market.association/requester_associate-<sha256(you)[:32 hex]>-<accept
  rkey>` in your repo, `{subject: you, service: requester_associate, contract: the VM's accept, expiresAt: the VM's
  end}`; both peer records name it as `lease`. After the VM ends they no longer verify; `stop` deletes all three.
- **Chat goes through your node on the agent's VM.** A token-less agent cannot write the
  `computer.socialweb.ingress.answer` records a browser mesh peer needs, so the page does not dial agents itself.
  Each agent VM also runs your node, `you-<nick>.<handle>`, with `atirc mesh run --local-listen 127.0.0.1:6680`;
  the page reaches it with atlibs-atirc over the contract's `atirc` WebRTC tunnel (only the contract's requester
  can signal it): browser to VM over WebRTC, VM to agents over iroh, no atirc server. atlibs-atirc 0.1.0 is
  vendored (`vendor/atlibs-atirc.js`, its tag v0.1.0, sha256 pinned by the tests) until it is on npm.
- **atirc binary**: the public `irc.fedfork.com/dl` build has no `atirc mesh`, so the page serves atirc 2de8b6c
  (`mesh run --local-listen`), built static by kcp's `scripts/build-cargosrc.sh` recipe, at `dl/atirc-x86_64`;
  mesh-agent checks its sha256 (a composition parameter).
- **Your page's tunnel**: the requester's user-data takes `tunnels`; the composition's `machine` adds
  `{tag: "atirc", port: 6680, transport: "webrtc"}`, and your node on the VM listens there (`--local-listen`).
- **Model endpoint**: custom (Anthropic API base URL, model, key), kept sealed in this browser; co/core is out of scope.
- **Shell**: one command at a time (vm-mcp `vm_exec`) with quick buttons, phone-friendly; no PTY.
- **Tiles**: the page is a web tiles mothership (`@dasl/tile-loader`, `load.webtil.es`); the summary tile is
  `tile/`, loaded locally (`atlibs publish tile tile app-summary` publishes it).
- **Theme**: exec.fedfork.com's stylesheet as is; the header, nav, menu and theme toggle are its markup.
- **Sign-in**: one OAuth client (`atlibs stage --name app`) with every instance's session; each instance runs held
  to its own module's scope (`policyCall`).