@zenera/neo 1.1.23 → 1.1.25

package/dist/match.d.ts

@@ -0,0 +1,44 @@
+/** Long enough for any honest pattern, short enough to bound a bad one. */
+export declare const MAX_PATTERN = 200;
+export declare class PatternError extends Error {
+}
+export interface MatchOptions {
+    /** read the pattern as a regular expression rather than as a literal */
+    regex?: boolean;
+    caseSensitive?: boolean;
+}
+export type Matcher = (text: string) => boolean;
+/** The offset of the first match in `text`, or -1. */
+export type Finder = (text: string) => number;
+/**
+ * Where a pattern first occurs. Literal by default: someone typing `user.id`
+ * means those seven characters, and a dot that quietly matched anything would
+ * be a worse answer than no answer.
+ */
+export declare function finder(pattern: string, options?: MatchOptions): Finder;
+/** Whether a pattern occurs at all, read the same way `finder` reads it. */
+export declare function matcher(pattern: string, options?: MatchOptions): Matcher;
+/**
+ * A glob, matched against the whole string. Globs rather than regexes because
+ * these are for naming things — a path, a schema — and a star is what everyone
+ * reaches for first.
+ */
+export declare function wildcard(pattern: string, options?: {
+    caseSensitive?: boolean;
+}): Matcher;
+/** Whether a pattern is asking to be read as a glob at all. */
+export declare const isGlob: (pattern: string) => boolean;
+/**
+ * What someone means when they type a name into a filter. With a star in it,
+ * a glob; without one, a substring — because `password` typed into `--name` is
+ * a search for the word, and a whole-string match would answer nothing and
+ * look like the field does not exist.
+ *
+ * `regex` settles it outright, and has to: a star is punctuation in both
+ * languages, so `^/(users|teams)/.*` read as a glob would match nothing and
+ * never say why.
+ */
+export declare function loose(pattern: string, options?: MatchOptions): Matcher;
+/** True when any of the patterns matches; no patterns means no opinion. */
+export declare function anyOf(matchers: readonly Matcher[]): Matcher | undefined;
+//# sourceMappingURL=match.d.ts.map

package/dist/match.js

