@oortmem/core 0.2.1 → 0.4.0

package/dist/address.d.ts

@@ -0,0 +1,161 @@
+import type { Memory, Scope } from './model.js';
+/**
+ * Levels: whose memory it is (CON-61). The code keeps plain names; the space
+ * names are the product's:
+ *
+ * | level        | space         | what it is                                         |
+ * | ------------ | ------------- | -------------------------------------------------- |
+ * | `user`       | Planet        | one person's own memory                            |
+ * | `agent`      | Star          | one agent's own private memory                     |
+ * | `agent-user` | Orbit         | what one agent knows about one person              |
+ * | `run`        | Flyby         | one run or session, short-lived                    |
+ * | `hive`       | Constellation | a group sharing memory (`hiveId` names it)         |
+ * | `hive`       | Galaxy        | an organisation's own node (`hiveId` is `root`)    |
+ *
+ * Levels say whose a memory is; tiers (hot, warm, cold) say how warm it is.
+ * The two are independent.
+ */
+export type Level = 'user' | 'agent' | 'agent-user' | 'run' | 'hive';
+export declare const LEVELS: readonly Level[];
+/** The `hiveId` of a Galaxy's own node (the hive tree is two deep: a Galaxy holds Constellations). */
+export declare const GALAXY_ROOT = "root";
+/**
+ * In every address, `orgId` is the **owner**: the storage, key and deletion
+ * boundary (`local` on a laptop, an account, or an organisation). `projectId`
+ * binds a memory to a project inside its node; absent means unbound (global).
+ */
+export interface PlanetAddress {
+    level: 'user';
+    orgId: string;
+    customerId: string;
+    projectId?: string;
+    agentId?: never;
+    hiveId?: never;
+    runId?: never;
+}
+export interface StarAddress {
+    level: 'agent';
+    orgId: string;
+    agentId: string;
+    projectId?: string;
+    customerId?: never;
+    hiveId?: never;
+    runId?: never;
+}
+export interface OrbitAddress {
+    level: 'agent-user';
+    orgId: string;
+    agentId: string;
+    customerId: string;
+    projectId?: string;
+    hiveId?: never;
+    runId?: never;
+}
+export interface FlybyAddress {
+    level: 'run';
+    orgId: string;
+    agentId: string;
+    runId: string;
+    customerId?: string;
+    projectId?: string;
+    hiveId?: never;
+}
+/** A Constellation, or the Galaxy's own node when `hiveId` is `GALAXY_ROOT`. Subject-free: no `customerId`. */
+export interface HiveAddress {
+    level: 'hive';
+    orgId: string;
+    hiveId: string;
+    projectId?: string;
+    customerId?: never;
+    agentId?: never;
+    runId?: never;
+}
+/** Where a memory lives. Every memory has exactly one; the level decides which fields exist. */
+export type Address = PlanetAddress | StarAddress | OrbitAddress | FlybyAddress | HiveAddress;
+type WithoutProject<T> = T extends unknown ? Omit<T, 'projectId'> : never;
+/** A node: an address without its project binding. Grants name nodes. */
+export type NodeRef = WithoutProject<Address>;
+/** Who wrote a memory. Not part of the address: a person's agents share their Planet. */
+export interface Author {
+    agentId: string;
+    /** The account that ran the agent, where the store knows it. */
+    accountRef?: string;
+}
+/**
+ * Where a shared copy came from (filled by sharing, a later feature). Absent on
+ * ordinary memories. Stores keep it as given; nothing in the engine reads it yet.
+ */
+export interface Provenance {
+    derivedFrom: {
+        vault: string;
+        memoryId: string;
+        subjectRef?: string;
+    }[];
+    contributors: {
+        memberRef: string;
+        agentId: string;
+        at: string;
+        action: 'asserted' | 'confirmed' | 'contradicted';
+    }[];
+    support: {
+        members: number;
+        agents: number;
+    };
+    gate: {
+        policyVersion: string;
+        mode: 'confirmed' | 'open' | 'approval';
+        approvedBy?: string;
+    };
+}
+/** Throws a `RangeError` naming the problem unless `a` is a legal `Address`. */
+export declare function assertAddress(a: unknown): asserts a is Address;
+/** Throws a `RangeError` unless `n` is a legal `NodeRef`. */
+export declare function assertNode(n: unknown): asserts n is NodeRef;
+/** Throws a `RangeError` unless `a` is a legal `Author`. */
+export declare function assertAuthor(a: unknown): asserts a is Author;
+/** The Planet a scope names: today's (org, customer, project), without the agent. */
+export declare function planetOf(scope: Scope): PlanetAddress;
+/** Where `m` lives: its `address`, or the Planet its `scope` names (every memory written before levels). */
+export declare function addressOf(m: Pick<Memory, 'scope' | 'address'>): Address;
+/** Who wrote `m`: its `author`, or the agent its `scope` names. */
+export declare function authorOf(m: Pick<Memory, 'scope' | 'author'>): Author;
+/**
+ * The `scope` a memory at `address` written by `author` carries: the
+ * pre-level view, kept so existing readers work. The agent is the address's
+ * own agent where it has one (Star, Orbit, Flyby), else the author. A level
+ * without a customer (Star, Constellation, Galaxy) has `customerId: ''`.
+ * Authorisation never reads it.
+ */
+export declare function scopeOf(address: Address, author: Author): Scope;
+/** `address`, `author` and the matching `scope`, to spread into a new memory at a level. */
+export declare function addressed(address: Address, author: Author): Pick<Memory, 'scope' | 'address' | 'author'>;
+/** The node `address` sits in (the address without its project binding). */
+export declare function nodeOf(address: Address): NodeRef;
+/**
+ * A node as a JSON tuple: `["user", orgId, customerId]`, `["hive", orgId, hiveId]`
+ * and so on, with `null` for an absent optional field. Structured and compared
+ * whole, never as a prefix.
+ */
+export declare function nodeKey(n: NodeRef): string;
+/** Two addresses name the same node and the same project binding. */
+export declare function sameAddress(a: Address, b: Address): boolean;
+export declare function sameAuthor(a: Author, b: Author): boolean;
+/** The space name of `address`'s level, for people: Planet, Star, Orbit, Flyby, Constellation or Galaxy. */
+export declare function spaceName(address: Address | NodeRef): string;
+/**
+ * `m`'s address, author and scope checked against each other: the address and
+ * author are legal, and `scope` is exactly the view `scopeOf` gives (extra
+ * scope fields aside). Throws a `RangeError` otherwise. Every store runs this
+ * on each memory it writes.
+ */
+export declare function resolveAddressing(m: Pick<Memory, 'scope' | 'address' | 'author'>): {
+    address: Address;
+    author: Author;
+};
+/**
+ * `m` in the shape stores return: `address` only when it is not the Planet
+ * `scope` names, `author` only when it is not `scope.agentId`, `provenance`
+ * only when set. A memory written before levels comes back exactly as it was.
+ */
+export declare function canonicalMemory<M extends Memory>(m: M): M;
+export {};

