hippo-memory 1.69.0 → 1.70.0

package/dist/{churn-git.js → learn/churn-git.js}

@@ -1,8 +1,10 @@
-/** Git subprocess helpers for churn-staleness (src/invalidation.ts). */
+/** Git subprocess helpers for churn-staleness (src/learn/invalidation.ts). */
 import { execFileSync } from 'child_process';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import { DAY_MS } from '../util/time.js';
+import { errorMessage } from '../util/log.js';
 // A `git log --name-status` dump can run to tens of MB; default 1MB pipe would truncate it.
 const GIT_MAX_BUFFER = 64 * 1024 * 1024;
 // Longer than the 10 s of one-line git reads because a full log dump on a large repo is slow, yet bounded so a wedged git cannot stall sleep.
@@ -15,7 +17,7 @@ function runGit(args, repoRoot) {
         return execFileSync('git', args, { cwd: repoRoot, encoding: 'utf8', maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, windowsHide: true });
     }
     catch (err) {
-        throw new GitReadError(`git ${args.join(' ')} failed: ${err instanceof Error ? err.message : String(err)}`);
+        throw new GitReadError(`git ${args.join(' ')} failed: ${errorMessage(err)}`, { cause: err });
     }
 }
 // git grep exits 1 for "no match" -- a normal empty result, not a failure.
@@ -28,7 +30,7 @@ function runGitGrepOrEmpty(args, repoRoot) {
         const status = err.status;
         if (status === 1)
             return '';
-        throw new GitReadError(`git ${args.join(' ')} failed: ${err instanceof Error ? err.message : String(err)}`);
+        throw new GitReadError(`git ${args.join(' ')} failed: ${errorMessage(err)}`, { cause: err });
     }
 }
 // ls-tree, not ls-files: the index can hold staged adds/deletes that HEAD does not.
