@nxuss/lemma 1.39.0 → 1.41.0

package/dist/esm/subconscious/TheBrainV2.js

@@ -918,6 +918,31 @@ function hashSymbolsForFreshness(refs) {
     }
     return hashes;
 }
+/**
+ * Splits symbol refs into the ones the resolver can actually locate and the ones it cannot
+ * (a typo, a rename, a file that is not code). An unlocatable symbol hashes MISSING when it is
+ * stored and MISSING again when it is verified, so MISSING === MISSING and the memory could
+ * never go stale — the worst way for freshness to fail, because the reply still says
+ * "tracking N symbols". Callers track the whole file for those instead and say so.
+ */
+function partitionSymbolRefs(refs) {
+    const resolved = [];
+    const unresolved = [];
+    for (const ref of refs) {
+        const hash = defaultLocalResolver.hashSymbol(path.resolve(ref.filePath), ref.symbolName);
+        (hash && hash.raw !== 'MISSING' ? resolved : unresolved).push(ref);
+    }
+    return { resolved, unresolved };
+}
+/** `files` minus those that contain one of the tracked `symbols`; `dropped` lists what was removed. */
+function dropFilesCoveredBySymbols(files, symbols) {
+    const covered = new Set(symbols.map((r) => path.resolve(r.filePath)));
+    const kept = [];
+    const dropped = [];
+    for (const f of files ?? [])
+        (covered.has(path.resolve(f)) ? dropped : kept).push(f);
+    return { files: kept, dropped };
+}
 /**
  * Fase D companion to hashSymbolsForFreshness: same symbols, hashed after
  * normalizeForFreshness strips comments/whitespace. Always computed alongside the raw hash
@@ -1120,7 +1145,7 @@ export function checkEntryFreshness(entry, resolver, resolveNode, depth = 0, vis
                 unverifiedFiles.push(relLabel(abs)); // fail-closed: cannot verify ⇒ not fresh
                 continue;
             }
-            if (currentHash !== storedHash)
+            if (currentHash !== storedHash && resolver.hashFileLegacy?.(abs) !== storedHash)
                 staleFiles.push(relLabel(abs));
         }
     }
@@ -1135,7 +1160,7 @@ export function checkEntryFreshness(entry, resolver, resolveNode, depth = 0, vis
                 unverifiedFiles.push(label); // fail-closed: cannot verify ⇒ not fresh
                 continue;
             }
-            if (currentPair.raw === storedHash)
+            if (currentPair.raw === storedHash || currentPair.rawLegacy === storedHash)
                 continue;
             if (semanticDiff) {
                 const storedNormalized = entry.symbolNormalizedHashes?.[key];
@@ -1258,7 +1283,7 @@ export function checkClaimFreshness(claim, resolver, semanticDiff = false) {
                 unverifiedFiles.push(relLabel(abs));
                 continue;
             }
-            if (currentHash !== storedHash)
+            if (currentHash !== storedHash && resolver.hashFileLegacy?.(abs) !== storedHash)
                 staleFiles.push(relLabel(abs));
         }
     }
@@ -1273,7 +1298,7 @@ export function checkClaimFreshness(claim, resolver, semanticDiff = false) {
                 unverifiedFiles.push(label);
                 continue;
             }
-            if (currentPair.raw === storedHash)
+            if (currentPair.raw === storedHash || currentPair.rawLegacy === storedHash)
                 continue;
             if (semanticDiff) {
                 const storedNormalized = claim.symbolNormalizedHashes?.[key];
@@ -1310,6 +1335,13 @@ export class TheBrainV2 {
         this.diskStamp = null;
         /** id -> ISO deletion time, for ids that must not come back through a merge. */
         this.tombstones = new Map();
