docs+refactor(client): fidelity pass — id identity, drop connections, no faux-login, accurate NextGraph framing

Align the polyfill's surface and docs with the verified NextGraph reality and
remove application-level concepts:

- Identity is an ID, not a username: AccountRecord.id, shim predicate shim:id,
  normalizeId; accounts core becomes IdentityStore (set/clear/get) — the faux
  login/logout framing is gone (identity is set at wallet-import time).
- Relationship/connection is an application concept, not a platform primitive
  (NextGraph has no bilateral-connection primitive: grantee is unpersisted
  scaffolding, cap-send is unimplemented). Remove connections.ts; caps exposes
  only a directed grantRead(doc, granteeId) + a read-only protectedDocsOf(owner).
  Delete the now-dead isolation.ts social-visibility axis.
- Inbox docs: NextGraph has no separate curator — the recipient's own verifier
  unseals and applies each queued sealed message inline (process_inbox);
  inbox_post_link is a proposed/future API. Stop attributing the emulated
  curator to the platform.
- Read isolation reframed around the outcome: no cap -> empty union read;
  targeted read of an unheld repo -> RepoNotFound; cap introspection
  (canRead/governsRead) is emulation-only with no NextGraph API behind it.
- read-model.md corrected: the listing path is per-doc ANCHORED default-graph
  queries, never the anchorless GRAPH ?g union (that is O(wallet)); the probe
  section no longer claims the opposite.
- README recap table restructured (target | current NextGraph status | current
  emulation); INDEX_ACCOUNT documented as reservedAccount("index") in the
  sentinel namespace; de-domained generic-layer comments; softened tone.

Consumer application (Festipod) rewired separately to own the relationship
concept and feed the lib an id. Lib gates: bun test 83 pass / 0 fail, tsc clean.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

packages/client/test/isolation-active.test.ts

@@ -1,15 +1,18 @@
 /**
- * ReadCap ACTIVE (T03.h) — end-to-end proof that the emulated SDK enforces
- * per-DOCUMENT isolation, driven by per-entity documents + BILATERAL connections.
+ * ReadCap ACTIVE — end-to-end proof that the emulated SDK enforces per-DOCUMENT
+ * isolation, driven by per-entity documents + DIRECTED read grants.
  *
- * Mirrors exactly what the app does: create an entity document through the REAL
- * registry (`createEntityDoc`), declare its cap policy via
- * `getCaps().open(doc, scope, owner)`, set the current identity, and declare
- * connections as the CURRENT identity's own peers (authenticated, bilateral). The
- * read filter then discriminates:
- *   (a) unconnected principal denied a PROTECTED doc; granted after a BILATERAL
- *       connection; PUBLIC readable throughout — via the ACTIVE ReadCap.
- *   (b) a UNILATERAL / self-declared connection grants NOTHING.
+ * Mirrors what the app does: create an entity document through the REAL registry
+ * (`createEntityDoc`), declare its cap policy via `getCaps().open(doc, scope,
+ * owner)`, set the current identity, and — when the app decides two identities
+ * are related — issue a DIRECTED read grant on each of the owner's protected
+ * documents (`getCaps().grantRead(doc, granteeId)`). Whether identities are
+ * "connected" is the application's own concept: this test plays that role
+ * directly. The read filter then discriminates:
+ *   (a) an ungranted principal is denied a PROTECTED doc; granted once the owner
+ *       issues a directed grant; PUBLIC readable throughout — via the ACTIVE
+ *       ReadCap.
+ *   (b) no grant → no protected read (a reader cannot grant itself).
  */
 import { test, expect, mock, afterAll } from "bun:test";
 import { createEntityDoc, resetRegistryCache } from "../src/store-registry";
@@ -22,7 +25,6 @@ import {
   getCaps,
   resetCaps,
   setCurrentUser,
-  declareConnections,
 } from "../src/polyfill";
 import { filterReadable } from "../src/read-filter";
 
@@ -43,13 +45,19 @@ function inject() {
     sparql_query: mock(async () => ({ results: { bindings: [] } })),
   };
   configure({ ng: ng as any, useShape: (() => {}) as any });