@@ -0,0 +1,100 @@
+// ---------------------------------------------------------------------------
+// Matching, with nothing learned in between
+//
+// Everything here is exact. A glob matches the characters it names and a
+// substring is a substring, which is the whole point of the surfaces built on
+// it: a vector index answers "what is near this", and near is a ranking, so it
+// can only ever return the top of a list. When the question is "does the word
+// `password` appear anywhere at all", a ranking is the wrong instrument and no
+// amount of tuning makes it the right one.
+//
+// Memory grep and @zenera/rag's lookups both stand on this. A `finder` says
+// *where*, for grep, which reports the line; a `matcher` says *whether*.
+//
+// A pattern may arrive from a model, so a regex is a bounded promise: the
+// length is capped here and the scan that uses it keeps a deadline.
+// ---------------------------------------------------------------------------
+/** Long enough for any honest pattern, short enough to bound a bad one. */
+export const MAX_PATTERN = 200;
+export class PatternError extends Error {
+}
+/**
+ * Where a pattern first occurs. Literal by default: someone typing `user.id`
+ * means those seven characters, and a dot that quietly matched anything would
+ * be a worse answer than no answer.
+ */
+export function finder(pattern, options = {}) {
+    guard(pattern);
+    if (!options.regex) {
+        if (options.caseSensitive) {
+            return (text) => text.indexOf(pattern);
+        }
+        const needle = pattern.toLowerCase();
+        return (text) => text.toLowerCase().indexOf(needle);
+    }
+    const expression = compile(pattern, options.caseSensitive ? '' : 'i');
+    // `lastIndex` is not carried between calls: the flags never include `g`.
+    return (text) => text.search(expression);
+}
+/** Whether a pattern occurs at all, read the same way `finder` reads it. */
+export function matcher(pattern, options = {}) {
+    const find = finder(pattern, options);
+    return (text) => find(text) >= 0;
+}
+/**
+ * A glob, matched against the whole string. Globs rather than regexes because
+ * these are for naming things — a path, a schema — and a star is what everyone
+ * reaches for first.
+ */
+export function wildcard(pattern, options = {}) {
+    guard(pattern);
+    const source = [...pattern]
+        .map((char) => (char === '*' ? '.*' : char === '?' ? '.' : escape(char)))
+        .join('');
+    const expression = compile(`^${source}$`, options.caseSensitive ? '' : 'i');
+    return (text) => expression.test(text);
+}
+/** Whether a pattern is asking to be read as a glob at all. */
+export const isGlob = (pattern) => /[*?]/.test(pattern);
+/**
+ * What someone means when they type a name into a filter. With a star in it,
+ * a glob; without one, a substring — because `password` typed into `--name` is
+ * a search for the word, and a whole-string match would answer nothing and
+ * look like the field does not exist.
+ *
+ * `regex` settles it outright, and has to: a star is punctuation in both
+ * languages, so `^/(users|teams)/.*` read as a glob would match nothing and
+ * never say why.
+ */
+export function loose(pattern, options = {}) {
+    if (options.regex) {
+        return matcher(pattern, options);
+    }
+    return isGlob(pattern) ? wildcard(pattern, options) : matcher(pattern, options);
+}
+/** True when any of the patterns matches; no patterns means no opinion. */
+export function anyOf(matchers) {
+    if (matchers.length === 0) {
+        return undefined;
+    }
+    return (text) => matchers.some((match) => match(text));
+}
+// ---------------------------------------------------------------------------
+function guard(pattern) {
+    if (pattern.length === 0) {
+        throw new PatternError('the pattern is empty');
+    }
+    if (pattern.length > MAX_PATTERN) {
+        throw new PatternError(`the pattern is longer than ${MAX_PATTERN} characters`);
+    }
+}
+function compile(source, flags) {
+    try {
+        return new RegExp(source, flags);
+    }
+    catch (err) {
+        throw new PatternError(`invalid pattern: ${err.message}`);
+    }
+}
+const escape = (char) => char.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+//# sourceMappingURL=match.js.map

package/dist/memory/diff.d.ts

@@ -0,0 +1,39 @@
+import type { MemoryStore } from './store.ts';
+import type { MemoryNode } from './types.ts';
+export interface MemoryNearest {
+    id: string;
+    score: number;
+    text: string;
+}
+export interface MemoryDiffAdded {
+    node: MemoryNode;
+    /** the closest comparable node the base held, if any */
+    nearest?: MemoryNearest;
+    /** `merge` would fold it onto `nearest`: the base already said this */
+    twin: boolean;
+}
+export interface MemoryDiff {
+    base: string;
+    other: string;
+    /** how `nearest` was scored: cosine when both sides hold vectors, else term overlap */
+    by: 'vector' | 'text';
+    added: MemoryDiffAdded[];
+    revised: {
+        before: MemoryNode;
+        after: MemoryNode;
+    }[];
+    /** base nodes `memory_load` returned since — what the run actually read */
+    used: {
+        node: MemoryNode;
+        loads: number;
+    }[];
+    removed: MemoryNode[];
+    /** edges `other` has that `base` did not */
+    edges: number;
+    supersedes: {
+        source: string;
+        target: string;
+    }[];
+}
+export declare function diffMemories(base: MemoryStore, other: MemoryStore): MemoryDiff;
+//# sourceMappingURL=diff.d.ts.map

package/dist/memory/diff.js