+        /**
+         * Ids a restore brought back that the on-disk meta.json still lists as deleted. save() absorbs
+         * the peers' tombstones first, which re-added the one restore had just removed and dropped the
+         * entry again: "Restored memory…" was followed by the memory vanishing at the next save. Skipped
+         * by the absorb until a save has written meta.json without them.
+         */
+        this.revived = new Set();
         /**
          * Last integrity incident on the corpus files (corrupt main file, undecryptable
          * envelope, skipped sync). Set by load()/save()/syncIfChanged(), never cleared
@@ -1564,6 +1596,7 @@ export class TheBrainV2 {
             }));
             this.diskStamp = stampOf(ENTRIES_FILE);
             this.dirty = false;
+            this.revived.clear(); // meta.json no longer lists them
         }
         catch { /* fail silently */ }
         finally {
@@ -1582,6 +1615,8 @@ export class TheBrainV2 {
      */
     absorbPeerTombstones() {
         for (const [id, at] of readTombstonesFile()) {
+            if (this.revived.has(id))
+                continue;
             if (!this.tombstones.has(id))
                 this.tombstones.set(id, at);
             const entry = this.entries.get(id);
@@ -1660,6 +1695,24 @@ export class TheBrainV2 {
                 };
             }
         }
+        let unresolvedSymbols;
+        let narrowedFiles;
+        if (symbolRefs && symbolRefs.length > 0 && !options.evidence?.symbols) {
+            const split = partitionSymbolRefs(symbolRefs);
+            if (split.unresolved.length > 0) {
+                unresolvedSymbols = split.unresolved;
+                symbolRefs = split.resolved;
+                filePaths = [...new Set([...(filePaths ?? []), ...split.unresolved.map((r) => r.filePath)])];
+            }
+            // A file whose symbols are tracked is not also tracked whole: the symbol is the narrower
+            // claim, and the whole file would stale the memory on every unrelated edit to it (callers
+            // routinely pass both: the file the symbol lives in, and the symbol).
+            const narrowed = dropFilesCoveredBySymbols(filePaths, split.resolved);
+            if (narrowed.dropped.length > 0) {
+                filePaths = narrowed.files;
+                narrowedFiles = narrowed.dropped;
+            }
+        }
         // Conflict check: another entry about the exact same symbol, with the opposite
         // outcome, is worth flagging before this one is even written — two memories about one
         // function disagreeing on whether an approach works is a trap for whoever searches next.
@@ -1741,7 +1794,7 @@ export class TheBrainV2 {
         this.recalcAvgDocLength();
         this.evictIfOverCapacity();
         this.scheduleSave();
-        return { stored: true, reason: 'Stored successfully', id, conflicts, textConflicts, redactions };
+        return { stored: true, reason: 'Stored successfully', id, conflicts, textConflicts, redactions, ...(unresolvedSymbols ? { unresolvedSymbols } : {}), ...(narrowedFiles ? { narrowedFiles } : {}) };
     }
     /**
      * Evict the lowest-value entries once the Brain is over capacity. Value = hits (proven
@@ -2466,8 +2519,10 @@ export class TheBrainV2 {
             this.bloom.add(entry.query.trim().toLowerCase().substring(0, 200));
         }
         // A restored id was deliberately brought back — its old tombstone must not suppress it.
-        for (const id of this.entries.keys())
-            this.tombstones.delete(id);
+        for (const id of this.entries.keys()) {
+            if (this.tombstones.delete(id))
+                this.revived.add(id);
+        }
         this.scheduleSave();
         return { ok: true, restored: entries.size, message: `Restored ${entries.size} memories from snapshot "${name}". The pre-restore state was snapshotted, so this is undoable too.` };
     }
@@ -2550,6 +2605,7 @@ export class TheBrainV2 {
         }
         this.bloom.add(revived.query.trim().toLowerCase().substring(0, 200));
         this.tombstones.delete(id);
+        this.revived.add(id);
         this.recalcAvgDocLength();
         this.scheduleSave();
         return { ok: true, message: `Restored memory "${id}" from the trash (${revived.hits || 0} prior reuse(s) kept). Its freshness will be re-judged on the next search.` };
@@ -2644,12 +2700,16 @@ export class TheBrainV2 {
         if (hasNewTracking) {
             // Re-point: the new tracking replaces the old wholesale rather than merging, because
             // a moved symbol's old path must stop counting against the entry forever.
-            entry.fileHashes = opts.filePaths?.length ? hashFilesForFreshness(opts.filePaths) : undefined;
-            entry.symbolHashes = opts.symbols?.length ? hashSymbolsForFreshness(opts.symbols) : undefined;
-            entry.symbolNormalizedHashes = opts.symbols?.length ? hashSymbolsNormalizedForFreshness(opts.symbols) : undefined;
-            for (const p of opts.filePaths || [])
+            // A symbol the resolver cannot locate would be "fresh" forever (MISSING === MISSING), so
+            // its file is tracked whole instead, and the label says file, not symbol.
+            const split = partitionSymbolRefs(opts.symbols ?? []);
+            const files = dropFilesCoveredBySymbols([...new Set([...(opts.filePaths ?? []), ...split.unresolved.map((r) => r.filePath)])], split.resolved).files;
+            entry.fileHashes = files.length ? hashFilesForFreshness(files) : undefined;
+            entry.symbolHashes = split.resolved.length ? hashSymbolsForFreshness(split.resolved) : undefined;
+            entry.symbolNormalizedHashes = split.resolved.length ? hashSymbolsNormalizedForFreshness(split.resolved) : undefined;
+            for (const p of files)
                 retracked.push(rel(path.resolve(p)));
-            for (const s of opts.symbols || [])
+            for (const s of split.resolved)
                 retracked.push(`${rel(path.resolve(s.filePath))}::${s.symbolName}`);
         }
         else {
@@ -2667,10 +2727,19 @@ export class TheBrainV2 {
                     const sep = key.lastIndexOf('::');
                     return { filePath: key.substring(0, sep), symbolName: key.substring(sep + 2) };
                 });
-                entry.symbolHashes = hashSymbolsForFreshness(refs);
-                entry.symbolNormalizedHashes = hashSymbolsNormalizedForFreshness(refs);
+                // A symbol that no longer resolves keeps the hash it was stored with: re-hashing it would
+                // write MISSING, which is what it will read as forever, and bless a deleted symbol.
+                const gone = new Set(partitionSymbolRefs(refs).unresolved.map((r) => `${path.resolve(r.filePath)}::${r.symbolName}`));
+                const rehashed = hashSymbolsForFreshness(refs);
+                const rehashedNorm = hashSymbolsNormalizedForFreshness(refs);
+                for (const key of gone) {
+                    rehashed[key] = entry.symbolHashes[key] ?? rehashed[key];
+                    rehashedNorm[key] = entry.symbolNormalizedHashes?.[key] ?? rehashedNorm[key];
+                }
+                entry.symbolHashes = rehashed;
+                entry.symbolNormalizedHashes = rehashedNorm;
                 for (const r of refs)
-                    retracked.push(`${rel(r.filePath)}::${r.symbolName}`);
+                    retracked.push(`${rel(r.filePath)}::${r.symbolName}${gone.has(`${path.resolve(r.filePath)}::${r.symbolName}`) ? ' (no longer found — stays stale)' : ''}`);
             }
             if (entry.claims) {
                 for (const claim of entry.claims) {
@@ -3352,6 +3421,11 @@ export class TheBrainV2 {
      */
     getStats(options = {}) {
         this.syncIfChanged();
+        // With projectId, every per-memory figure covers that project's memories only. Corpus-wide
+        // ones (term index, bloom filter, file size, snapshots, tombstones) stay what they are, and
+        // `unscopedEntries` still counts the memories that predate scoping, which belong to no project.
+        const scopeId = options.projectId;
+        let inScope = 0;
         const base = {
             totalEntries: this.entries.size,
             totalTerms: this.invertedIndex.size,
@@ -3377,14 +3451,17 @@ export class TheBrainV2 {
         const reuseBySource = {};
         const projects = new Set();
         for (const entry of this.entries.values()) {
-            if (!entry.hits)
-                neverHit++;
-            if (entry.demerits)
-                downvoted++;
             if (entry.projectId === undefined)
                 unscoped++;
             else
                 projects.add(entry.projectId);
+            if (scopeId !== undefined && entry.projectId !== scopeId)
+                continue;
+            inScope++;
+            if (!entry.hits)
+                neverHit++;
+            if (entry.demerits)
+                downvoted++;
             if (trackedArtifactCount(entry) === 0)
                 untracked++;
             else if (entry.filePaths !== undefined || entry.symbols !== undefined ||
@@ -3425,7 +3502,11 @@ export class TheBrainV2 {
         base.downvoted = downvoted;
         base.bySource = bySource;
         base.reuseBySource = reuseBySource;
-        base.projects = projects.size;
+        if (scopeId !== undefined) {
+            base.totalEntries = inScope;
+            base.scopedTo = scopeId;
+        }
+        base.projects = scopeId !== undefined ? (projects.has(scopeId) ? 1 : 0) : projects.size;
         base.unscopedEntries = unscoped;
         base.untrackedEntries = untracked;
         base.withClearPaths = withClearPaths;