-  configureStoreRegistry({ getSession: async () => SESSION, normalizeUser: (u) => u.trim() });
+  configureStoreRegistry({ getSession: async () => SESSION, normalizeId: (id) => id.trim() });
   resetRegistryCache();
   resetCaps();
   setCurrentUser(null);
   return ng;
 }
 
+/** The app's relationship concept, played inline: grant `reader` the read cap of
+ *  every protected document owned by `owner`. */
+function grantOwnerProtectedTo(owner: string, reader: string) {
+  for (const doc of getCaps().protectedDocsOf(owner)) getCaps().grantRead(doc, reader);
+}
+
 test("ReadCap active: a private entity doc created via the real registry is hidden from another principal", async () => {
   inject();
 
@@ -70,9 +78,9 @@ test("ReadCap active: a private entity doc created via the real registry is hidd
   expect(getCaps().hasReadPolicy()).toBe(true);
 });
 
-// (a) protected hidden while unconnected → revealed after a BILATERAL connection;
-//     public readable regardless — all through the ACTIVE ReadCap.
-test("(a) PROTECTED doc: hidden unconnected, revealed after BILATERAL connection, PUBLIC always readable", async () => {
+// (a) protected hidden while ungranted → revealed after a DIRECTED grant; public
+//     readable regardless — all through the ACTIVE ReadCap.
+test("(a) PROTECTED doc: hidden ungranted, revealed after a DIRECTED grant, PUBLIC always readable", async () => {
   inject();
 
   const aliceProtected = await createEntityDoc("alice", "protected");
@@ -86,22 +94,22 @@ test("(a) PROTECTED doc: hidden unconnected, revealed after BILATERAL connection
   ];
   const view = (u: string) => filterReadable(items, getCaps(), u).map((i) => i["@id"]).sort();
 
-  // BEFORE any connection: bob sees only the public item.
+  // BEFORE any grant: bob sees only the public item.
   expect(view("bob")).toEqual(["u1"]);
   expect(view("alice")).toEqual(["p1", "u1"]);
 
-  // BILATERAL: alice asserts bob AND bob asserts alice → the link materializes and
-  // the SDK issues the protected doc's read cap to bob.
-  declareConnections(["bob"], "alice");
-  declareConnections(["alice"], "bob");
+  // The app decides alice↔bob are related and grants bob the read cap of alice's
+  // protected documents.
+  grantOwnerProtectedTo("alice", "bob");
 
   expect(view("bob")).toEqual(["p1", "u1"]);
-  // A third, unconnected principal still sees only the public one.
+  // A third, ungranted principal still sees only the public one.
   expect(view("carol")).toEqual(["u1"]);
 });
 
-// (b) A UNILATERAL / self-declared connection must NOT grant protected read.
-test("(b) a UNILATERAL / self-declared connection grants NO protected read", async () => {
+// (b) An identity gets no protected read until the OWNER issues the grant — a
+//     reader cannot grant itself.
+test("(b) no directed grant → no protected read", async () => {
   inject();
 
   const aliceProtected = await createEntityDoc("alice", "protected");
@@ -109,15 +117,11 @@ test("(b) a UNILATERAL / self-declared connection grants NO protected read", asy
   const items = [{ "@graph": aliceProtected, "@id": "p1" }];
   const view = (u: string) => filterReadable(items, getCaps(), u).map((i) => i["@id"]);
 
-  // The ATTACKER (mallory) self-declares a connection to alice — a UNILATERAL
-  // assertion authored by mallory. Alice NEVER asserts mallory back.
-  declareConnections(["alice"], "mallory");
-  expect(view("mallory")).toEqual([]); // still denied — no bilateral link
+  // mallory holds no grant on alice's protected doc → denied.
+  expect(view("mallory")).toEqual([]);
 
-  // Even if alice connects to bob (a different, legitimate bilateral link),
-  // mallory's one-sided assertion still grants nothing.
-  declareConnections(["bob"], "alice");
-  declareConnections(["alice"], "bob");
+  // Granting bob (a different, legitimate reader) leaves mallory denied.
+  grantOwnerProtectedTo("alice", "bob");
   expect(view("mallory")).toEqual([]);
   expect(view("bob")).toEqual(["p1"]);
 });