package/dist/address.js

@@ -0,0 +1,225 @@
+export const LEVELS = Object.freeze([
+    'user',
+    'agent',
+    'agent-user',
+    'run',
+    'hive',
+]);
+/** The `hiveId` of a Galaxy's own node (the hive tree is two deep: a Galaxy holds Constellations). */
+export const GALAXY_ROOT = 'root';
+/** The fields each level requires (besides `level` and `orgId`) and allows. */
+const SHAPE = {
+    user: { required: ['customerId'], optional: [] },
+    agent: { required: ['agentId'], optional: [] },
+    'agent-user': { required: ['agentId', 'customerId'], optional: [] },
+    run: { required: ['agentId', 'runId'], optional: ['customerId'] },
+    hive: { required: ['hiveId'], optional: [] },
+};
+const NODE_FIELDS = ['customerId', 'agentId', 'hiveId', 'runId'];
+const isText = (x) => typeof x === 'string' && x !== '';
+function checkNode(a, what, allowProject) {
+    const level = a['level'];
+    if (typeof level !== 'string' || !LEVELS.includes(level)) {
+        throw new RangeError(`${what}: unknown level ${JSON.stringify(level)}`);
+    }
+    const shape = SHAPE[level];
+    if (!isText(a['orgId']))
+        throw new RangeError(`${what}: orgId must be a non-empty string`);
+    for (const f of shape.required) {
+        if (!isText(a[f]))
+            throw new RangeError(`${what}: a ${level} address needs ${f}`);
+    }
+    for (const f of NODE_FIELDS) {
+        if (a[f] === undefined || shape.required.includes(f))
+            continue;
+        if (!shape.optional.includes(f))
+            throw new RangeError(`${what}: a ${level} address has no ${f}`);
+        if (!isText(a[f]))
+            throw new RangeError(`${what}: ${f} must be a non-empty string`);
+    }
+    if (a['projectId'] !== undefined) {
+        if (!allowProject)
+            throw new RangeError(`${what}: a node has no projectId`);
+        if (typeof a['projectId'] !== 'string') {
+            throw new RangeError(`${what}: projectId must be a string`);
+        }
+    }
+    const known = new Set(['level', 'orgId', 'projectId', ...NODE_FIELDS]);
+    for (const k of Object.keys(a)) {
+        if (!known.has(k))
+            throw new RangeError(`${what}: unknown field ${k}`);
+    }
+}
+/** Throws a `RangeError` naming the problem unless `a` is a legal `Address`. */
+export function assertAddress(a) {
+    if (typeof a !== 'object' || a === null)
+        throw new RangeError('address must be an object');
+    checkNode(a, 'address', true);
+}
+/** Throws a `RangeError` unless `n` is a legal `NodeRef`. */
+export function assertNode(n) {
+    if (typeof n !== 'object' || n === null)
+        throw new RangeError('node must be an object');
+    checkNode(n, 'node', false);
+}
+/** Throws a `RangeError` unless `a` is a legal `Author`. */
+export function assertAuthor(a) {
+    if (typeof a !== 'object' || a === null)
+        throw new RangeError('author must be an object');
+    const o = a;
+    if (!isText(o['agentId']))
+        throw new RangeError('author: agentId must be a non-empty string');
+    if (o['accountRef'] !== undefined && !isText(o['accountRef'])) {
+        throw new RangeError('author: accountRef must be a non-empty string');
+    }
+    for (const k of Object.keys(o)) {
+        if (k !== 'agentId' && k !== 'accountRef')
+            throw new RangeError(`author: unknown field ${k}`);
+    }
+}
+/** The Planet a scope names: today's (org, customer, project), without the agent. */
+export function planetOf(scope) {
+    return {
+        level: 'user',
+        orgId: scope.orgId,
+        customerId: scope.customerId,
+        ...(scope.projectId !== undefined && { projectId: scope.projectId }),
+    };
+}
+/** A copy of `a` with only its own level's fields, in a fixed order. */
+function clean(a) {
+    const out = { level: a.level, orgId: a.orgId };
+    for (const f of NODE_FIELDS) {
+        const v = a[f];
+        if (typeof v === 'string')
+            out[f] = v;
+    }
+    if (a.projectId !== undefined)
+        out['projectId'] = a.projectId;
+    return out;
+}
+/** Where `m` lives: its `address`, or the Planet its `scope` names (every memory written before levels). */
+export function addressOf(m) {
+    return m.address === undefined ? planetOf(m.scope) : clean(m.address);
+}
+/** Who wrote `m`: its `author`, or the agent its `scope` names. */
+export function authorOf(m) {
+    if (m.author === undefined)
+        return { agentId: m.scope.agentId };
+    const { agentId, accountRef } = m.author;
+    return accountRef === undefined ? { agentId } : { agentId, accountRef };
+}
+/**
+ * The `scope` a memory at `address` written by `author` carries: the
+ * pre-level view, kept so existing readers work. The agent is the address's
+ * own agent where it has one (Star, Orbit, Flyby), else the author. A level
+ * without a customer (Star, Constellation, Galaxy) has `customerId: ''`.
+ * Authorisation never reads it.
+ */
+export function scopeOf(address, author) {
+    const a = address;
+    return {
+        orgId: address.orgId,
+        customerId: a.customerId ?? '',
+        agentId: a.agentId ?? author.agentId,
+        ...(address.projectId !== undefined && { projectId: address.projectId }),
+    };
+}
+/** `address`, `author` and the matching `scope`, to spread into a new memory at a level. */
+export function addressed(address, author) {
+    assertAddress(address);
+    assertAuthor(author);
+    const a = clean(address);
+    const w = author.accountRef === undefined
+        ? { agentId: author.agentId }
+        : { agentId: author.agentId, accountRef: author.accountRef };
+    return { scope: scopeOf(a, w), address: a, author: w };
+}
+/** The node `address` sits in (the address without its project binding). */
+export function nodeOf(address) {
+    const { projectId: _p, ...node } = clean(address);
+    return node;
+}
+/**
+ * A node as a JSON tuple: `["user", orgId, customerId]`, `["hive", orgId, hiveId]`
+ * and so on, with `null` for an absent optional field. Structured and compared
+ * whole, never as a prefix.
+ */
+export function nodeKey(n) {
+    const x = n;
+    switch (n.level) {
+        case 'user':
+            return JSON.stringify([n.level, n.orgId, x.customerId]);
+        case 'agent':
+            return JSON.stringify([n.level, n.orgId, x.agentId]);
+        case 'agent-user':
+            return JSON.stringify([n.level, n.orgId, x.agentId, x.customerId]);
+        case 'run':
+            return JSON.stringify([n.level, n.orgId, x.agentId, x.runId, x.customerId ?? null]);
+        case 'hive':
+            return JSON.stringify([n.level, n.orgId, x.hiveId]);
+    }
+}
+/** Two addresses name the same node and the same project binding. */
+export function sameAddress(a, b) {
+    return (nodeKey(nodeOf(a)) === nodeKey(nodeOf(b)) && (a.projectId ?? null) === (b.projectId ?? null));
+}
+export function sameAuthor(a, b) {
+    return a.agentId === b.agentId && (a.accountRef ?? null) === (b.accountRef ?? null);
+}
+/** The space name of `address`'s level, for people: Planet, Star, Orbit, Flyby, Constellation or Galaxy. */
+export function spaceName(address) {
+    switch (address.level) {
+        case 'user':
+            return 'Planet';
+        case 'agent':
+            return 'Star';
+        case 'agent-user':
+            return 'Orbit';
+        case 'run':
+            return 'Flyby';
+        case 'hive':
+            return address.hiveId === GALAXY_ROOT ? 'Galaxy' : 'Constellation';
+    }
+}
+/**
+ * `m`'s address, author and scope checked against each other: the address and
+ * author are legal, and `scope` is exactly the view `scopeOf` gives (extra
+ * scope fields aside). Throws a `RangeError` otherwise. Every store runs this
+ * on each memory it writes.
+ */
+export function resolveAddressing(m) {
+    if (m.address !== undefined)
+        assertAddress(m.address);
+    if (m.author !== undefined)
+        assertAuthor(m.author);
+    const address = addressOf(m);
+    const author = authorOf(m);
+    const want = scopeOf(address, author);
+    const s = m.scope;
+    if (s.orgId !== want.orgId ||
+        s.customerId !== want.customerId ||
+        s.agentId !== want.agentId ||
+        (s.projectId ?? null) !== (want.projectId ?? null)) {
+        throw new RangeError('memory scope does not match its address and author (use addressed())');
+    }
+    return { address, author };
+}
+/**
+ * `m` in the shape stores return: `address` only when it is not the Planet
+ * `scope` names, `author` only when it is not `scope.agentId`, `provenance`
+ * only when set. A memory written before levels comes back exactly as it was.
+ */
+export function canonicalMemory(m) {
+    const { address, author } = resolveAddressing(m);
+    const { address: _a, author: _w, provenance, ...rest } = m;
+    const out = { ...rest };
+    if (address.level !== 'user')
+        out.address = address;
+    if (author.accountRef !== undefined || author.agentId !== m.scope.agentId)
+        out.author = author;
+    if (provenance !== undefined && provenance !== null)
+        out.provenance = provenance;
+    return out;
+}
+//# sourceMappingURL=address.js.map

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/date-cue.d.ts

@@ -0,0 +1,26 @@
+import type * as Chrono from 'chrono-node';
+/**
+ * chrono-node, loaded only when a text may hold a date (CON-82). Importing it costs about
+ * 95 ms, and a hook process pays that on every prompt; most prompts name no date, so the
+ * temporal functions ask `mayHaveDateCue` first and treat a text without a cue as one chrono
+ * finds nothing in.
+ */
+type ChronoModule = typeof Chrono;
+/**
+ * Whether `text` may hold a date or time expression chrono-node would read. False means
+ * chrono reads none that the temporal functions act on (a bare "now" is the present, and
+ * only counts after a bound word such as "from" or "until"). True may be a false alarm: that
+ * only costs loading chrono.
+ */
+export declare function mayHaveDateCue(text: string): boolean;
+/** Whether chrono-node has been loaded in this process. */
+export declare function chronoLoaded(): boolean;
+/**
+ * Loads chrono-node ahead of need. Node never has to: the temporal functions load it
+ * synchronously on first use. A bundled runtime without `require` (a Worker) awaits this once
+ * at startup.
+ */
+export declare function preloadChrono(): Promise<void>;
+/** chrono-node, loaded synchronously on first call. */
+export declare function loadChrono(): ChronoModule;
+export {};