@oortmem/core 0.3.0 → 0.4.0

package/dist/agents.d.ts

@@ -0,0 +1,38 @@
+import { ANONYMOUS_AGENT, type Home } from './grant.js';
+/**
+ * Agent identities on one machine (CON-62). Every host Oort is connected to
+ * acts as its own agent (`claude-code`, `codex`, `cursor`, …): they share the
+ * person's Planet, and each has a Star of its own that no other agent reads.
+ * An agent configured as a Star (`oort connect cursor --star`) writes new
+ * memories to its Star instead of the Planet. The configuration lives in
+ * `$OORT_HOME/agents.json` (0600).
+ */
+/**
+ * Claude Code's agent id: what every local memory before agents was written as, and what the
+ * Claude Code hooks and transcript import always act as. A caller that names no agent is
+ * `ANONYMOUS_AGENT` (Planet only), never this.
+ */
+export declare const DEFAULT_AGENT = "claude-code";
+export { ANONYMOUS_AGENT };
+/** Agents configured as Stars, under `OORT_HOME`. */
+export declare const AGENTS_FILE = "agents.json";
+/** A lowercase id: letters, digits, `.`, `_` and `-`, at most 64 characters, starting alphanumeric. */
+export declare const AGENT_ID: RegExp;
+/** A valid agent id that is not reserved (`anonymous` names a caller that named none). */
+export declare const isAgentId: (s: string) => boolean;
+export interface AgentSettings {
+    /** New memories land in this agent's Star (private to it) instead of the person's Planet. */
+    star: boolean;
+}
+/**
+ * The agents configured in `home`. A missing or unreadable file means none,
+ * so every agent writes to the Planet (as before agents existed).
+ */
+export declare function readAgents(home: string): Record<string, AgentSettings>;
+/**
+ * Records whether agent `id` keeps a Star (0600). Returns true when that changed anything. An agent
+ * that stops keeping one stays listed (`star: false`), so its Star is still found (export).
+ */
+export declare function setAgentStar(home: string, id: string, star: boolean): boolean;
+/** Where agent `id`'s new memories land. */
+export declare function agentHome(home: string, id: string): Home;

package/dist/agents.js

@@ -0,0 +1,67 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ANONYMOUS_AGENT } from './grant.js';
+import { writePrivateFile } from './private-fs.js';
+/**
+ * Agent identities on one machine (CON-62). Every host Oort is connected to
+ * acts as its own agent (`claude-code`, `codex`, `cursor`, …): they share the
+ * person's Planet, and each has a Star of its own that no other agent reads.
+ * An agent configured as a Star (`oort connect cursor --star`) writes new
+ * memories to its Star instead of the Planet. The configuration lives in
+ * `$OORT_HOME/agents.json` (0600).
+ */
+/**
+ * Claude Code's agent id: what every local memory before agents was written as, and what the
+ * Claude Code hooks and transcript import always act as. A caller that names no agent is
+ * `ANONYMOUS_AGENT` (Planet only), never this.
+ */
+export const DEFAULT_AGENT = 'claude-code';
+export { ANONYMOUS_AGENT };
+/** Agents configured as Stars, under `OORT_HOME`. */
+export const AGENTS_FILE = 'agents.json';
+/** A lowercase id: letters, digits, `.`, `_` and `-`, at most 64 characters, starting alphanumeric. */
+export const AGENT_ID = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+/** A valid agent id that is not reserved (`anonymous` names a caller that named none). */
+export const isAgentId = (s) => AGENT_ID.test(s) && s !== ANONYMOUS_AGENT;
+/**
+ * The agents configured in `home`. A missing or unreadable file means none,
+ * so every agent writes to the Planet (as before agents existed).
+ */
+export function readAgents(home) {
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(path.join(home, AGENTS_FILE), 'utf8'));
+    }
+    catch {
+        return {};
+    }
+    const agents = parsed?.agents;
+    if (typeof agents !== 'object' || agents === null || Array.isArray(agents))
+        return {};
+    const out = {};
+    for (const [id, v] of Object.entries(agents)) {
+        if (!isAgentId(id) || typeof v !== 'object' || v === null)
+            continue;
+        out[id] = { star: v.star === true };
+    }
+    return out;
+}
+/**
+ * Records whether agent `id` keeps a Star (0600). Returns true when that changed anything. An agent
+ * that stops keeping one stays listed (`star: false`), so its Star is still found (export).
+ */
+export function setAgentStar(home, id, star) {
+    if (!isAgentId(id))
+        throw new RangeError(`not an agent id: ${JSON.stringify(id)}`);
+    const agents = readAgents(home);
+    if ((agents[id]?.star ?? false) === star)
+        return false;
+    agents[id] = { star };
+    writePrivateFile(path.join(home, AGENTS_FILE), `${JSON.stringify({ version: 1, agents }, null, 2)}\n`);
+    return true;
+}
+/** Where agent `id`'s new memories land. */
+export function agentHome(home, id) {
+    return readAgents(home)[id]?.star === true ? 'star' : 'planet';
+}
+//# sourceMappingURL=agents.js.map

