Plan · draft · 2026-11-17

Browsy hosts Wizy.
Personal, local, social — kept apart.

A privacy-first data mesh: Browsy is the extension that authenticates you (Authy) and hosts Wizy; Wizy manages your JSONs and derives recommendations; Nety carries only the social layer. Local data moves directly between permitted peers, session by session. Nothing personal leaves the device unencrypted.

01

Personal, local, social — and the apps in play

Three concentric worlds. The class of a field decides where it may live and who may read it; the app never decides that on its own.

P · personal

The world that never leaves

Journal answers, health and body data, identity proofs, precise location, private messages, keys.

  • Lives encrypted in the vault inside Browsy.
  • Only Authy (unlock/sign) and Wizy (derive, in memory) touch it.
  • Apps receive an answer or nothing — never raw personal JSON.
L · local

The world you share by permission

App portraits, extended profile fields, shared playlists, project data, circle posts.

  • Direct, peer to peer, at session start.
  • Encrypted per recipient, under a signed grant with an expiry.
  • Never routed through Nety; revoke stops future pulls.
S · social

The world you publish

Published posts, public profile, public app summaries, social recommendations.

  • Structured exactly like local data — the class tag is the difference.
  • Travels through Nety; may be mirrored by Central.
  • Publication is explicit consent, never a side effect.
App / pieceLives inRole hereClasses
BrowsyBrowser extensionHost: Authy, Wizy, vault, peer pulls, grants, enforcementP · L · S · D · M
AuthyModule inside BrowsyIdentity, channels, levels, sessions, recovery, signingP keys · M grants
WizyModule + workspace inside BrowsyJSON manager, merge, derive, projection, others viewP · L · S · D
NetyRust daemon + libp2pSocial/global transport, storage, compute, WoT rankingS (and published D)
Localhost / weblocalhost:8642 / flove.orgAuthoring and export, same schema, signed via AuthyL · S authored
Appyflove.org / localhostRenders portraits and profiles; asks Browsy for a viewL · S
flovePortrait appsAny single-file appProduce flove-portrait/1 documents (Goddy, Souls, …)L by default
MyFamilyBrowsy L use case (app stays the editor)Each added person is kept P/L/S and used L; local federated sharingP · L (used) · S
Central (optional)FastAPI / TursoPublic mirror, discovery, optional aggregationS only
Rule of thumb for every screen: class → reader → derivation. If a screen cannot answer all three, it is not ready.
02

Diagram A — the simple system

Browsy is the only host. Authy and Wizy are its two organs. The vault is the only place P/L/M rest. Peers receive encrypted L projections; Nety only receives S.

Simple system diagram Your device contains Browsy with Authy and Wizy, an encrypted vault and local derived data. Wizy exchanges encrypted local data directly with permitted peers and reads or publishes social data with Nety only when enabled. Localhost or the web author signed bundles into the vault. YOUR DEVICE BROWSY EXTENSION Authy unlock · identity channels · levels signs grants recovery · rotation Wizy JSON manager merge P + L + S derive D · explain local net + social Encrypted vault P + L + M plaintext never written D · derived recommendations stay local by default read/write after unlock derive PERMITTED PEERS · LOCAL NET Peer A · their Browsy sees only its granted paths Peer B · their Browsy per session · encrypted L → ← L NETY P2P · SOCIAL Public profile Published posts Public app summaries Social recommendations (if exported) S only · no P/L plaintext S · opt-in AUTHORING · LOCALHOST:8642 / FLOVE.ORG Same JSON schema · signed bundles · offline or web signed bundles
P · personal L · local S · social D · derived M · metadata

Browsy is the host; Authy and Wizy live inside it. The local net and Nety social are two independent switches.

03

Diagram B — the long thread

Session start: unlock → load → pull local peers → read social (optional) → merge → derive. The gates are the privacy contract.

Session thread Sequence from user unlock through Authy, vault, Wizy, permitted peer and Nety, with five privacy gates: no key no plaintext; personal data stays in memory; quarantine on signature mismatch; social data cannot contain personal fields; derivations are inspectable and local. User Browsy Authy Wizy Vault Peer Nety open session unlock request decrypt identity + grants + peers GATE 1 · no key, no plaintext unlocked session identity + grants (no P values) load L + M GATE 2 · P stays in Wizy memory pull allowed deltas (local net) encrypted projection + signature verify key · paths · expiry GATE 3 · quarantine on mismatch read S · only if social toggle is on signed S bundles GATE 4 · S carries no P fields merge P + L + S → derive D0/D1 recommendations + explanation + inputs used GATE 5 · inspectable, local