@@ -0,0 +1,95 @@
+import { DUPLICATE_SCORE } from "./index.js";
+import { comparable, sameContent, twinKey } from "./twin.js";
+import { overlap, tokenize } from "./vectors.js";
+export function diffMemories(base, other) {
+    const stale = base.graph.superseded();
+    const block = base.vectors;
+    const theirs = other.vectors;
+    const byVector = !!block?.rows && !!theirs && theirs.dims === block.dims;
+    const held = base.graph.nodes();
+    const lexical = new Map(held.filter((n) => !stale.has(n.id)).map((n) => [twinKey(n), n.id]));
+    const nearestOf = (node) => {
+        if (node.file) {
+            return { twin: false };
+        }
+        const allow = (id) => {
+            const n = base.graph.get(id);
+            return !stale.has(id) && !!n && comparable(n, node);
+        };
+        const exact = lexical.get(twinKey(node));
+        const vector = byVector ? theirs.get(node.id) : undefined;
+        if (vector) {
+            const hit = block.topK(vector, 1, allow)[0];
+            if (hit) {
+                const text = base.graph.get(hit.id).text;
+                return {
+                    nearest: { id: hit.id, score: hit.score, text },
+                    twin: hit.score >= DUPLICATE_SCORE,
+                };
+            }
+        }
+        if (exact) {
+            return {
+                nearest: { id: exact, score: 1, text: base.graph.get(exact).text },
+                twin: true,
+            };
+        }
+        const words = tokenize(node.text);
+        let best;
+        for (const n of held) {
+            if (!allow(n.id)) {
+                continue;
+            }
+            const score = overlap(words, tokenize(n.text));
+            if (score > 0 && (!best || score > best.score)) {
+                best = { id: n.id, score, text: n.text };
+            }
+        }
+        return { nearest: best, twin: false };
+    };
+    const diff = {
+        base: base.dir,
+        other: other.dir,
+        by: byVector ? 'vector' : 'text',
+        added: [],
+        revised: [],
+        used: [],
+        removed: [],
+        edges: 0,
+        supersedes: [],
+    };
+    for (const after of other.graph.nodes()) {
+        const before = base.graph.get(after.id);
+        if (!before) {
+            diff.added.push({ node: after, ...nearestOf(after) });
+            continue;
+        }
+        if (before.revision !== after.revision || !sameContent(before, after)) {
+            diff.revised.push({ before, after });
+        }
+        if (after.useCount > before.useCount) {
+            diff.used.push({ node: after, loads: after.useCount - before.useCount });
+        }
+    }
+    for (const node of held) {
+        if (!other.graph.has(node.id)) {
+            diff.removed.push(node);
+        }
+    }
+    const key = (source, target, relation) => `${source}\u0000${target}\u0000${relation}`;
+    const had = new Set(base.graph.links().map((l) => key(l.source, l.target, l.attrs.relation)));
+    for (const link of other.graph.links()) {
+        if (had.has(key(link.source, link.target, link.attrs.relation))) {
+            continue;
+        }
+        diff.edges++;
+        if (link.attrs.relation === 'SUPERSEDES') {
+            diff.supersedes.push({ source: link.source, target: link.target });
+        }
+    }
+    const newest = (a, b) => b.node.createdAt.localeCompare(a.node.createdAt);
+    diff.added.sort(newest);
+    diff.used.sort((a, b) => b.loads - a.loads);
+    return diff;
+}
+//# sourceMappingURL=diff.js.map

package/dist/memory/files.d.ts