package/dist/config.d.ts

@@ -42,6 +42,7 @@ export declare const OortConfig: z.ZodObject<{
         rerankBudgetMs: z.ZodDefault<z.ZodNumber>;
         queryCacheTtlSec: z.ZodDefault<z.ZodNumber>;
         staleAfterDays: z.ZodDefault<z.ZodNumber>;
+        specificityPrior: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strict>>;
     project: z.ZodDefault<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;

package/dist/config.js

@@ -69,6 +69,12 @@ const recall = z
      * marked "may be outdated" when injected, and listed by `oort revalidate`. 0 turns it off.
      */
     staleAfterDays: z.number().int().min(0).default(30),
+    /**
+     * The specificity prior ε (spec 7.2): when a recall reads several nodes, each fused score is
+     * scaled by 1 + ε × specificity / 3 (an agent's Star 3, the Planet 2, a Constellation 1, a
+     * Galaxy 0). 0, the default, turns it off: it is turned on only if the eval shows a gain.
+     */
+    specificityPrior: z.number().min(0).max(1).default(0),
 })
     .default({
     lexicalK: 50,
@@ -84,6 +90,7 @@ const recall = z
     rerankBudgetMs: 400,
     queryCacheTtlSec: 600,
     staleAfterDays: 30,
+    specificityPrior: 0,
 });
 const project = z
     .strictObject({

package/dist/consolidate.d.ts

@@ -37,6 +37,10 @@ export declare const COLD_EVICT_BATCH = 500;
  * left in its current tier (hot or warm); consolidate never promotes cold to warm/hot, since
  * hydration is recall's job.
  * Idempotent for a fixed `now`.
+ *
+ * Each node the scope's grant covers (the person's Planet, this agent's Star)
+ * is consolidated on its own, so the Planet's tiers do not depend on which of
+ * the person's agents ran consolidation.
  */
 export declare function consolidate(scope: ScopeFilter, deps: {
     store: MemoryStore;

package/dist/consolidate.js

@@ -1,5 +1,6 @@
 import { activation, tierFor } from './activation.js';
-import { localGrant } from './grant.js';
+import { nodeKey } from './address.js';
+import { localGrant, narrowGrant, readableNodes } from './grant.js';
 import { isCurrent } from './model.js';
 /** Evictions per `coldPutMany` call: one store transaction and one directory sync each. */
 export const COLD_EVICT_BATCH = 500;
@@ -23,10 +24,14 @@ const RANK = { cold: 0, warm: 1, hot: 2 };
  * left in its current tier (hot or warm); consolidate never promotes cold to warm/hot, since
  * hydration is recall's job.
  * Idempotent for a fixed `now`.
+ *
+ * Each node the scope's grant covers (the person's Planet, this agent's Star)
+ * is consolidated on its own, so the Planet's tiers do not depend on which of
+ * the person's agents ran consolidation.
  */
 export async function consolidate(scope, deps) {
     const { store, config } = deps;
-    const grant = localGrant(scope);
+    const full = localGrant(scope);
     const now = deps.now ?? new Date();
     const result = {
         promoted: [],
@@ -35,6 +40,14 @@ export async function consolidate(scope, deps) {
         expired: [],
         skipped: 0,
     };
+    // Only nodes this grant may change: a Star agent's grant reads the Planet but does not write it.
+    const writable = new Set(full.writeNodes.map((p) => nodeKey(p.node)));
+    for (const node of readableNodes(full).filter((n) => writable.has(nodeKey(n)))) {
+        await consolidateNode(store, narrowGrant(full, [node]), config, now, result);
+    }
+    return result;
+}
+async function consolidateNode(store, grant, config, now, result) {
     // 1. Expire.
     const due = (await store.list(grant, { validOnly: false })).filter((m) => m.validTo !== null && m.expiredAt === null && Date.parse(m.validTo) <= now.getTime());
     if (due.length > 0) {
@@ -76,7 +89,6 @@ export async function consolidate(scope, deps) {
         evictions.push(m);
     }
     await evictAll(store, grant, evictions, result);
-    return result;
 }
 async function evictAll(store, grant, evictions, result) {
     for (let i = 0; i < evictions.length; i += COLD_EVICT_BATCH) {

package/dist/grant.d.ts

@@ -27,15 +27,26 @@ export interface GrantFilter extends Readonly<Principal> {
  * One node a grant covers (CON-61): the node, the project bindings inside it,
  * and optionally one author. Matching is structural and exact on every field
  * (never a prefix). `authorAgentId` restricts the pattern to memories that
- * agent wrote; the pre-level constructors (`localGrant`, `principalGrant`)
- * set it to the principal's agent, so they see exactly what they saw before
- * levels existed.
+ * agent wrote. The local constructors (`localGrant`, `principalGrant`) name
+ * the principal's Planet with no author restriction (a person's agents share
+ * their Planet, CON-62) and the principal's agent's own Star.
  */
 export interface NodePattern {
     readonly node: NodeRef;
     readonly projectIds: GrantProjects;
     readonly authorAgentId?: string;
 }
+/**
+ * Where an agent's new memories land by default (its home node, spec 5.1):
+ * the person's Planet, or the agent's own Star when it is configured as one.
+ */
+export type Home = 'planet' | 'star';
+/**
+ * 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 declare const ANONYMOUS_AGENT = "anonymous";
 /**
  * The permission every `MemoryStore` method takes. Opaque: built only by
  * `localGrant`, `principalGrant` or `nodeGrant`, frozen, and nominal, so a raw
@@ -58,24 +69,48 @@ export declare class Grant {
     readonly write: GrantFilter;
     readonly readNodes: readonly NodePattern[];
     readonly writeNodes: readonly NodePattern[];
+    /**
+     * 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.
+     */
+    readonly home: NodeRef;
     private constructor();
     /** @internal Use `localGrant` or `principalGrant`. */
-    static issue(principal: Principal, read: GrantProjects, write: GrantProjects): Grant;
-    /** @internal Use `nodeGrant`. */
-    static issueNodes(principal: Principal, read: readonly NodePattern[], write: readonly NodePattern[]): Grant;
+    static issue(principal: Principal, read: GrantProjects, write: GrantProjects, home?: Home): Grant;
+    /** @internal Use `nodeGrant` or `narrowGrant`. */
+    static issueNodes(principal: Principal, read: readonly NodePattern[], write: readonly NodePattern[], home?: NodeRef): Grant;
     /** True for a real grant (not a copy, not a look-alike). */
     static is(x: unknown): x is Grant;
 }
+/** The Star of a principal's agent (owned by the principal's owner). */
+export declare function starNode(p: Pick<Principal, 'orgId' | 'agentId'>): NodeRef;
 /**
- * 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 declare function localGrant(read: ScopeFilter, opts?: {
     write?: ScopeFilter;
+    home?: Home;
+}): Grant;
+/**
+ * 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 declare function principalGrant(p: Principal, opts?: {
+    home?: Home;
 }): Grant;
-/** Every project of `p` (and its global memories), for read and write: maintenance such as export. */
-export declare function principalGrant(p: Principal): Grant;
 /**
  * A grant over explicit node patterns, possibly across owners and levels:
  * `read` bounds what is seen, `write` (default: `read`) what may change.
@@ -88,7 +123,19 @@ export declare function nodeGrant(opts: {
     principal: Principal;
     read: readonly NodePattern[];
     write?: readonly NodePattern[];
+    /** Where new memories land (default: the principal's Planet if written, else the first node written). */
+    home?: NodeRef;
 }): Grant;
+/**
+ * `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 declare function narrowGrant(g: Grant, keep: readonly NodeRef[]): Grant;
+/** The distinct nodes `g` reads, in the order its patterns name them. */
+export declare function readableNodes(g: Grant): NodeRef[];
+/** The address a new memory gets under `g`: its home node, bound to `projectId` when given. */
+export declare function homeAddress(g: Grant, projectId?: string): Address;
 /** Rejects anything that is not a real `Grant`; every store calls it first. */
 export declare function assertGrant(g: unknown): asserts g is Grant;
 /**

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.4.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.4.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>;