Session thread. Gate 1–5 are binary: if a gate fails, the session stops at that point.

Share and revoke thread The owner selects JSON paths, Wizy builds a projection without personal data, Authy signs a grant, the projection is pushed encrypted to a peer, social publication is opt-in, and revocation stops future pulls. User Wizy Authy Peer Nety choose JSON + recipients + paths build projection · P not selectable request signature + grant signed envelope direct encrypted push (local net) GATE 6 · only granted paths readable verify · store in their L cache publish S-only bundle · explicit consent GATE 7 · public by decision, not default revoke peer / shorten expiry notify next pull GATE 8 · future reads stop; copies remain

Share thread. The grant is signed by Authy; Wizy can never include a P path in a projection.

04

flovePortrait — the real case, two scales

This is the shipped envelope today. It stays exactly the same for apps and Appy; Browsy/Wizy add owner, class, grants and signatures around it.

today

The envelope (Goddy reference)

{
  "schema": "flove-portrait/1",
  "app": "goddy",
  "version": 1,
  "generatedAt": "…",
  "lang": "en",
  "phrase": "…",
  "rows": [
    { "key": "from:to", "kind": "cell",
      "title": "from → to", "items": ["2"] }
  ],
  "completeness": { "layers": 7, "total": 9 },
  "stats": { "count": 7, "intensity": 0.62, "max": 3 },
  "consent": { "share": "app",
    "purposes": ["self-reflection", "export"] },
  "source": { "url": "https://flove.org/apps/metas/goddy.html" }
}

API: get · validate · consult · merge · selfTest · toSummary · toAgent. Appy renders it; the file is still downloadable.

extension

What Browsy adds around it

  • Owner + bundle: owner, bundleId, version, signature.
  • Class: L by default; public slices become S only by consent.
  • Paths: documents.goddy.rows; grants can narrow to prefixes/slices.
  • Grants: grantee, paths, capability, expiry, encrypted content key.
  • Enforcement: consult(grant) intersects the grant with consent.purposes.
  • Audit: pull/share/deny log local to Browsy.
flovePortrait scale 1 — one portrait, one device Goddy produces the flove-portrait/1 document. The file can still be downloaded as today, and Wizy inside Browsy also wraps it as a class L document in the encrypted vault. Appy renders the same portrait through a permissioned view from Browsy. SCALE 1 · GODDY APP matrix model cells + levels flovePortrait.get() flove-portrait/1 existing path portrait file download · legacy share BROWSY · WIZY Wizy · wrap + class L owner · signature · grant capture vault encrypted P + L + M same portrait document, now inside a signed bundle the download path still works APPY renderer same flove-portrait/1 permissioned view view Appy asks Browsy, not the vault

Scale 1 · one portrait, one device. The app API does not change; the wrapper is additive.

flovePortrait scale 2 — the same portrait across the mesh The owner's bundle holds the Goddy portrait as class L with a grant to a peer. The peer's Browsy pulls it directly, decrypts and verifies it, merges it with their own private and local data, and derives a local recommendation. Nety only carries the public social slice if the owner publishes it. OWNER DEVICE bundle · goddy portrait class L · signed · version 3 rows + phrase + stats grant · peer A rows · view · expiry encrypted content key S slice = exported public fields only P + L never leave in plaintext revoke → version++ → next pull PEER A DEVICE Browsy + Wizy pull · verify · decrypt only granted paths direct grant merge P + L their private + granted local plus social S if enabled recommendation (D) stays local by default explainable · inspectable no vault access for the app NETY · SOCIAL S public slice public profile · posts public summaries no P/L plaintext WoT ranking, not access control optional S slice · consent S reads

Scale 2 · the same portrait across the mesh. The grant is the only bridge; Nety never sees L.

05

The flovePortrait API, explained

Every app exposes the same seven functions. They are the seam Browsy/Wizy hooks into; the app does not need to know about bundles or grants.