@@ -20,7 +20,7 @@ export interface RememberOptions {
  */
 export declare function rememberFile(dir: string, source: string, id: string, opts?: RememberOptions): Promise<MemoryFile>;
 /** The host path of a remembered file, for reading it back or deleting it. */
-export declare function hostPath(dir: string, file: MemoryFile): string;
+export declare function hostPath(dir: string, file: Pick<MemoryFile, 'path'>): string;
 /** Drop the bytes of a forgotten node. Missing is success — the goal is absence. */
 export declare function forgetFile(dir: string, file: MemoryFile): Promise<void>;
 //# sourceMappingURL=files.d.ts.map

package/dist/memory/grep.d.ts

@@ -0,0 +1,57 @@
+import { type MatchOptions } from '../match.ts';
+import type { Omitted } from './report.ts';
+import type { MemoryStore } from './store.ts';
+import { type MemoryNode } from './types.ts';
+/** The three places a pattern is looked for. */
+export declare const GREP_FIELDS: readonly ["text", "metadata", "file"];
+export type GrepField = (typeof GREP_FIELDS)[number];
+/** What to do about nodes something has superseded. */
+export type StaleMode = 'exclude' | 'include' | 'only';
+/** Past this a remembered file is reported as unsearched rather than read. */
+export declare const MAX_GREP_FILE_BYTES: number;
+/** And past this, so does the rest of the scan: one memory can hold hundreds. */
+export declare const MAX_GREP_BYTES: number;
+export interface GrepHit {
+    where: GrepField;
+    /** 1-based, within that field */
+    line: number;
+    /** the matched line, clipped around the match */
+    text: string;
+}
+export interface MemoryMatch {
+    node: MemoryNode;
+    hits: GrepHit[];
+    /** hits this node had beyond the ones kept */
+    more: number;
+    /** superseded by a newer node; only ever true when they were asked for */
+    stale: boolean;
+}
+/** A remembered file that was not searched, so absence of a hit proves nothing. */
+export interface SkippedFile {
+    id: string;
+    /** the mount path, as the agent knows it */
+    path: string;
+    reason: Omitted;
+}
+export interface MemoryGrepFilter extends MatchOptions {
+    /** audience labels the reader holds; absent reads the graph unmasked */
+    sees?: readonly string[];
+    kinds?: readonly string[];
+    audience?: string;
+    /** only nodes that remember a file */
+    files?: boolean;
+    /** which fields to read; all three by default */
+    in?: readonly GrepField[];
+    stale?: StaleMode;
+    limit?: number;
+    hitsPerNode?: number;
+}
+export interface MemoryGrepResult {
+    /** how many nodes matched, whatever was kept */
+    found: number;
+    matches: MemoryMatch[];
+    truncated: boolean;
+    skipped: SkippedFile[];
+}
+export declare function grepMemory(store: MemoryStore, pattern: string, filter?: MemoryGrepFilter): Promise<MemoryGrepResult>;
+//# sourceMappingURL=grep.d.ts.map

package/dist/memory/grep.js

@@ -0,0 +1,182 @@
+import { readFile, stat } from 'node:fs/promises';
+import { PatternError, finder } from "../match.js";
+import { hostPath } from "./files.js";
+import { MemoryError } from "./types.js";
+// ---------------------------------------------------------------------------
+// The memory, read exhaustively
+//
+// `search` ranks and `grep` decides. They answer different questions and
+// neither can be made to answer the other's: a ranking hands back the top of a
+// list, so "nothing came back" and "nothing is there" are the same result, and
+// the one question memory keeps raising — *did we already write this down* —
+// needs them to be different results. So this is one pass, no embedder, no
+// credential, and `found` is the true total even when the list was cut.
+//
+// Three fields, because a memory is not only its summary. `text` is what the
+// ranker sees; `metadata` is where an agent puts the identifiers nobody would
+// ever phrase as a sentence — a commit sha, an endpoint, a container name; and
+// the bytes of a remembered file are the thing itself. An exact match belongs
+// against all three.
+//
+// Two rules keep this honest against raw `grep` over /memory, which is what it
+// exists to replace. Superseded nodes are excluded unless asked for, and come
+// back flagged when they are — serving a withdrawn correction as current is
+// the failure mode the mount is warned about. And reading here is not use:
+// recency decay is meant to track what an agent actually opened, and a finder
+// that bumped it would make every scan look like a read.
+// ---------------------------------------------------------------------------
+/** The three places a pattern is looked for. */
+export const GREP_FIELDS = ['text', 'metadata', 'file'];
+/** A scan is bounded, because a pattern may have come from a model. */
+const DEADLINE_MS = 2000;
+const DEADLINE_EVERY = 100;
+/** Past this a remembered file is reported as unsearched rather than read. */
+export const MAX_GREP_FILE_BYTES = 256 * 1024;
+/** And past this, so does the rest of the scan: one memory can hold hundreds. */
+export const MAX_GREP_BYTES = 8 * 1024 * 1024;
+/** Enough to see why a node matched without one file crowding out every other. */
+const HITS_PER_NODE = 5;
+/** A matched line, as much of it as is worth carrying. */
+const EXCERPT = 240;
+export async function grepMemory(store, pattern, filter = {}) {
+    const match = compile(pattern, filter);
+    const fields = new Set(filter.in?.length ? filter.in : GREP_FIELDS);
+    const kinds = filter.kinds?.length ? new Set(filter.kinds) : undefined;
+    const cap = filter.hitsPerNode ?? HITS_PER_NODE;
+    const want = filter.stale ?? 'exclude';
+    const superseded = store.graph.superseded(filter.sees);
+    const matches = [];
+    const skipped = [];
+    const until = Date.now() + DEADLINE_MS;
+    let budget = MAX_GREP_BYTES;
+    let seen = 0;
+    for (const node of store.graph.nodes(filter.sees)) {
+        if (++seen % DEADLINE_EVERY === 0 && Date.now() > until) {
+            throw new MemoryError(`the pattern is still running after ${DEADLINE_MS / 1000}s — it is too expensive to be useful`, 'anchor the pattern, or narrow the scan with `kinds` or `in`');
+        }
+        const stale = superseded.has(node.id);
+        if (want === 'exclude' ? stale : want === 'only' && !stale) {
+            continue;
+        }
+        if (kinds && !kinds.has(node.kind)) {
+            continue;
+        }
+        if (filter.audience && !node.audience.includes(filter.audience)) {
+            continue;
+        }
+        if (filter.files && !node.file) {
+            continue;
+        }
+        const hits = [];
+        let total = 0;
+        if (fields.has('text')) {
+            total += scan(hits, 'text', node.text, match, cap);
+        }
+        // Indented rather than compact, so a line number names a key someone
+        // can search for: one-line JSON would make every hit "line 1".
+        if (fields.has('metadata') && node.metadata) {
+            total += scan(hits, 'metadata', JSON.stringify(node.metadata, null, 4), match, cap);
+        }
+        if (fields.has('file') && node.file) {
+            const body = await read(store.dir, node.file, budget);
+            if (body.omitted) {
+                skipped.push({ id: node.id, path: node.file.path, reason: body.omitted });
+            }
+            else {
+                budget -= body.bytes;
+                total += scan(hits, 'file', body.text, match, cap);
+            }
+        }
+        if (hits.length) {
+            matches.push({ node, hits, more: total - hits.length, stale });
+        }
+    }
+    // Newest first, as `zen memory ls` lists them: when a pattern matches an
+    // old node and the node that corrected it, the correction should read first.
+    matches.sort((a, b) => b.node.createdAt.localeCompare(a.node.createdAt) || a.node.id.localeCompare(b.node.id));
+    const found = matches.length;
+    const limit = filter.limit;
+    const truncated = limit !== undefined && limit >= 0 && limit < found;
+    return { found, matches: truncated ? matches.slice(0, limit) : matches, truncated, skipped };
+}
+// ---------------------------------------------------------------------------
+/**
+ * A bad pattern is the model's mistake to fix, and `MemoryError` is the one
+ * shape both surfaces already know how to hand back rather than throw.
+ */
+function compile(pattern, options) {
+    try {
+        return finder(pattern, options);
+    }
+    catch (err) {
+        if (err instanceof PatternError) {
+            throw new MemoryError(err.message, options.regex
+                ? 'fix the expression, or drop `regex` to search for the literal text'
+                : 'pass a shorter, non-empty pattern');
+        }
+        throw err;
+    }
+}
+/** Every matching line, of which the first `cap` are kept; the count is of all of them. */
+function scan(out, where, body, match, cap) {
+    const lines = body.split('\n');
+    let total = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const at = match(lines[i]);
+        if (at < 0) {
+            continue;
+        }
+        total++;
+        if (out.length < cap) {
+            out.push({ where, line: i + 1, text: excerpt(lines[i], at) });
+        }
+    }
+    return total;
+}
+/**
+ * The line, windowed onto the match. Clipping from the front would be right for
+ * prose and useless for the one case that most needs it — a minified file or a
+ * long serialized value, where the hit is thousands of characters in.
+ */
+function excerpt(line, at) {
+    const text = line.replace(/\t/g, '    ').trimEnd();
+    if (text.length <= EXCERPT) {
+        return text;
+    }
+    const start = Math.max(0, Math.min(at - Math.floor(EXCERPT / 3), text.length - EXCERPT));
+    const end = start + EXCERPT;
+    return (start > 0 ? '…' : '') + text.slice(start, end) + (end < text.length ? '…' : '');
+}
+/**
+ * A remembered file's bytes, or why they were not read. The recorded size is
+ * not trusted for the decision — what is on disk is what would have to be
+ * scanned — and a skip is reported rather than swallowed, because a grep that
+ * silently did not look is worse than one that refused to.
+ */
+async function read(dir, file, budget) {
+    const path = hostPath(dir, file);
+    let size;
+    try {
+        size = (await stat(path)).size;
+    }
+    catch {
+        return { omitted: 'missing' };
+    }
+    if (size > Math.min(MAX_GREP_FILE_BYTES, budget)) {
+        return { omitted: 'too-big' };
+    }
+    let buf;
+    try {
+        buf = await readFile(path);
+    }
+    catch {
+        return { omitted: 'unreadable' };
+    }
+    // A NUL byte in the first few KiB is the cheap, boring test for "this is
+    // not text", and it is right about every format anyone remembers on purpose.
+    if (buf.subarray(0, 8192).includes(0)) {
+        return { omitted: 'binary' };
+    }
+    return { text: buf.toString('utf8'), bytes: buf.byteLength };
+}
+//# sourceMappingURL=grep.js.map