@@ -38,7 +40,7 @@ export function gitLsFilesAtHead(repoRoot) {
 }
 // 1-day buffer guards against git's --since boundary excluding a commit dated exactly at the anchor.
 export function fetchChurnWindowLog(repoRoot, sinceIso) {
-    const buffered = new Date(new Date(sinceIso).getTime() - 24 * 60 * 60 * 1000).toISOString();
+    const buffered = new Date(new Date(sinceIso).getTime() - DAY_MS).toISOString();
     const raw = runGit(
     // --first-parent -m: a merge's changes land as one diff against its mainline parent.
     ['log', '--no-renames', '--first-parent', '-m', `--since=${buffered}`, '--pretty=format:%x01%H%x02%cI', '--name-status'], repoRoot);

package/dist/{extract.d.ts → learn/extract.d.ts}

@@ -1,4 +1,4 @@
-import { MemoryEntry, EmotionalValence } from './memory.js';
+import { MemoryEntry, EmotionalValence } from '../core/memory.js';
 export interface ExtractedFact {
     content: string;
     tags: string[];

package/dist/learn/extract.js

@@ -0,0 +1,125 @@
+import { Layer, createMemory } from '../core/memory.js';
+import { writeEntry } from '../store/entry-writes.js';
+import { loadConfig } from '../core/config.js';
+import { RejectedValueError } from '../store/rejection.js';
+import { redactSecretsStrict } from '../util/secret-detect.js';
+import { describeMessageFailure, sendAnthropicMessage } from '../util/anthropic-messages.js';
+import { neverAutoShareTags } from '../sharing/shared.js';
+import { errorMessage, log } from '../util/log.js';
+import { isJsonString } from '../util/json.js';
+import { certainDefect } from '../core/memory-quality.js';
+const EXTRACTION_PROMPT = `You are extracting factual statements from a conversation or memory entry. Extract 1-8 standalone factual statements that would be useful to remember later.
+
+Rules:
+- Each fact must be a complete, standalone sentence
+- Include the speaker's name in every fact (e.g. "Alice prefers..." not "She prefers...")
+- Preserve specific details: names, numbers, dates, paths, IDs
+- Return a JSON array of objects with: content (string), tags (array of "speaker:X" and "topic:Y" strings), valence ("neutral", "positive", "negative", or "critical")
+- Return an empty array [] for small talk with no extractable facts
+- Output ONLY the JSON array, no preamble or explanation
+
+Input text:
+`;
+// Output budget for one extraction reply.
+const EXTRACTION_MAX_TOKENS = 1200;
+export async function extractFacts(text, opts) {
+    const reply = await sendAnthropicMessage({
+        apiKey: opts.apiKey,
+        model: opts.model,
+        maxTokens: EXTRACTION_MAX_TOKENS,
+        prompt: EXTRACTION_PROMPT + redactSecretsStrict(text),
+        fetcher: opts.fetcher,
+    });
+    if (!reply.ok) {
+        opts.onError?.(describeMessageFailure(reply.failure));
+        return [];
+    }
+    try {
+        const raw = reply.text;
+        if (!raw)
+            return [];
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parseExtractedFacts(parsed);
+    }
+    catch (err) {
+        opts.onError?.(`unparseable response: ${errorMessage(err)}`);
+        return [];
+    }
+}
+function parseExtractedFacts(parsed) {
+    const validValences = new Set(['neutral', 'positive', 'negative', 'critical']);
+    const facts = [];
+    for (const item of parsed) {
+        if (facts.length >= 8)
+            break;
+        if (!item ||
+            !isJsonString(item.content) ||
+            item.content.length < 3)
+            continue;
+        const itemTags = item.tags;
+        const tags = Array.isArray(itemTags)
+            ? itemTags.filter((t) => isJsonString(t))
+            : [];
+        // SAFETY: the isJsonString + validValences.has guard below confirms item.valence is one of the four literal strings of EmotionalValence.
+        const valence = isJsonString(item.valence) && validValences.has(item.valence)
+            ? item.valence
+            : 'neutral';
+        facts.push({ content: item.content, tags, valence });
+    }
+    return facts;
+}
+const INHERITABLE_PREFIXES = ['conv:', 'session:', 'scope:', 'path:'];
+export function storeExtractedFacts(hippoRoot, source, facts) {
+    const inheritedTags = [
+        ...source.tags.filter((t) => INHERITABLE_PREFIXES.some((p) => t.startsWith(p))),
+        ...neverAutoShareTags([source]),
+    ];
+    const entries = [];
+    let rejected = 0;
+    const baseHalfLifeDays = loadConfig(hippoRoot).defaultHalfLifeDays;
+    for (const fact of facts) {
+        const defect = certainDefect(fact.content);
+        if (defect !== null) {
+            log.warn(`storeExtractedFacts: skipped automatic quality defect (${defect})`);
+            continue;
+        }
+        const entry = buildExtractedEntry(fact, source, inheritedTags, baseHalfLifeDays);
+        // A refusal is per-VALUE: one rejected fact must not
+        // drop the rest of this batch. writeEntry has already audited the
+        // refusal (reject_refusal) before rethrowing, so skip-and-count here.
+        try {
+            writeEntry(hippoRoot, entry);
+        }
+        catch (err) {
+            if (err instanceof RejectedValueError) {
+                rejected++;
+                continue;
+            }
+            throw err;
+        }
+        entries.push(entry);
+    }
+    if (rejected > 0) {
+        log.warn(`storeExtractedFacts: skipped ${rejected} rejected value(s)`);
+    }
+    return entries;
+}
+function buildExtractedEntry(fact, source, inheritedTags, baseHalfLifeDays) {
+    const tags = ['extracted', ...inheritedTags, ...fact.tags];
+    return { ...createMemory(fact.content, {
+            layer: Layer.Semantic,
+            tags,
+            emotional_valence: fact.valence,
+            confidence: 'inferred',
+            source: source.source,
+            extracted_from: source.id,
+            scope: source.scope,
+            // Without it createMemory stamps 'default', and extracted facts leave
+            // the tenant of the episodic memory they were extracted from.
+            tenantId: source.tenantId,
+            baseHalfLifeDays,
+        }), origin_project: source.origin_project };
+}
+//# sourceMappingURL=extract.js.map

package/dist/{forward-claim-detector.d.ts → learn/forward-claim-detector.d.ts}

@@ -11,7 +11,7 @@
  * Kahneman 2003 inside-vs-outside view).
  *
  * Iteration signal: the `recall_autodebias_hint_no_class_match` audit op
- * (emitted by computePlanningFallacyOutput when a phrase matches but no class
+ * (emitted by recall when a phrase matches but no class
  * resolves) is the telemetry channel for deciding whether to add an
  * embedding-based detector.
  */

package/dist/{forward-claim-detector.js → learn/forward-claim-detector.js}

@@ -11,7 +11,7 @@
  * Kahneman 2003 inside-vs-outside view).
  *
  * Iteration signal: the `recall_autodebias_hint_no_class_match` audit op
- * (emitted by computePlanningFallacyOutput when a phrase matches but no class
+ * (emitted by recall when a phrase matches but no class
  * resolves) is the telemetry channel for deciding whether to add an
  * embedding-based detector.
  */

package/dist/{invalidation.d.ts → learn/invalidation.d.ts}

@@ -1,3 +1,4 @@
+import { type MemoryEntry } from '../core/memory.js';
 export interface InvalidationTarget {
     from: string;
     to: string | null;
@@ -38,6 +39,9 @@ export declare function extractInvalidationTarget(message: string): Invalidation
  * auto-learn-from-git path) inherit this contract.
  */
 export declare function invalidateMatching(hippoRoot: string, target: InvalidationTarget, tenantId?: string, options?: InvalidationOptions): InvalidationResult;
+/** invalidateMatching for a batch: matches against `live`, the caller's list of the tenant's rows, and keeps it current.
+ *  Each match is read again before it is weakened, so a row another writer changed since the list was read is never written back stale. */
+export declare function invalidateMatchingAmong(hippoRoot: string, live: MemoryEntry[], target: InvalidationTarget, tenantId?: string): InvalidationResult;
 export interface ChurnRefs {
     paths: string[];
     symbols: string[];

package/dist/{invalidation.js → learn/invalidation.js}

@@ -1,9 +1,9 @@
-import { writeEntryOn } from './store/entry-writes.js';
-import { loadAllEntries, selectEntriesByIds } from './store/entry-reads.js';
-import { openStore } from './store/open.js';
-import { openHippoDb, closeHippoDb } from './db.js';
-import { CHURN_STALE_TAG } from './memory.js';
+import { addTagToEntries, writeEntriesSeparately } from '../store/entry-writes.js';
+import { confirmedOutcomeTimes } from '../store/audit.js';
+import { chunked, loadAllEntries, loadEntriesByIds } from '../store/entry-reads.js';
+import { CHURN_STALE_TAG } from '../core/memory.js';
 import { GitReadError, gitLsFilesAtHead, fetchChurnWindowLog, gitGrepPresence, resolveCommitBefore, packageScriptsAt, } from './churn-git.js';
+const HEADLINE_CHARS = 60;
 /**
  * Extract what was replaced/removed from a commit message.
  * Returns null if the commit isn't a breaking/migration change.
@@ -63,7 +63,33 @@ export function invalidateMatching(hippoRoot, target, tenantId, options) {
     // (host-wide invalidation across all tenants in the store).
     // options.onlyId resolves by FILTERING this tenant-scoped list — never a
     // direct id lookup — so an id from another tenant is invisible here.
-    const entries = loadAllEntries(hippoRoot, tenantId);
+    const { result, weakened } = weakenMatches(loadAllEntries(hippoRoot, tenantId), target, options);
+    writeEntriesSeparately(hippoRoot, weakened);
+    return result;
+}
+/** invalidateMatching for a batch: matches against `live`, the caller's list of the tenant's rows, and keeps it current.
+ *  Each match is read again before it is weakened, so a row another writer changed since the list was read is never written back stale. */
+export function invalidateMatchingAmong(hippoRoot, live, target, tenantId) {
+    const seen = weakenMatches(live, target, { dryRun: true }).result;
+    const ids = [...seen.targets, ...seen.skippedPinned];
+    // loadEntriesByIds reads at most 500 ids a call.
+    const fresh = new Map(chunked(ids, 500).flatMap((chunk) => loadEntriesByIds(hippoRoot, chunk, tenantId)).map((entry) => [entry.id, entry]));
+    const { result, weakened } = weakenMatches(ids.flatMap((id) => fresh.get(id) ?? []), target);
+    writeEntriesSeparately(hippoRoot, weakened);
+    const byId = new Map(weakened.map((entry) => [entry.id, entry]));
+    for (let i = 0; i < live.length; i++)
+        live[i] = byId.get(live[i].id) ?? live[i];
+    return result;
+}
+function referencesPattern(entry, fromTokens, exactTag) {
+    const contentTokens = invalidationTokenize(entry.content);
+    const tagTokens = entry.tags.map(t => t.toLowerCase());
+    const tokenMatch = matchScore(fromTokens, contentTokens);
+    const tagMatch = tagTokens.includes(exactTag);
+    return tokenMatch >= 0.5 || tagMatch;
+}
+/** The match pass: weakens each unpinned match in place and returns them, writing nothing. */
+function weakenMatches(entries, target, options) {
     const fromTokens = invalidationTokenize(target.from);
     const exactTag = target.from.toLowerCase().trim();
     const dryRun = options?.dryRun === true;
@@ -80,15 +106,8 @@ export function invalidateMatching(hippoRoot, target, tenantId, options) {
             if (entry.id !== options.onlyId)
                 continue;
         }
-        else {
-            const contentTokens = invalidationTokenize(entry.content);
-            const tagTokens = entry.tags.map(t => t.toLowerCase());
-            // Check if the memory references the old pattern
-            const tokenMatch = matchScore(fromTokens, contentTokens);
-            const tagMatch = tagTokens.includes(exactTag);
-            if (!(tokenMatch >= 0.5 || tagMatch))
-                continue;
-        }
+        else if (!referencesPattern(entry, fromTokens, exactTag))
+            continue;
         // Pinned check runs AFTER matching so pinned would-be targets are
         // observable in skippedPinned (pattern mode and onlyId mode alike).
         if (entry.pinned) {
@@ -99,7 +118,7 @@ export function invalidateMatching(hippoRoot, target, tenantId, options) {
         result.targets.push(entry.id);
         result.preview.push({
             id: entry.id,
-            headline: entry.content.replace(/\s+/g, ' ').slice(0, 60),
+            headline: entry.content.replace(/\s+/g, ' ').slice(0, HEADLINE_CHARS),
         });
         if (dryRun)
             continue;
@@ -110,21 +129,7 @@ export function invalidateMatching(hippoRoot, target, tenantId, options) {
         }
         weakened.push(entry);
     }
-    writeEntriesOnOneHandle(hippoRoot, weakened);
-    return result;
-}
-/** Each row commits alone, as a run of writeEntry calls would, but the store opens once. */
-function writeEntriesOnOneHandle(hippoRoot, entries) {
-    if (entries.length === 0)
-        return;
-    const db = openStore(hippoRoot);
-    try {
-        for (const entry of entries)
-            writeEntryOn(db, hippoRoot, entry);
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    return { result, weakened };
 }
 const STOPWORDS = new Set([
     'the', 'an', 'is', 'it', 'in', 'on', 'at', 'to', 'for', 'of', 'by',
@@ -219,22 +224,6 @@ function resolveTrackedPath(token, repoRoot, projectName, index) {
     }
     return null;
 }
-// Anchor SQL runs on its own handle (closed in finally); queryAuditEvents is NOT
-// reused here because its 10k-row cap would silently miss old confirmations.
-function queryConfirmedAt(hippoRoot, tenantId) {
-    const db = openHippoDb(hippoRoot);
-    try {
-        // SAFETY: the SELECT list above is exactly target_id and ts; no other shape reaches this cast.
-        const rows = db.prepare(`SELECT target_id, MAX(ts) AS ts FROM audit_log
-       WHERE tenant_id = ? AND op = 'outcome' AND target_id IS NOT NULL
-         AND json_extract(metadata_json, '$.good') = 1
-       GROUP BY target_id`).all(tenantId);
-        return new Map(rows.map((r) => [r.target_id, r.ts]));
-    }
-    finally {
-        closeHippoDb(db);
-    }
-}
 function emptyChurnResult(dryRun, skippedPinned = [], error) {
     const result = { checked: 0, marked: 0, alreadyMarked: 0, skippedPinned, dryRun, preview: [] };
     if (error !== undefined)
@@ -262,25 +251,8 @@ function collectChurnCandidates(entries, opts) {
     }
     return { candidates, skippedPinned };
 }
-function loadChurnGitView(repoRoot, projectName, candidates, anchorOf, needs) {
-    const headFiles = gitLsFilesAtHead(repoRoot);
-    let windowLog = [];
-    if (needs.paths) {
-        const minAnchor = candidates.reduce((min, c) => {
-            const a = anchorOf(c.entry);
-            return min === '' || a < min ? a : min;
-        }, '');
-        windowLog = fetchChurnWindowLog(repoRoot, minAnchor);
-    }
-    const touchedInWindow = new Set();
-    for (const c of windowLog)
-        for (const f of c.files)
-            touchedInWindow.add(f.path);
-    const trackedIndex = buildTrackedIndex(new Set([...headFiles, ...touchedInWindow]));
-    const headIndex = buildTrackedIndex(headFiles);
-    const presentAtHeadSymbols = needs.symbols
-        ? gitGrepPresence(repoRoot, [...new Set(candidates.flatMap((c) => c.refs.symbols))], 'HEAD')
-        : new Set();
+/** The per-commit lookups of a ChurnGitView; each asks git once per commit and remembers the answer. */
+function churnCommitLookups(repoRoot) {
     const anchorCommitCache = new Map();
     const resolveAnchorCommit = (anchorIso) => {
         if (!anchorCommitCache.has(anchorIso)) {
@@ -299,7 +271,6 @@ function loadChurnGitView(repoRoot, projectName, candidates, anchorOf, needs) {
         }
         return known;
     };
-    const headScripts = needs.scripts ? packageScriptsAt(repoRoot, 'HEAD') : null;
     const scriptsAtCommit = new Map();
     const scriptsAt = (hash) => {
         if (!scriptsAtCommit.has(hash)) {
@@ -307,7 +278,29 @@ function loadChurnGitView(repoRoot, projectName, candidates, anchorOf, needs) {
         }
         return scriptsAtCommit.get(hash);
     };
-    return { repoRoot, projectName, windowLog, trackedIndex, headIndex, presentAtHeadSymbols, headScripts, resolveAnchorCommit, symbolsPresentAt, scriptsAt };
+    return { resolveAnchorCommit, symbolsPresentAt, scriptsAt };
+}
+function loadChurnGitView(repoRoot, projectName, candidates, anchorOf, needs) {
+    const headFiles = gitLsFilesAtHead(repoRoot);
+    let windowLog = [];
+    if (needs.paths) {
+        const minAnchor = candidates.reduce((min, c) => {
+            const a = anchorOf(c.entry);
+            return min === '' || a < min ? a : min;
+        }, '');
+        windowLog = fetchChurnWindowLog(repoRoot, minAnchor);
+    }
+    const touchedInWindow = new Set();
+    for (const c of windowLog)
+        for (const f of c.files)
+            touchedInWindow.add(f.path);
+    const trackedIndex = buildTrackedIndex(new Set([...headFiles, ...touchedInWindow]));
+    const headIndex = buildTrackedIndex(headFiles);
+    const presentAtHeadSymbols = needs.symbols
+        ? gitGrepPresence(repoRoot, [...new Set(candidates.flatMap((c) => c.refs.symbols))], 'HEAD')
+        : new Set();
+    const headScripts = needs.scripts ? packageScriptsAt(repoRoot, 'HEAD') : null;
+    return { repoRoot, projectName, windowLog, trackedIndex, headIndex, presentAtHeadSymbols, headScripts, ...churnCommitLookups(repoRoot) };
 }
 function pathEvidence(git, paths, anchorTime) {
     for (const rawPath of paths) {
@@ -362,25 +355,31 @@ function churnEvidence(git, refs, anchor) {
 }
 function tagChurnStale(hippoRoot, tenantId, toTag, confirmedAt) {
     // The git calls above can take seconds; a good outcome landing meanwhile moves the anchor past the evidence.
-    const confirmedNow = queryConfirmedAt(hippoRoot, tenantId);
+    const confirmedNow = confirmedOutcomeTimes(hippoRoot, tenantId);
     const unconfirmed = toTag.filter((stale) => confirmedNow.get(stale.id) === confirmedAt.get(stale.id));
     if (unconfirmed.length === 0)
         return;
-    const db = openStore(hippoRoot);
-    try {
-        const live = selectEntriesByIds(db, unconfirmed.map((stale) => stale.id), tenantId);
-        for (const stale of unconfirmed) {
-            const entry = live.get(stale.id);
-            if (!entry || entry.tags.includes(CHURN_STALE_TAG))
-                continue;
-            const tagged = { ...entry, tags: [...entry.tags, CHURN_STALE_TAG] };
-            writeEntryOn(db, hippoRoot, tagged);
-            live.set(stale.id, tagged); // a repeated id is already tagged, as a fresh read would show
+    addTagToEntries(hippoRoot, tenantId, unconfirmed.map((stale) => stale.id), CHURN_STALE_TAG);
+}
+/** Counts every candidate's evidence into `result` and returns the rows still to tag, writing nothing. */
+function recordChurnEvidence(git, candidates, anchorOf, result) {
+    const toTag = [];
+    for (const { entry, refs } of candidates) {
+        result.checked++;
+        const evidence = churnEvidence(git, refs, anchorOf(entry));
+        if (!evidence)
+            continue;
+        const headline = entry.content.replace(/\s+/g, ' ').slice(0, HEADLINE_CHARS);
+        if (entry.tags.includes(CHURN_STALE_TAG)) {
+            result.alreadyMarked++;
+            result.preview.push({ id: entry.id, headline, evidence, already: true });
+            continue;
         }
+        result.marked++;
+        result.preview.push({ id: entry.id, headline, evidence, already: false });
+        toTag.push(entry);
     }
-    finally {
-        closeHippoDb(db);
-    }
+    return toTag;
 }
 /** Flags memories whose named file/symbol/script changed or disappeared since storage (or last confirmation); only adds/removes CHURN_STALE_TAG, never confidence/half-life/strength. */
 export function detectChurnStale(hippoRoot, repoRoot, opts) {
@@ -391,7 +390,7 @@ export function detectChurnStale(hippoRoot, repoRoot, opts) {
     const { candidates, skippedPinned } = collectChurnCandidates(entries, opts);
     if (candidates.length === 0)
         return emptyChurnResult(dryRun, skippedPinned);
-    const confirmedAt = queryConfirmedAt(hippoRoot, opts.tenantId);
+    const confirmedAt = confirmedOutcomeTimes(hippoRoot, opts.tenantId);
     // Compared as epoch ms, not strings: imported rows may carry offsets or other ISO forms.
     const anchorOf = (entry) => {
         const confirmed = confirmedAt.get(entry.id);
@@ -412,22 +411,7 @@ export function detectChurnStale(hippoRoot, repoRoot, opts) {
         // Collected here, written only after every candidate's evidence is
         // computed: a GitReadError thrown mid-loop must never leave an earlier
         // candidate tagged while a later one aborts the run untagged.
-        const toTag = [];
-        for (const { entry, refs } of candidates) {
-            result.checked++;
-            const evidence = churnEvidence(git, refs, anchorOf(entry));
-            if (!evidence)
-                continue;
-            const headline = entry.content.replace(/\s+/g, ' ').slice(0, 60);
-            if (entry.tags.includes(CHURN_STALE_TAG)) {
-                result.alreadyMarked++;
-                result.preview.push({ id: entry.id, headline, evidence, already: true });
-                continue;
-            }
-            result.marked++;
-            result.preview.push({ id: entry.id, headline, evidence, already: false });
-            toTag.push(entry);
-        }
+        const toTag = recordChurnEvidence(git, candidates, anchorOf, result);
         if (!dryRun && toTag.length > 0)
             tagChurnStale(hippoRoot, opts.tenantId, toTag, confirmedAt);
     }

package/dist/mcp/admin-tools.d.ts

@@ -1,5 +1,5 @@
 import { type ToolCall } from './protocol.js';
-export declare function runPredictBaserateTool({ args, ctx, hippoRoot, tenantId }: ToolCall): string;
+export declare function runPredictBaserateTool({ args, ctx, hippoRoot, tenantId }: ToolCall): Promise<string>;
 export declare function runStatusTool({ hippoRoot, config, tenantId }: ToolCall): string;
 export declare function runConflictsTool(call: ToolCall): string;
 export declare function runResolveTool({ args, ctx, hippoRoot, tenantId }: ToolCall): string;

package/dist/mcp/admin-tools.js

@@ -1,36 +1,28 @@
 // Store health and admin tool handlers: base rates, status, conflicts, resolve, share and peers.
-import { calculateStrength } from '../memory.js';
-import { evalNow } from '../ablation.js';
-import { loadStrengthRows } from '../store/candidates.js';
-import { listMemoryConflicts, listTouchableConflicts, resolveConflict } from '../store/conflicts.js';
-import { shareMemory, listPeers } from '../shared.js';
-import { computePredictionBaserate } from '../predictions/store.js';
-import { closeHippoDb, openHippoDb } from '../db.js';
-import { NotFoundError } from '../api-errors.js';
-import { classifyOriginProject } from '../project-identity.js';
-import { canTouchScope, passesScopeFilterForRecall, personalScopeOf } from '../recall-scope.js';
-import { selectEntriesByIds } from '../store/entry-reads.js';
-import { selectMemoryReach } from '../store/tenant-lookup.js';
+import { evalNow } from '../core/ablation.js';
+import { loadStrengthTallies } from '../store/candidates.js';
+import { countOpenConflicts, listTouchableConflicts, resolveConflict } from '../store/conflicts.js';
+import { shareMemory, listPeers } from '../sharing/shared.js';
+import { requireGroup, storeFor } from '../store/index.js';
+import { NotFoundError } from '../core/api-errors.js';
+import { classifyOriginProject } from '../core/project-identity.js';
+import { canTouchScope, passesScopeFilterForRecall, personalScopeOf } from '../store/recall-scope.js';
+import { chunked, loadEntriesByIds, readEntry } from '../store/entry-reads.js';
 import { mcpActor } from './protocol.js';
-import { isJsonString } from '../json.js';
+import { isJsonString } from '../util/json.js';
+import { DATE_PREFIX_CHARS } from '../util/token-text.js';
+const BASERATE_DECIMALS = 3;
 const NOT_RESOLVED = 'Could not resolve. Check the conflict ID and --keep value.';
 /** The scope of memory `id`, null when it has none or does not exist. */
 function memoryScope(hippoRoot, id) {
-    const db = openHippoDb(hippoRoot);
-    try {
-        return selectMemoryReach(db, id)?.scope ?? null;
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    return readEntry(hippoRoot, id)?.scope ?? null;
 }
-export function runPredictBaserateTool({ args, ctx, hippoRoot, tenantId }) {
-    // Text-only reply, matching the other MCP tools; the helper opens its own db
-    // and emits the audit, so call sites cannot drift.
+export async function runPredictBaserateTool({ args, ctx, hippoRoot, tenantId }) {
+    // Text-only reply, matching the other MCP tools; the group's read writes the audit row, so no surface can skip it.
     const classTag = String(args.class_tag || '').trim();
     if (!classTag)
         return 'No class_tag provided. Usage: pass class_tag matching a class used in past predictions (e.g. "migration-effort").';
-    const baserate = computePredictionBaserate(hippoRoot, tenantId, classTag, ctx?.actor ?? 'mcp');
+    const baserate = await requireGroup(storeFor({ hippoRoot, store: ctx?.store }), 'predictions').predictionBaserate(tenantId, classTag, ctx?.actor ?? 'mcp');
     if (baserate.nClosed === 0) {
         return `No closed predictions in class "${classTag}" yet. Create one via hippo_predict (or 'hippo predict ...' CLI) and close it with hippo_predict_close once the actual outcome is known. Base rates need closed predictions with numeric actual_value to compute.`;
     }
@@ -38,37 +30,26 @@ export function runPredictBaserateTool({ args, ctx, hippoRoot, tenantId }) {
     lines.push(`n_closed:         ${baserate.nClosed}`);
     lines.push(`n_ratio_eligible: ${baserate.nRatioEligible}`);
     if (baserate.meanEstimate !== null)
-        lines.push(`mean_estimate:    ${baserate.meanEstimate.toFixed(3)}`);
+        lines.push(`mean_estimate:    ${baserate.meanEstimate.toFixed(BASERATE_DECIMALS)}`);
     if (baserate.meanActual !== null)
-        lines.push(`mean_actual:      ${baserate.meanActual.toFixed(3)}`);
+        lines.push(`mean_actual:      ${baserate.meanActual.toFixed(BASERATE_DECIMALS)}`);
     if (baserate.meanRatio !== null)
-        lines.push(`mean_ratio:       ${baserate.meanRatio.toFixed(3)}x`);
+        lines.push(`mean_ratio:       ${baserate.meanRatio.toFixed(BASERATE_DECIMALS)}x`);
     if (baserate.p50Ratio !== null)
-        lines.push(`p50_ratio:        ${baserate.p50Ratio.toFixed(3)}x`);
+        lines.push(`p50_ratio:        ${baserate.p50Ratio.toFixed(BASERATE_DECIMALS)}x`);
     if (baserate.mae !== null)
-        lines.push(`mae:              ${baserate.mae.toFixed(3)}`);
+        lines.push(`mae:              ${baserate.mae.toFixed(BASERATE_DECIMALS)}`);
     return lines.join('\n');
 }
 export function runStatusTool({ hippoRoot, config, tenantId }) {
-    // Every row counts toward the averages, so this scans the store, but without its text.
-    const entries = loadStrengthRows(hippoRoot, tenantId);
-    const now = evalNow(); // honors HIPPO_FAKE_NOW (eval-only; see ablation.ts)
-    let atRisk = 0;
-    let totalStrength = 0;
-    for (const e of entries) {
-        const s = calculateStrength(e, now);
-        totalStrength += s;
-        if (s < 0.1 && !e.pinned)
-            atRisk++;
-    }
-    const avgStrength = entries.length > 0 ? (totalStrength / entries.length).toFixed(2) : '0';
-    const pinned = entries.filter((e) => e.pinned).length;
-    const errors = entries.filter((e) => e.tags.includes('error')).length;
-    const conflicts = listMemoryConflicts(hippoRoot, 'open', tenantId).length;
+    // honors HIPPO_FAKE_NOW (eval-only; see ablation.ts)
+    const tallies = loadStrengthTallies(hippoRoot, tenantId, evalNow(), 0.1);
+    const avgStrength = tallies.total > 0 ? (tallies.strengthSum / tallies.total).toFixed(2) : '0';
+    const conflicts = countOpenConflicts(hippoRoot, tenantId);
     return [
-        `Memories: ${entries.length} (${pinned} pinned, ${errors} errors)`,
+        `Memories: ${tallies.total} (${tallies.pinned} pinned, ${tallies.errors} errors)`,
         `Avg strength: ${avgStrength}`,
-        `At risk (<0.1): ${atRisk}`,
+        `At risk (<0.1): ${tallies.atRisk}`,
         `Open conflicts: ${conflicts}`,
         `Half-life default: ${config.defaultHalfLifeDays}d`,
     ].join('\n');
@@ -76,19 +57,15 @@ export function runStatusTool({ hippoRoot, config, tenantId }) {
 /** Pairs whose two rows the caller could recall: its repo or user-global, and no scope it was not asked for. */
 function recallablePairs(call, conflicts, project) {
     const own = personalScopeOf(mcpActor(call.ctx));
-    const db = openHippoDb(call.hippoRoot);
-    try {
-        const rows = selectEntriesByIds(db, conflicts.flatMap((c) => [c.memory_a_id, c.memory_b_id]), call.tenantId);
-        const shown = (id) => {
-            const row = rows.get(id);
-            return row !== undefined && classifyOriginProject(row.origin_project, project) !== 'cross-project'
-                && passesScopeFilterForRecall(row.scope ?? null, undefined, own);
-        };
-        return conflicts.filter((c) => shown(c.memory_a_id) && shown(c.memory_b_id));
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    const ids = [...new Set(conflicts.flatMap((c) => [c.memory_a_id, c.memory_b_id]))];
+    // loadEntriesByIds reads at most one chunk of ids per call.
+    const rows = new Map(chunked(ids).flatMap((chunk) => loadEntriesByIds(call.hippoRoot, chunk, call.tenantId)).map((row) => [row.id, row]));
+    const shown = (id) => {
+        const row = rows.get(id);
+        return row !== undefined && classifyOriginProject(row.origin_project, project) !== 'cross-project'
+            && passesScopeFilterForRecall(row.scope ?? null, undefined, own);
+    };
+    return conflicts.filter((c) => shown(c.memory_a_id) && shown(c.memory_b_id));
 }
 export function runConflictsTool(call) {
     const { ctx, hippoRoot, tenantId } = call;
@@ -143,6 +120,6 @@ export function runPeersTool({ tenantId }) {
     const peers = listPeers(undefined, tenantId);
     if (peers.length === 0)
         return 'No peers found.';
-    return peers.map((p) => `${p.project}: ${p.count} memories (latest: ${p.latest.slice(0, 10)})`).join('\n');
+    return peers.map((p) => `${p.project}: ${p.count} memories (latest: ${p.latest.slice(0, DATE_PREFIX_CHARS)})`).join('\n');
 }
 //# sourceMappingURL=admin-tools.js.map

package/dist/mcp/format.d.ts

@@ -1,9 +1,9 @@
-import type { SearchResult } from '../search/types.js';
+import type { SearchResult } from '../core/search-types.js';
 import type { SessionEvent, TaskSnapshot } from '../store/rows.js';
-import type { ContextCost, ContinuityBlock, RecallResult, RecallResultItem } from '../api.js';
-import { type SessionHandoff } from '../handoff.js';
-import { detectAnchoring } from '../recall-history.js';
-import { detectAvailabilityBias } from '../availability.js';
+import type { ContextCost, ContinuityBlock, RecallResult, RecallResultItem } from '../api/index.js';
+import { type SessionHandoff } from '../core/handoff.js';
+import { detectAnchoring } from '../api/recall-history.js';
+import { detectAvailabilityBias } from '../api/availability.js';
 export declare function formatContinuityBlock(block: ContinuityBlock): string;
 export declare function formatMemories(results: ReadonlyArray<Pick<SearchResult, 'entry'>>): string;
 export interface RenderedRecall {