FunctionWhat it doesInput → outputWho calls it
get()Reads the live model and builds the portrait() → flove-portrait/1App UI, Browsy/Wizy capture
validate(payload)Checks schema, app id and rows(object) → {ok, errors[]}Appy import, Wizy, tests
consult(sel)Returns a filtered read-only view for a purpose({purpose, enforceConsent, from, to, kinds, group, maxItems}) → flove-consult/1Wizy projections, agents
merge(payload, opts)Writes a portrait back into the app(portrait, {mode}) → {ok, applied, mode}Import, restore, peer sync
selfTest()Runs get → validate → consult() → {ok, rows, consultRows, errors}?selftest, CI
toSummary()Returns the app's own summary model() → app modelAppy legacy, Wizy context
toAgent()Returns the agent block (prompt, schema, suggestions)() → floveAgentBlockMyWizy / Flove AI
What changes with Browsy: get stays; validate becomes the first gate; consult accepts a grant and returns only the intersection; merge only accepts a verified bundle; selfTest is the M1 acceptance test; toSummary/toAgent stay local unless their output is exported as D/L/S.
06

MyFamily — the first local data manager

MyFamily is the L use case of Browsy. Each person added is kept as P, L or S and used as L: P is private, L is shared with others locally (federated), S is public data. Permissions over a P2P network are another planned trunk.

P · private

Kept, not shared

The record — person id, name, relation, 7 trait groups with nuances, 5 raters, notes, subject-consent, version — encrypted in the vault.

L · used by default

Local federated

Chosen traits/raters shared with named peers or circles, with expiry, and only if the subject-consent state allows it.

S · public

Public card

A minimal separate artefact for the web-social path; never the raw record, nuances or children's data.

MyFamily is displayed as a use case on the browsy page ↗. Third-party questions B01–B10 are in browsy-questions.md; P2P permissions are a later trunk.

07

Authy — current ladder, extended

The Authenticate card in index.html has five bars: Self, Email, Telegram, Phone, Bio. In the risa model, Telegram presence is L2; a nonce + DM claim upgrades to L3 verified, the publish gate. linkIdentity() stores the key, awards Personal points and persists to flove:authy in localhost. From there the signed summary can be sent to local and (at L3) social keepers.

LevelProofAddsPublish SSign grants
L1 selflocal profileidentity rootnoyes (own)
L2 presenceTelegram linked (unclaimed); email also presencepresence profile, local sharingnoyes
L3 verifiedTelegram claim (nonce + DM)publish gateyesyes
L4 phoneSMS/call proofstronger recoveryyesyes
L5 biolocal biometric unlockhighest unlock baryesyes
Telegram also enables MyNet: appy-basic gates MyNet behind Telegram presence. MyNet is a simplification of MyFamily (person + relation + 2–3 traits + one affinity), stored as L. See the two diagrams in the Authy index.
Persistence: the Authy index and appy-basic share flove:authy/1 in localStorage; the same payload is what Browsy will store later. Displayed vs awarded points differ (+4/+12/+6/+8 vs 20/50/100/200). The Authy index ↗ shows both until one table wins (pending A03).
08

What is derived? — the options

“Derived” (D) is anything Wizy produces from inputs rather than copying. The options are deliberately separate so the user can choose how much computation — and exposure — is acceptable.

OptionWhereInputsLeaves deviceOutputShareableRisk
D0 · noneWizy in BrowsyP/L/S for merge + filteringNothingViews: what I see / what X seesOnly as L/S projectionLowest; over-sharing is the only leak
D1 · deterministic rulesWizy in BrowsyP + L + S, class-taggedNothingScores, matches, auditable explanationsD as L/S if exportedRule leakage / gaming
D2 · on-device modelWizy in Browsy (WASM/small)P + L + S or a de-identified subsetModel updates only, no payloadNatural-language adviceD as L/S if exportedDevice cost; prompt/log leakage
D3 · remote de-identifiedNety compute / approved serverD-only feature vector + queryDe-identified payloadRecommendation resultD as L/S if exportedInference; metadata; provider trust
D4 · remote encryptedNety node / enclave (future)Encrypted P/L payloadCiphertext onlyEncrypted result, decrypted locallyD as L/S if exportedEnclave trust; availability
D5 · peer-assistedPermitted peer's BrowsyOnly the granted L projectionThe granted projectionPeer's derived answerD unless exportedTrust + extra exposure

Others view — what another user can see or derive

OptionWhat it isExposureSuggested
O0 · raw projectionThe owner's signed view, filtered by the grantExactly the granted paths✅ v1 default
O1 · recomputed viewThe recipient's Wizy recomputes from granted LMore personalization, more inferenceOpt-in per relationship
O2 · social comparisonNety-ranked comparison using S onlyPublic/social onlyLater
Defaults proposed: D0/D1 locally, D2 optional on-device, D3 per-request consent, D4 future, D5 experimental; others view = O0.
09

Milestones — specified