package/dist/memory/index.d.ts

@@ -73,8 +73,16 @@ export declare class MemoryIndex {
     get graph(): MemoryGraph;
     get kinds(): readonly string[];
     get relations(): readonly string[];
-    /** Read-only: a search returns nodes the model has not read, so nothing is touched. */
-    search(query: MemoryQuery, sees: readonly string[]): Promise<Recollection>;
+    /**
+     * Read-only: a search returns nodes the model has not read, so nothing is
+     * touched. `stale` is the audit view — it puts back the superseded nodes
+     * recall drops, which is the only way to see the correction and the thing
+     * it corrected at once. No tool passes it; it is for `zen memory search`,
+     * where the question is why a run recalled what it did.
+     */
+    search(query: MemoryQuery, sees: readonly string[], opts?: {
+        stale?: boolean;
+    }): Promise<Recollection>;
     /**
      * Listed rather than ranked, and deliberately not routed through `recall`:
      * ranking decays by `lastUsedAt`, only `memory_load` bumps that, and a

package/dist/memory/index.js

@@ -13,7 +13,7 @@ import { ALL_AGENTS, MEMORY_KINDS, MEMORY_RELATIONS, MemoryError, PREFERENCE_KIN
 // `ref` — it cannot know an id that has not been minted — and edges join refs
 // and existing ids indiscriminately, so a whole subgraph arrives in one call.
 // Everything is validated, and every source file stat-ed, before the first
-// mutation, on the same principle as `runPatch` in tools/workspace.ts: a
+// mutation, on the same principle as `runPatch` in tools/files.ts: a
 // commit that fails must leave no half-built graph behind.
 // ---------------------------------------------------------------------------
 /** Past this a `load` returns the path and lets the agent open it itself. */
@@ -44,8 +44,14 @@ export class MemoryIndex {
     get relations() {
         return [...this.#relations];
     }
-    /** Read-only: a search returns nodes the model has not read, so nothing is touched. */
-    async search(query, sees) {
+    /**
+     * Read-only: a search returns nodes the model has not read, so nothing is
+     * touched. `stale` is the audit view — it puts back the superseded nodes
+     * recall drops, which is the only way to see the correction and the thing
+     * it corrected at once. No tool passes it; it is for `zen memory search`,
+     * where the question is why a run recalled what it did.
+     */
+    async search(query, sees, opts = {}) {
         const vector = query.text ? await this.#embed([query.text], 'query') : undefined;
         return recall({
             graph: this.graph,
@@ -53,6 +59,7 @@ export class MemoryIndex {
             sees,
             vector: vector?.[0],
             vectors: this.store.vectors,
+            stale: opts.stale,
         });
     }
     /**
@@ -92,7 +99,11 @@ export class MemoryIndex {
                     : undefined,
             });
         }
-        await this.store.commit();
+        // The bump is bookkeeping, and persisting it is what would make a
+        // read-only recall rewrite the graph every other run is reading.
+        if (!this.store.readOnly) {
+            await this.store.commit();
+        }
         return out;
     }
     async commit(tx, opts) {

package/dist/memory/merge.js

@@ -4,6 +4,7 @@ import { join, resolve } from 'node:path';
 import { hostPath } from "./files.js";
 import { DUPLICATE_SCORE, flatten } from "./index.js";
 import { MANIFEST_FILE, MemoryStore, lockHolder } from "./store.js";
+import { comparable, sameContent, twinKey } from "./twin.js";
 import { MemoryError } from "./types.js";
 // ---------------------------------------------------------------------------
 // Folding several memories into one
@@ -251,15 +252,6 @@ function twinOf(target, src, node, lexical, stale) {
     const id = lexical.get(twinKey(node));
     return id && !stale.has(id) ? id : undefined;
 }
-function comparable(a, b) {
-    return a.id !== b.id && a.kind === b.kind && !a.file && audienceKey(a) === audienceKey(b);
-}
-function twinKey(node) {
-    return [node.kind, audienceKey(node), flatten(node.text)].join('\u0000');
-}
-function audienceKey(node) {
-    return [...node.audience].sort().join('|');
-}
 function carryVector(from, to, id) {
     const vector = from.vectors?.get(id);
     const block = to.vectors;
@@ -284,28 +276,6 @@ function reconcile(keep, other) {
 function newer(a, b) {
     return a.revision === b.revision ? a.updatedAt > b.updatedAt : a.revision > b.revision;
 }
-function sameContent(a, b) {
-    return (a.kind === b.kind &&
-        a.text === b.text &&
-        audienceKey(a) === audienceKey(b) &&
-        a.file?.sha256 === b.file?.sha256 &&
-        deep(a.metadata, b.metadata));
-}
-function deep(a, b) {
-    if (a === b) {
-        return true;
-    }
-    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) {
-        return false;
-    }
-    if (Array.isArray(a) !== Array.isArray(b)) {
-        return false;
-    }
-    const left = a;
-    const right = b;
-    const keys = Object.keys(left);
-    return keys.length === Object.keys(right).length && keys.every((k) => deep(left[k], right[k]));
-}
 /** Stat every file the merge would copy before it copies any of them. */
 async function checkFiles(plan) {
     for (const planned of plan.values()) {

package/dist/memory/recall.d.ts

@@ -1,7 +1,7 @@
 import type { MemoryGraph } from './graph.ts';
 import { type MemoryQuery, type Recollection, type ScoredNode } from './types.ts';
 import { type VectorBlock } from './vectors.ts';
-export declare const DEFAULT_SEEDS = 5;
+export declare const DEFAULT_SEEDS = 10;
 export declare const DEFAULT_MAX_HOPS = 2;
 /** Past roughly this many nodes a rendered graph reads as soup, not structure. */
 export declare const DEFAULT_MAX_NODES = 25;

package/dist/memory/recall.js

@@ -17,7 +17,7 @@ import { overlap, recencyDecay, tokenize } from "./vectors.js";
 // it replaced from every recall, while the history stays on disk for anyone
 // asking how the correction came about.
 // ---------------------------------------------------------------------------
-export const DEFAULT_SEEDS = 5;
+export const DEFAULT_SEEDS = 10;
 export const DEFAULT_MAX_HOPS = 2;
 /** Past roughly this many nodes a rendered graph reads as soup, not structure. */
 export const DEFAULT_MAX_NODES = 25;