@oortmem/core 0.3.0 → 0.5.0

package/dist/grant.js

@@ -1,4 +1,10 @@
 import { addressOf, assertNode, authorOf, nodeKey, nodeOf, planetOf, sameAddress, sameAuthor, } from './address.js';
+/**
+ * The agent id of a caller that named no agent (an MCP entry written before agents existed, a
+ * terminal without `--agent`). It reads and writes the person's Planet only: it has no Star, so
+ * it can neither see nor create one. No configured agent may use this id.
+ */
+export const ANONYMOUS_AGENT = 'anonymous';
 /**
  * The permission every `MemoryStore` method takes. Opaque: built only by
  * `localGrant`, `principalGrant` or `nodeGrant`, frozen, and nominal, so a raw
@@ -21,10 +27,18 @@ export class Grant {
     write;
     readNodes;
     writeNodes;
-    constructor(principal, readNodes, writeNodes) {
+    /**
+     * The node new memories are written to (the home node): the principal's
+     * Planet unless the agent keeps a Star. Engine code that creates a memory
+     * (observe, remember) addresses it here; edits of existing memories keep
+     * their own address. Covered by `writeNodes` whenever they are not empty.
+     */
+    home;
+    constructor(principal, readNodes, writeNodes, home) {
         this.principal = Object.freeze({ ...principal });
         this.readNodes = Object.freeze(readNodes.map(freezePattern));
         this.writeNodes = Object.freeze(writeNodes.map(freezePattern));
+        this.home = Object.freeze(homeNode(principal, this.writeNodes, home));
         this.read = Object.freeze({
             ...principal,
             projectIds: legacyProjects(principal, this.readNodes),
@@ -36,14 +50,27 @@ export class Grant {
         Object.freeze(this);
     }
     /** @internal Use `localGrant` or `principalGrant`. */
-    static issue(principal, read, write) {
+    static issue(principal, read, write, home = 'planet') {
         checkPrincipal(principal);
-        return new Grant(principal, [ownPlanet(principal, read)], [ownPlanet(principal, write)]);
+        const anonymous = principal.agentId === ANONYMOUS_AGENT;
+        if (anonymous && home === 'star')
+            throw new RangeError('grant: an anonymous agent has no Star');
+        const readSide = anonymous
+            ? [ownPlanet(principal, read)]
+            : [ownPlanet(principal, read), ownStar(principal, read)];
+        // An agent whose home is its Star may read the shared Planet but never change it: its writes
+        // (new memories, forget, pin, tiers, confirmations) stay in its Star.
+        const writeSide = home === 'star'
+            ? [ownStar(principal, write)]
+            : anonymous
+                ? [ownPlanet(principal, write)]
+                : [ownPlanet(principal, write), ownStar(principal, write)];
+        return new Grant(principal, readSide, writeSide, home === 'star' ? starNode(principal) : planetNode(principal));
     }
-    /** @internal Use `nodeGrant`. */
-    static issueNodes(principal, read, write) {
+    /** @internal Use `nodeGrant` or `narrowGrant`. */
+    static issueNodes(principal, read, write, home) {
         checkPrincipal(principal);
-        return new Grant(principal, read, write);
+        return new Grant(principal, read, write, home);
     }
     /** True for a real grant (not a copy, not a look-alike). */
     static is(x) {
@@ -57,13 +84,41 @@ function checkPrincipal(principal) {
         }
     }
 }
-/** The pre-level grant side: the principal's own Planet, written by its own agent. */
+/**
+ * The local grant side's Planet: the principal's own Planet, whichever of the
+ * person's agents wrote the memory (CON-62; before it, the pattern was
+ * restricted to the principal's own agent).
+ */
 function ownPlanet(p, projectIds) {
-    return {
-        node: { level: 'user', orgId: p.orgId, customerId: p.customerId },
-        projectIds,
-        authorAgentId: p.agentId,
-    };
+    return { node: planetNode(p), projectIds };
+}
+/** The principal's agent's own Star: private to that agent, never another's. */
+function ownStar(p, projectIds) {
+    return { node: starNode(p), projectIds };
+}
+/** The Star of a principal's agent (owned by the principal's owner). */
+export function starNode(p) {
+    return { level: 'agent', orgId: p.orgId, agentId: p.agentId };
+}
+/**
+ * `home` checked against the write side, or the default: the principal's
+ * Planet when the write side names it, else the first node written, else the
+ * Planet (a read-only grant writes nothing anyway).
+ */
+function homeNode(p, write, home) {
+    if (home !== undefined) {
+        assertNode(home);
+        const { level: _l, ...rest } = home;
+        const node = { level: home.level, ...rest };
+        if (write.length > 0 && !write.some((w) => nodeKey(w.node) === nodeKey(node))) {
+            throw new RangeError('grant: home must be a node the grant writes');
+        }
+        return node;
+    }
+    const planet = planetNode(p);
+    if (write.length === 0 || write.some((w) => nodeKey(w.node) === nodeKey(planet)))
+        return planet;
+    return write[0].node;
 }
 function freezePattern(p) {
     if (typeof p !== 'object' || p === null)
@@ -83,12 +138,13 @@ function freezePattern(p) {
 }
 /**
  * The projects of `patterns` that a pre-level reader may assume: those of
- * patterns naming exactly the principal's Planet, restricted to its agent.
- * Never wider than the patterns themselves.
+ * patterns naming exactly the principal's Planet and covering its agent's
+ * writing (no author restriction, or that agent). Never wider than the
+ * patterns themselves.
  */
 function legacyProjects(p, patterns) {
     const own = nodeKey({ level: 'user', orgId: p.orgId, customerId: p.customerId });
-    const mine = patterns.filter((x) => x.authorAgentId === p.agentId && nodeKey(x.node) === own);
+    const mine = patterns.filter((x) => (x.authorAgentId === undefined || x.authorAgentId === p.agentId) && nodeKey(x.node) === own);
     if (mine.some((x) => x.projectIds === 'all'))
         return 'all';
     return Object.freeze([
@@ -111,9 +167,17 @@ function samePrincipal(a, b) {
     return a.orgId === b.orgId && a.customerId === b.customerId && a.agentId === b.agentId;
 }
 /**
- * The grant for today's single-principal callers: read exactly what `read`
- * names (a one-node grant), and write the same unless `opts.write` narrows it.
- * `write` must name the same principal as `read`.
+ * The grant for one agent of one person (CON-62): read and write the
+ * person's Planet (memories any of their agents wrote) and this agent's own
+ * Star, in the projects `read` names; `opts.write` may narrow the write side.
+ * Another agent's Star is never covered. `opts.home` picks where new memories
+ * land: the Planet (default) or the agent's Star; with `star` the Planet is
+ * read-only (the agent writes only its Star). `ANONYMOUS_AGENT` gets the
+ * Planet alone. `write` must name the same principal as `read`.
+ *
+ * Before CON-62 the Planet side was restricted to memories the principal's
+ * own agent wrote. Every local memory so far was written as `claude-code`,
+ * so a local store sees exactly what it saw; nothing is rewritten.
  */
 export function localGrant(read, opts = {}) {
     const write = opts.write ?? read;
@@ -124,11 +188,15 @@ export function localGrant(read, opts = {}) {
     if (!samePrincipal(read, write)) {
         throw new RangeError('localGrant: read and write must name the same org, customer and agent');
     }
-    return Grant.issue(read, read.projectIds, write.projectIds);
+    return Grant.issue({ orgId: read.orgId, customerId: read.customerId, agentId: read.agentId }, read.projectIds, write.projectIds, opts.home);
 }
-/** Every project of `p` (and its global memories), for read and write: maintenance such as export. */
-export function principalGrant(p) {
-    return Grant.issue(p, 'all', 'all');
+/**
+ * Every project of `p` (and its global memories), for read and write:
+ * maintenance such as export. Covers the same nodes as `localGrant`: the
+ * person's Planet and this agent's own Star.
+ */
+export function principalGrant(p, opts = {}) {
+    return Grant.issue({ orgId: p.orgId, customerId: p.customerId, agentId: p.agentId }, 'all', 'all', opts.home);
 }
 /**
  * A grant over explicit node patterns, possibly across owners and levels:
@@ -142,7 +210,37 @@ export function nodeGrant(opts) {
     if (!Array.isArray(opts.read) || (opts.write !== undefined && !Array.isArray(opts.write))) {
         throw new TypeError('nodeGrant: read and write must be arrays of node patterns');
     }
-    return Grant.issueNodes(opts.principal, opts.read, opts.write ?? opts.read);
+    return Grant.issueNodes(opts.principal, opts.read, opts.write ?? opts.read, opts.home);
+}
+/**
+ * `g` narrowed to the nodes `keep` names (by `nodeKey`), on both sides: the
+ * grant recall uses for one node's first stage. Never wider than `g`. The
+ * home stays when it is kept, else the default for what remains.
+ */
+export function narrowGrant(g, keep) {
+    assertGrant(g);
+    const keys = new Set(keep.map((n) => nodeKey(n)));
+    const read = g.readNodes.filter((p) => keys.has(nodeKey(p.node)));
+    const write = g.writeNodes.filter((p) => keys.has(nodeKey(p.node)));
+    const home = write.some((p) => nodeKey(p.node) === nodeKey(g.home)) ? g.home : undefined;
+    return Grant.issueNodes(g.principal, read, write, home);
+}
+/** The distinct nodes `g` reads, in the order its patterns name them. */
+export function readableNodes(g) {
+    assertGrant(g);
+    const seen = new Map();
+    for (const p of g.readNodes)
+        if (!seen.has(nodeKey(p.node)))
+            seen.set(nodeKey(p.node), p.node);
+    return [...seen.values()];
+}
+/** The address a new memory gets under `g`: its home node, bound to `projectId` when given. */
+export function homeAddress(g, projectId) {
+    assertGrant(g);
+    return {
+        ...g.home,
+        ...(projectId !== undefined && { projectId }),
+    };
 }
 /** Rejects anything that is not a real `Grant`; every store calls it first. */
 export function assertGrant(g) {

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "0.3.0";
+export declare const VERSION = "0.5.0";
 export * from './model.js';
 export * from './address.js';
 export * from './export-format.js';
@@ -8,6 +8,8 @@ export * from './activation.js';
 export * from './adapters.js';
 export * from './embed-cache.js';
 export * from './grant.js';
+export * from './levels.js';
+export * from './agents.js';
 export * from './fusion.js';
 export * from './memory-store.js';
 export * from './tokenize.js';

package/dist/index.js

@@ -1,4 +1,4 @@
-export const VERSION = '0.3.0';
+export const VERSION = '0.5.0';
 export * from './model.js';
 export * from './address.js';
 export * from './export-format.js';
@@ -8,6 +8,8 @@ export * from './activation.js';
 export * from './adapters.js';
 export * from './embed-cache.js';
 export * from './grant.js';
+export * from './levels.js';
+export * from './agents.js';
 export * from './fusion.js';
 export * from './memory-store.js';
 export * from './tokenize.js';

package/dist/isolation.d.ts

@@ -10,8 +10,14 @@ import { type Grant } from './grant.js';
 import type { Memory, Scope } from './model.js';
 /** A memory for the isolation checks: text, stub and entities all carry `marker`. */
 export declare function isoMemory(id: string, scope: Scope, marker: string, embedding?: Int8Array): Memory;
-/** The narrowest grant for one scope (its principal and its one project or global). */
+/**
+ * The narrowest grant for one scope: its Planet, its one project (or global),
+ * memories its own agent wrote. (The pre-CON-62 local grant; today's
+ * `localGrant` also covers the Planet's other authors and the agent's Star.)
+ */
 export declare function soleGrant(s: Scope): Grant;
+/** The local grant of `ISO_SCOPES.mine`'s agent for its one project: Planet plus its own Star. */
+export declare function defaultGrant(s: Scope): Grant;
 /** The narrowest grant for one memory at any level: its node, its one project, its author. */
 export declare function soleGrantFor(m: Pick<Memory, 'scope' | 'address' | 'author'>): Grant;
 /** `m` moved to `scope`: its address and author dropped, so the scope's Planet is the address. */
@@ -59,13 +65,20 @@ export declare const ISO_SCOPES: {
 /**
  * Victims at the other levels, each next to the caller's own Planet: a Planet
  * memory another of the caller's agents wrote, the caller's agent's own Star,
- * an Orbit, a Flyby, a Constellation and a Galaxy root of an organisation, and
- * one of the caller's own owner. A pre-level grant sees none of them.
+ * another agent's Star (in the caller's project and global), an Orbit, a
+ * Flyby, a Constellation and a Galaxy root of an organisation, and one of the
+ * caller's own owner. The narrowest grant sees none of them; the local grant
+ * sees only those in `DEFAULT_COVERS`.
  */
 export declare const ISO_LEVELS: Record<string, {
     address: Address;
     author: Author;
 }>;
+/**
+ * The victims the local grant of `ISO_SCOPES.mine` legitimately covers (CON-62): Planet memories
+ * the person's other agents wrote, and its agent's own Star. Never another agent's Star.
+ */
+export declare const DEFAULT_COVERS: readonly string[];
 /**
  * Every `MemoryStore` method, called with a grant for `ISO_SCOPES.mine`
  * against memories (warm and cold) in each other scope: nothing is seen,
@@ -73,6 +86,10 @@ export declare const ISO_LEVELS: Record<string, {
  * apart. Also the write-side rules (`GrantError` for an out-of-grant scope
  * and for an id that exists elsewhere, atomic batches, address changes),
  * read/write splits, cursor namespaces and rejection of non-grants.
+ *
+ * Run twice: as the narrowest grant (every victim out of reach), and as the
+ * local grant (`localGrant`, Planet plus own Star), for which every victim
+ * but `DEFAULT_COVERS` is out of reach, other agents' Stars included.
  */
 export declare function isolationViolations(make: () => Promise<MemoryStore>): Promise<string[]>;
 /** A small seeded PRNG (mulberry32), so a failing seed replays exactly. */
@@ -94,7 +111,13 @@ export declare function seededRng(seed: number): {
  * `multiNode`: A's grant spans its Planet, its agent's Star and a
  * Constellation of another owner; B's spans its own Planet and a sibling
  * Constellation. Same property.
+ *
+ * `peers` (CON-62): A and B are two agents of one person, each with the local
+ * grant (the shared Planet plus its own Star). A writes to the Planet and its
+ * Star; B writes only to its own Star and aims every method at A's Star ids.
+ * Nothing B does through its Star reaches A.
  */
 export declare function nonInterference(make: () => Promise<MemoryStore>, seed: number, steps: number, opts?: {
     multiNode?: boolean;
+    peers?: boolean;
 }): Promise<string | null>;

package/dist/isolation.js

@@ -34,8 +34,25 @@ export function isoMemory(id, scope, marker, embedding) {
     };
 }
 const principal = (s) => ({ orgId: s.orgId, customerId: s.customerId, agentId: s.agentId });
-/** The narrowest grant for one scope (its principal and its one project or global). */
+/**
+ * The narrowest grant for one scope: its Planet, its one project (or global),
+ * memories its own agent wrote. (The pre-CON-62 local grant; today's
+ * `localGrant` also covers the Planet's other authors and the agent's Star.)
+ */
 export function soleGrant(s) {
+    return nodeGrant({
+        principal: principal(s),
+        read: [
+            {
+                node: { level: 'user', orgId: s.orgId, customerId: s.customerId },
+                projectIds: [s.projectId ?? null],
+                authorAgentId: s.agentId,
+            },
+        ],
+    });
+}
+/** The local grant of `ISO_SCOPES.mine`'s agent for its one project: Planet plus its own Star. */
+export function defaultGrant(s) {
     return localGrant({ ...principal(s), projectIds: [s.projectId ?? null] });
 }
 /** The narrowest grant for one memory at any level: its node, its one project, its author. */
@@ -92,8 +109,10 @@ const ISO_PRINCIPAL = { orgId: 'local', customerId: 'self', agentId: 'claude-cod
 /**
  * Victims at the other levels, each next to the caller's own Planet: a Planet
  * memory another of the caller's agents wrote, the caller's agent's own Star,
- * an Orbit, a Flyby, a Constellation and a Galaxy root of an organisation, and
- * one of the caller's own owner. A pre-level grant sees none of them.
+ * another agent's Star (in the caller's project and global), an Orbit, a
+ * Flyby, a Constellation and a Galaxy root of an organisation, and one of the
+ * caller's own owner. The narrowest grant sees none of them; the local grant
+ * sees only those in `DEFAULT_COVERS`.
  */
 export const ISO_LEVELS = {
     planetOtherAuthor: {
@@ -104,6 +123,14 @@ export const ISO_LEVELS = {
         address: { level: 'agent', orgId: 'local', agentId: 'claude-code', projectId: 'pa' },
         author: { agentId: 'claude-code' },
     },
+    otherStar: {
+        address: { level: 'agent', orgId: 'local', agentId: 'cursor', projectId: 'pa' },
+        author: { agentId: 'cursor' },
+    },
+    otherStarGlobal: {
+        address: { level: 'agent', orgId: 'local', agentId: 'cursor' },
+        author: { agentId: 'cursor' },
+    },
     orbit: {
         address: { level: 'agent-user', orgId: 'local', agentId: 'claude-code', customerId: 'self' },
         author: { agentId: 'claude-code' },
@@ -132,6 +159,15 @@ export const ISO_LEVELS = {
         author: { agentId: 'claude-code' },
     },
 };
+/**
+ * The victims the local grant of `ISO_SCOPES.mine` legitimately covers (CON-62): Planet memories
+ * the person's other agents wrote, and its agent's own Star. Never another agent's Star.
+ */
+export const DEFAULT_COVERS = Object.freeze([
+    'otherAgent',
+    'planetOtherAuthor',
+    'star',
+]);
 /**
  * Every `MemoryStore` method, called with a grant for `ISO_SCOPES.mine`
  * against memories (warm and cold) in each other scope: nothing is seen,
@@ -139,6 +175,10 @@ export const ISO_LEVELS = {
  * apart. Also the write-side rules (`GrantError` for an out-of-grant scope
  * and for an id that exists elsewhere, atomic batches, address changes),
  * read/write splits, cursor namespaces and rejection of non-grants.
+ *
+ * Run twice: as the narrowest grant (every victim out of reach), and as the
+ * local grant (`localGrant`, Planet plus own Star), for which every victim
+ * but `DEFAULT_COVERS` is out of reach, other agents' Stars included.
  */
 export async function isolationViolations(make) {
     const out = [];
@@ -176,62 +216,12 @@ export async function isolationViolations(make) {
             }
         }
         const snapshot = async () => Promise.all(victims.map(async (v) => `${render(await store.get(v.g, v.m.id))}|${render(await store.coldGet(v.g, v.m.id))}`));
-        const before = await snapshot();
-        for (const v of victims) {
-            const id = v.m.id;
-            const fail = (what) => out.push(`${v.name}: ${what}`);
-            if ((await store.get(mine, id)) !== null)
-                fail('get returned it');
-            if ((await store.coldGet(mine, id)) !== null)
-                fail('coldGet returned it');
-            const lex = await store.lexical(mine, 'shared canary', 50);
-            if (lex.some((h) => h.id === id))
-                fail('lexical returned it');
-            const den = await store.dense(mine, v.m.embedding ?? vec(1), 50);
-            if (den.some((h) => h.id === id))
-                fail('dense returned it');
-            for (const validOnly of [true, false]) {
-                if ((await store.list(mine, { validOnly })).some((m) => m.id === id))
-                    fail('list returned it');
-            }
-            await store.recordAccess(mine, [id], new Date(NOW));
-            if ((await store.setTier(mine, id, 'hot')) !== false)
-                fail('setTier reported a write');
-            if ((await store.setTier(mine, id, 'hot', v.m)) !== false)
-                fail('guarded setTier reported a write');
-            const exp = await store.expireMany(mine, [v.m], new Date(NOW));
-            if (!exp.skipped.includes(id))
-                fail('expireMany did not skip it');
-            for (const r of [await store.coldPut(mine, v.m), await store.coldPutMany(mine, [v.m])]) {
-                if (!r.skipped.includes(id))
-                    fail('coldPut did not skip it');
-            }
-            await store.forget(mine, id);
-            const direct = await settle(store.upsert(mine, v.m));
-            if (!('err' in direct) || !(direct.err instanceof GrantError)) {
-                fail('upsert of its own scope was not refused with GrantError');
-            }
-            const moved = await settle(store.upsert(mine, movedTo(v.m, ISO_SCOPES.mine)));
-            if (!('err' in moved) || !(moved.err instanceof GrantError)) {
-                fail('upsert moving its id into my scope was not refused with GrantError');
-            }
-            else if ('err' in direct &&
-                direct.err.message !== moved.err.message) {
-                fail('the two refusals have different messages');
-            }
-            const batch = await settle(store.upsertMany(mine, [
-                isoMemory(`batch-${id}`, ISO_SCOPES.mine, 'batch'),
-                movedTo(v.m, ISO_SCOPES.mine),
-            ]));
-            if (!('err' in batch))
-                fail('a batch reaching it was not refused');
-            if ((await store.get(mine, `batch-${id}`)) !== null)
-                fail('a refused batch wrote part of itself');
-        }
-        const after = await snapshot();
-        for (const [i, v] of victims.entries()) {
-            if (before[i] !== after[i])
-                out.push(`${v.name}: changed through a grant that cannot see it`);
+        for (const [caller, grant, covered] of [
+            ['narrowest', mine, []],
+            ['local', defaultGrant(ISO_SCOPES.mine), DEFAULT_COVERS],
+        ]) {
+            const reach = victims.filter((v) => !covered.some((c) => v.name === `victim-${c}-warm` || v.name === `victim-${c}-cold`));
+            out.push(...(await victimViolations(store, caller, grant, reach, snapshot, victims)));
         }
         // An address change of my own record is refused too, and leaves it as it was.
         const own = await store.get(mine, 'mine-1');
@@ -312,6 +302,68 @@ export async function isolationViolations(make) {
     }
     return out;
 }
+/** One caller's pass over the victims it must not reach: nothing seen, nothing changed. */
+async function victimViolations(store, caller, mine, victims, snapshot, all) {
+    const out = [];
+    const vec = (n) => Int8Array.from([n, 1, 1, 1]);
+    const before = await snapshot();
+    for (const v of victims) {
+        const id = v.m.id;
+        const fail = (what) => out.push(`${caller}: ${v.name}: ${what}`);
+        if ((await store.get(mine, id)) !== null)
+            fail('get returned it');
+        if ((await store.coldGet(mine, id)) !== null)
+            fail('coldGet returned it');
+        const lex = await store.lexical(mine, 'shared canary', 50);
+        if (lex.some((h) => h.id === id))
+            fail('lexical returned it');
+        const den = await store.dense(mine, v.m.embedding ?? vec(1), 50);
+        if (den.some((h) => h.id === id))
+            fail('dense returned it');
+        for (const validOnly of [true, false]) {
+            if ((await store.list(mine, { validOnly })).some((m) => m.id === id))
+                fail('list returned it');
+        }
+        await store.recordAccess(mine, [id], new Date(NOW));
+        if ((await store.setTier(mine, id, 'hot')) !== false)
+            fail('setTier reported a write');
+        if ((await store.setTier(mine, id, 'hot', v.m)) !== false)
+            fail('guarded setTier reported a write');
+        const exp = await store.expireMany(mine, [v.m], new Date(NOW));
+        if (!exp.skipped.includes(id))
+            fail('expireMany did not skip it');
+        for (const r of [await store.coldPut(mine, v.m), await store.coldPutMany(mine, [v.m])]) {
+            if (!r.skipped.includes(id))
+                fail('coldPut did not skip it');
+        }
+        await store.forget(mine, id);
+        const direct = await settle(store.upsert(mine, v.m));
+        if (!('err' in direct) || !(direct.err instanceof GrantError)) {
+            fail('upsert of its own scope was not refused with GrantError');
+        }
+        const moved = await settle(store.upsert(mine, movedTo(v.m, ISO_SCOPES.mine)));
+        if (!('err' in moved) || !(moved.err instanceof GrantError)) {
+            fail('upsert moving its id into my scope was not refused with GrantError');
+        }
+        else if ('err' in direct && direct.err.message !== moved.err.message) {
+            fail('the two refusals have different messages');
+        }
+        const batch = await settle(store.upsertMany(mine, [
+            isoMemory(`batch-${id}`, ISO_SCOPES.mine, 'batch'),
+            movedTo(v.m, ISO_SCOPES.mine),
+        ]));
+        if (!('err' in batch))
+            fail('a batch reaching it was not refused');
+        if ((await store.get(mine, `batch-${id}`)) !== null)
+            fail('a refused batch wrote part of itself');
+    }
+    const after = await snapshot();
+    for (const [i, v] of all.entries()) {
+        if (before[i] !== after[i])
+            out.push(`${caller}: ${v.name}: changed through a grant that cannot see it`);
+    }
+    return out;
+}
 /** A small seeded PRNG (mulberry32), so a failing seed replays exactly. */
 export function seededRng(seed) {
     let a = seed >>> 0;
@@ -336,7 +388,10 @@ const WORDS = ['orbit', 'comet', 'nebula', 'pulsar', 'quasar', 'photon', 'kuiper
  * keys (callers use UUIDs), so a tenant that reuses another tenant's id is
  * refused, which is a collision, not a leak of content.
  */
-function opSequence(seed, steps, multiNode) {
+function opSequence(seed, steps, mode) {
+    if (mode === 'peers')
+        return peerSequence(seed, steps);
+    const multiNode = mode === 'multi';
     const rng = seededRng(seed);
     const planetA = ['pa', 'pa2', null].map((projectId) => (id, t, e) => isoMemory(id, projectId === null ? ISO_SCOPES.global : { ...ISO_SCOPES.mine, projectId }, t, e));
     // With multiNode, A also reads and writes a Constellation of another owner and its
@@ -453,6 +508,107 @@ function opSequence(seed, steps, multiNode) {
     }
     return ops;
 }
+/**
+ * Two agents of one person (see `nonInterference`'s `peers`): A is `claude-code`, B is `cursor`,
+ * each with its local grant over projects pa, pa2 and global.
+ */
+function peerSequence(seed, steps) {
+    const rng = seededRng(seed);
+    const person = { orgId: 'local', customerId: 'self' };
+    const projects = ['pa', 'pa2', null];
+    const aGrant = localGrant({ ...person, agentId: 'claude-code', projectIds: [...projects] });
+    const bGrant = localGrant({ ...person, agentId: 'cursor', projectIds: [...projects] });
+    const star = (agentId, projectId) => ({
+        level: 'agent',
+        orgId: 'local',
+        agentId,
+        ...(projectId !== null && { projectId }),
+    });
+    const ops = [];
+    const aIds = [];
+    const aStarIds = [];
+    const bIds = [];
+    const text = () => `${rng.pick(WORDS)} ${rng.pick(WORDS)} ${rng.pick(WORDS)}`;
+    const emb = () => Int8Array.from([rng.int(9) - 4, rng.int(9) - 4, rng.int(9) - 4, 1]);
+    for (let i = 0; i < steps; i++) {
+        const who = rng.int(2) === 0 ? 'A' : 'B';
+        const grant = who === 'A' ? aGrant : bGrant;
+        const own = who === 'A' ? aIds : bIds;
+        // B aims at A's Star ids half the time (A's Planet is B's to share); A only at its own.
+        const target = () => who === 'B' && aStarIds.length > 0 && rng.int(2) === 0
+            ? rng.pick(aStarIds)
+            : own.length > 0
+                ? rng.pick(own)
+                : 'none';
+        const kind = rng.int(12);
+        if (kind <= 2 || own.length === 0) {
+            const id = `${who}-${i}`;
+            own.push(id);
+            const projectId = rng.pick(projects);
+            let m;
+            if (who === 'B') {
+                m = isoAt(id, star('cursor', projectId), { agentId: 'cursor' }, text(), emb());
+            }
+            else if (rng.int(2) === 0) {
+                aStarIds.push(id);
+                m = isoAt(id, star('claude-code', projectId), { agentId: 'claude-code' }, text(), emb());
+            }
+            else {
+                const scope = {
+                    ...person,
+                    agentId: 'claude-code',
+                    ...(projectId !== null && { projectId }),
+                };
+                m = isoMemory(id, scope, text(), emb());
+            }
+            const salted = { ...m, salience: rng.int(10) / 10 };
+            ops.push({ who, run: (s) => s.upsert(grant, salted) });
+        }
+        else if (kind === 3) {
+            const id = target();
+            ops.push({ who, run: async (s) => render(await s.get(grant, id)) });
+        }
+        else if (kind === 4) {
+            const q = text();
+            ops.push({ who, run: async (s) => (await s.lexical(grant, q, 100)).map((h) => h.id).sort() });
+        }
+        else if (kind === 5) {
+            const v = emb();
+            ops.push({ who, run: async (s) => s.dense(grant, v, 5) });
+        }
+        else if (kind === 6) {
+            ops.push({ who, run: async (s) => (await s.list(grant, { validOnly: false })).map(render) });
+        }
+        else if (kind === 7) {
+            const id = target();
+            ops.push({
+                who,
+                run: async (s) => {
+                    const m = await s.get(grant, id);
+                    return m === null ? 'none' : s.coldPut(grant, m);
+                },
+            });
+        }
+        else if (kind === 8) {
+            const id = target();
+            ops.push({ who, run: async (s) => render(await s.coldGet(grant, id)) });
+        }
+        else if (kind === 9) {
+            const id = target();
+            const tier = rng.pick(['hot', 'warm']);
+            ops.push({ who, run: (s) => s.setTier(grant, id, tier) });
+        }
+        else if (kind === 10) {
+            const ids = [target(), target()];
+            ops.push({ who, run: (s) => s.recordAccess(grant, ids, new Date(NOW)) });
+        }
+        else {
+            const id = target();
+            ops.push({ who, run: (s) => s.forget(grant, id) });
+        }
+    }
+    return ops;
+}
 /**
  * Non-interference: tenant A's observable results (return values, errors,
  * order and scores) are the same whether or not tenant B ran its operations
@@ -467,9 +623,14 @@ function opSequence(seed, steps, multiNode) {
  * `multiNode`: A's grant spans its Planet, its agent's Star and a
  * Constellation of another owner; B's spans its own Planet and a sibling
  * Constellation. Same property.
+ *
+ * `peers` (CON-62): A and B are two agents of one person, each with the local
+ * grant (the shared Planet plus its own Star). A writes to the Planet and its
+ * Star; B writes only to its own Star and aims every method at A's Star ids.
+ * Nothing B does through its Star reaches A.
  */
 export async function nonInterference(make, seed, steps, opts = {}) {
-    const ops = opSequence(seed, steps, opts.multiNode === true);
+    const ops = opSequence(seed, steps, opts.peers === true ? 'peers' : opts.multiNode === true ? 'multi' : 'single');
     const observe = async (withB) => {
         const s = await make();
         const seen = [];