IDMilestoneGoal + deliverablesEntryPrivacy gate / acceptance test
M0Spec & taxonomyClassify every field P/L/S/D/M; grant schema v0; invariants; threat model v0Reviewed doc; Q1–Q3No unclassified field; every shipped JSON mapped; invariants signed off
M1Browsy shell + Wizy localMV3 shell; Wizy workspace; bundle read/write; portrait wrapping; import/export; class tags; no networkM0Goddy portrait round-trips unchanged; P cannot be selected for export; vault refuses plaintext writes
M2Authy + vaultEd25519 root; passphrase/WebAuthn unlock; encrypted vault; signed bundles; grants; recovery startM1Tampered bundle rejected; wrong passphrase reveals nothing; rotation keeps grants valid
M3Local net L pullsPeer discovery option; transport; deltas; verify/decrypt; revoke; offline queue; local auditM2; Q3Two browsers exchange only granted paths; revoke stops next pull; zero Nety traffic for L
M4Nety social SOpt-in social toggle; S schema/validation; signed reads; gateway prerequisiteM3; Nety gateway wired (currently not)S contains no P/L; toggle off = zero Nety calls; publish requires consent
M5Derivations + others viewD0/D1 built; D2 spike; D3 consent flow; O0 projection; explanation UIM4; Q7–Q8Default run fully offline; D3 shows exactly what leaves; O0 shows only granted paths
M6Hardening + overwriteThreat review; a11y/mobile; docs; rewrite index P2P/Wizy/Nety; retire superseded plansM5External checklist; no open critical privacy bug; Chrome + Firefox usable
M7Usability passesOnboarding; grant editor; explanation readability; error states; measured tasksFirst 3 real peers on M3+Time-to-share and task success measured; no privacy setting hidden behind a default
Every milestone ends with a usability pass; only M7 turns them into measured goals. Privacy gates are binary: no gate, no next milestone.
10

The 10 questions

Q1 · P/L/S field by field

Map every shipped JSON and app field to a class; default for new fields.

Suggested: P unless listed; L for portraits; S only for already-public fields.

Q2 · Permission unit

File, JSON path, array slice or field — one unit for v1 and the grant schema.

Suggested: JSON path with array ranges; fields later.

Q3 · Local net discovery

QR/endpoint, LAN, WebRTC, or Nety DHT for addresses only.

Suggested: manual endpoint + signature first; WebRTC second; never L over Nety.

Q4 · Revocation guarantee

TTL, rotation, no-copy, UI wording, re-encryption.

Suggested: forward-only; short TTL; rotate keys on removal.

Q5 · Supersafe bar

Unlock factor, at-rest format, memory rules, encrypted backup.

Suggested: WebAuthn + passphrase; P only in Browsy/Wizy memory.

Q6 · Authy identity set

Channels, levels, sessions, masks, recovery, Nety PeerId binding.

Suggested: Ed25519 root + proofs; self-backup; social quorum fallback.

Q7 · Derivation first

D0/D1 first, D2 spike, D3 consent; explanation; shareability.

Suggested: local by default; D3 per request; D4/D5 later.

Q8 · Others view

Projection vs recomputation; signer; inference; consent.

Suggested: O0 signed projection; O1 opt-in; O2 later.

Q9 · Bundle schema

Envelope, documents, consent, signature scope, portrait compatibility.

Suggested: flove-bundle/0.1; portraits in documents[]; Authy signs.

Q10 · Offline sync

Deltas, vector clocks/CRDT, tombstones, TTL, conflict display.

Suggested: bundle version + vector clock; last signed snapshot; surface staleness.

11

The privacy rules, kept

Invariants

  • P never leaves unencrypted; no P in an S bundle.
  • L leaves only as an encrypted projection under a signed grant.
  • S contains no P by construction.
  • Every outbound byte traces to a grant (local audit log).
  • Defaults private; widening is explicit.
  • Revocation is forward-only; copies cannot be recalled.
  • Every received document is signed and verified.
  • Wizy computes locally by default; remote needs consent.
  • Nety does not learn who pulls from whom locally.
  • Linking a channel never re-derives identity keys.

Threats still open

  • Coerced unlock and memory scraping.
  • Authorized peer who leaks on purpose.
  • Unrecallable copies after revocation.
  • Extension supply chain / store compromise.
  • XSS on flove.org reaching the bridge.
  • Metadata graph visible to Nety nodes.
  • Inference and model inversion from D3/D2.
  • Hijacked social recovery quorum.
  • Usability pressure producing over-broad grants.