hippo-memory 2.0.0 → 2.1.0

package/dist/learn/invalidation.js

@@ -1,11 +1,11 @@
-import { addTagToEntries, writeEntriesTogether } from '../store/entry-writes.js';
-import { confirmedOutcomeTimes } from '../store/audit.js';
-import { loadAllEntries, loadEntriesMentioning, readEntry } from '../store/entry-reads.js';
-import { requireGroup } from '../store/port.js';
+import { localFilesAt } from './roots.js';
 import { chunked } from '../util/chunked.js';
 import { CHURN_STALE_TAG } from '../core/memory.js';
 import { GitReadError, gitLsFilesAtHead, fetchChurnWindowLog, gitGrepPresence, resolveCommitBefore, packageScriptsAt, } from './churn-git.js';
 const HEADLINE_CHARS = 60;
+const TRIVIAL_REMOVAL_WORDS = new Set([
+    'extra', 'unused', 'empty', 'old', 'whitespace', 'spaces', 'blank', 'dead', 'commented',
+]);
 /** Extract what was replaced/removed from a commit message.
  *  Returns null if the commit isn't a breaking/migration change. */
 export function extractInvalidationTarget(message) {
@@ -36,39 +36,47 @@ export function extractInvalidationTarget(message) {
     if (removeMatch) {
         const target = removeMatch[1].trim();
         const words = target.split(/\s+/);
-        const trivialWords = new Set(['extra', 'unused', 'empty', 'old', 'whitespace', 'spaces', 'blank', 'dead', 'commented']);
-        const isTrivial = words.length <= 2 && words.some(w => trivialWords.has(w.toLowerCase()));
+        const isTrivial = words.length <= 2 && words.some(w => TRIVIAL_REMOVAL_WORDS.has(w.toLowerCase()));
         if (isTrivial)
             return null;
         return { from: target, to: null, type: 'removal' };
     }
     return null;
 }
-/** Find memories that reference the invalidated pattern and weaken them (halve half_life_days, confidence 'stale', add 'invalidated' tag; pinned are skipped).
- *  Tag matching is EXACT: the FULL pattern must equal a tag, so a pattern merely containing a common tag word cannot mass-weaken every memory with that tag. */
+/** Find memories that reference the invalidated pattern and weaken them (halve half_life_days, confidence 'stale', add
+ * 'invalidated' tag; pinned are skipped).
+ * Tag matching is EXACT: the FULL pattern must equal a tag, so a pattern merely containing a common tag word cannot
+ * mass-weaken every memory with that tag. */
 export function invalidateMatching(hippoRoot, target, tenantId, options) {
+    return invalidateIn(localFilesAt(hippoRoot).learning, target, tenantId, options);
+}
+/** invalidateMatching on the memories `learning` holds. */
+function invalidateIn(learning, target, tenantId, options) {
     // tenantId opt-in: when set, only that tenant's memories are weakened; undefined is host-wide.
     // The onlyId read is tenant-scoped too, so another tenant's id is invisible here.
     const entries = options?.onlyId === undefined
-        ? loadEntriesMentioning(hippoRoot, invalidationTokenize(target.from), target.from.toLowerCase().trim(), tenantId)
-        : [readEntry(hippoRoot, options.onlyId, tenantId)].filter((entry) => entry !== null);
+        ? learning.entriesMentioning(invalidationTokenize(target.from), target.from.toLowerCase().trim(), tenantId)
+        : [learning.readEntry(options.onlyId, tenantId)].filter((entry) => entry !== null);
     const { result, weakened } = weakenMatches(entries, target, options);
-    writeEntriesTogether(hippoRoot, weakened);
+    learning.writeEntriesTogether(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. */
+/** 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 async function invalidateMatchingAmong(store, live, target, tenantId) {
     const seen = weakenMatches(live, target, { dryRun: true }).result;
     const ids = [...seen.targets, ...seen.skippedPinned];
     const fresh = new Map();
     // The port reads at most 500 ids a call.
-    for (const chunk of chunked(ids, 500))
+    for (const chunk of chunked(ids, 500)) {
         for (const entry of await store.entriesByIds(chunk, tenantId))
             fresh.set(entry.id, entry);
+    }
     const { result, weakened } = weakenMatches(ids.flatMap((id) => fresh.get(id) ?? []), target);
     if (weakened.length > 0)
-        await requireGroup(store, 'lessonWrites').writeTogether(weakened);
+        await store.lessonWrites.writeTogether(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];
@@ -154,7 +162,8 @@ const CHURN_PATH_RE = new RegExp(
 `[A-Za-z0-9_./\\\\:-]+\\.(?:${CHURN_PATH_EXTENSIONS.join('|')})(?![A-Za-z0-9_])(?::\\d+(?:-\\d+)?)?`, 'g');
 const CHURN_SYMBOL_RE = /`([A-Za-z_$][A-Za-z0-9_$]*)(?:\(\))?`/g;
 const CHURN_SCRIPT_RE = /npm run(?:-script)?\s+([A-Za-z0-9:_-]+)/g;
-/** Pure syntactic extraction; repo-aware resolution (trackedness, path relativization) happens only in detectChurnStale. */
+/** Pure syntactic extraction; repo-aware resolution (trackedness, path relativization) happens only in
+ * detectChurnStale. */
 export function extractChurnRefs(content) {
     const paths = new Set();
     for (const m of content.matchAll(CHURN_PATH_RE)) {
@@ -227,8 +236,10 @@ function collectChurnCandidates(entries, opts) {
     const skippedPinned = [];
     const candidates = [];
     for (const entry of entries) {
-        if (!entry.origin_project || (entry.origin_project !== opts.projectName && entry.origin_project !== opts.legacyName))
+        if (!entry.origin_project ||
+            (entry.origin_project !== opts.projectName && entry.origin_project !== opts.legacyName)) {
             continue;
+        }
         if (entry.superseded_by)
             continue;
         if (entry.kind === 'raw' || entry.kind === 'archived')
@@ -293,7 +304,16 @@ function loadChurnGitView(repoRoot, projectName, candidates, anchorOf, needs) {
         ? 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) };
+    return {
+        repoRoot,
+        projectName,
+        windowLog,
+        trackedIndex,
+        headIndex,
+        presentAtHeadSymbols,
+        headScripts,
+        ...churnCommitLookups(repoRoot),
+    };
 }
 function pathEvidence(git, paths, anchorTime) {
     for (const rawPath of paths) {
@@ -336,7 +356,8 @@ function scriptEvidence(git, scripts, anchor, headScripts) {
         : undefined;
     return hit ? `script-gone: ${hit}` : null;
 }
-/** The first churn evidence against one candidate: a changed or deleted file, then a gone symbol, then a gone script. */
+/** The first churn evidence against one candidate: a changed or deleted file, then a gone symbol, then a gone
+ * script. */
 function churnEvidence(git, refs, anchor) {
     let evidence = pathEvidence(git, refs.paths, new Date(anchor).getTime());
     if (!evidence && refs.symbols.length > 0)
@@ -346,13 +367,13 @@ function churnEvidence(git, refs, anchor) {
     }
     return evidence;
 }
-function tagChurnStale(hippoRoot, tenantId, toTag, confirmedAt) {
+function tagChurnStale(learning, tenantId, toTag, confirmedAt) {
     // The git calls above can take seconds; a good outcome landing meanwhile moves the anchor past the evidence.
-    const confirmedNow = confirmedOutcomeTimes(hippoRoot, tenantId);
+    const confirmedNow = learning.confirmedOutcomeTimes(tenantId);
     const unconfirmed = toTag.filter((stale) => confirmedNow.get(stale.id) === confirmedAt.get(stale.id));
     if (unconfirmed.length === 0)
         return;
-    addTagToEntries(hippoRoot, tenantId, unconfirmed.map((stale) => stale.id), CHURN_STALE_TAG);
+    learning.addTagToEntries(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) {
@@ -377,19 +398,26 @@ function recordChurnEvidence(git, candidates, anchorOf, result) {
 /** 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) {
+    return detectChurnIn(localFilesAt(hippoRoot).learning, repoRoot, opts);
+}
+/** detectChurnStale on the memories `learning` holds. */
+function detectChurnIn(learning, repoRoot, opts) {
     const dryRun = opts.dryRun === true;
     if (!opts.projectName)
         return emptyChurnResult(dryRun);
-    const entries = loadAllEntries(hippoRoot, opts.tenantId);
+    const origins = [opts.projectName, opts.legacyName].filter((name) => !!name);
+    const entries = learning.currentEntriesFromOrigins(opts.tenantId, origins);
     const { candidates, skippedPinned } = collectChurnCandidates(entries, opts);
     if (candidates.length === 0)
         return emptyChurnResult(dryRun, skippedPinned);
-    const confirmedAt = confirmedOutcomeTimes(hippoRoot, opts.tenantId);
+    const confirmedAt = learning.confirmedOutcomeTimes(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);
         const confirmedMs = confirmed ? Date.parse(confirmed) : NaN;
-        return confirmedMs > Date.parse(entry.created) ? new Date(confirmedMs).toISOString() : new Date(entry.created).toISOString();
+        return confirmedMs > Date.parse(entry.created)
+            ? new Date(confirmedMs).toISOString()
+            : new Date(entry.created).toISOString();
     };
     const needs = {
         paths: candidates.some((c) => c.refs.paths.length > 0),
@@ -402,10 +430,11 @@ export function detectChurnStale(hippoRoot, repoRoot, opts) {
     const result = { checked: 0, marked: 0, alreadyMarked: 0, skippedPinned, dryRun, preview: [] };
     try {
         const git = loadChurnGitView(repoRoot, opts.legacyName ?? opts.projectName, candidates, anchorOf, needs);
-        // Collected here and written only after every candidate's evidence is computed, so a GitReadError mid-loop cannot leave an earlier candidate tagged.
+        // Collected here and written only after every candidate's evidence is computed, so a GitReadError mid-loop cannot
+        // leave an earlier candidate tagged.
         const toTag = recordChurnEvidence(git, candidates, anchorOf, result);
         if (!dryRun && toTag.length > 0)
-            tagChurnStale(hippoRoot, opts.tenantId, toTag, confirmedAt);
+            tagChurnStale(learning, opts.tenantId, toTag, confirmedAt);
     }
     catch (err) {
         if (err instanceof GitReadError)

package/dist/learn/roots.d.ts

@@ -0,0 +1,3 @@
+import type { LocalFiles } from '../store/port/local-files.js';
+export declare function localFilesAt(hippoRoot: string): LocalFiles;
+//# sourceMappingURL=roots.d.ts.map

package/dist/learn/roots.js

@@ -0,0 +1,5 @@
+import { sqliteSyncStore } from '../store/sqlite/store.js';
+export function localFilesAt(hippoRoot) {
+    return sqliteSyncStore(hippoRoot).localFiles;
+}
+//# sourceMappingURL=roots.js.map

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

@@ -1,8 +1,8 @@
 import { type ToolCall } from './protocol.js';
-export declare function runPredictBaserateTool({ args, ctx, hippoRoot, tenantId }: ToolCall): Promise<string>;
-export declare function runStatusTool({ ctx, hippoRoot, config, tenantId }: ToolCall): string;
-export declare function runConflictsTool(call: ToolCall): string;
-export declare function runResolveTool({ args, ctx, hippoRoot, tenantId }: ToolCall): string;
-export declare function runShareTool({ args, ctx, hippoRoot, tenantId }: ToolCall): Promise<string>;
+export declare function runPredictBaserateTool({ args, ctx, hippoRoot, tenantId, store }: ToolCall<'predictions'>): Promise<string>;
+export declare function runStatusTool({ ctx, hippoRoot, config, tenantId, store }: ToolCall<'reports'>): Promise<string>;
+export declare function runConflictsTool(call: ToolCall<'conflicts'>): Promise<string>;
+export declare function runResolveTool({ args, ctx, hippoRoot, tenantId, store }: ToolCall<'conflicts'>): Promise<string>;
+export declare function runShareTool({ args, ctx, hippoRoot, tenantId, store }: ToolCall): Promise<string>;
 export declare function runPeersTool({ tenantId }: ToolCall): string;
 //# sourceMappingURL=admin-tools.d.ts.map

package/dist/mcp/admin-tools.js

@@ -2,30 +2,32 @@
 import { evalNow } from '../core/ablation.js';
 import { shareMemory, listPeers } from '../sharing/share.js';
 import { ConflictError, NotFoundError } from '../core/api-errors.js';
-import { predictionBaserate } from '../api/predictions.js';
-import { listOpenConflicts, resolveMemoryConflict } from '../api/conflicts.js';
-import { getMemoryStatus, getTouchableMemory } from '../api/memories.js';
+import { predictionBaserate } from '../api/objects/predictions.js';
+import { listOpenConflicts, resolveMemoryConflict } from '../api/memories/conflicts.js';
+import { getMemoryStatus, getTouchableMemory } from '../api/memories/memories.js';
 import { mcpActor } from './protocol.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.';
-export async function runPredictBaserateTool({ args, ctx, hippoRoot, tenantId }) {
+export async function runPredictBaserateTool({ args, ctx, hippoRoot, tenantId, store }) {
     // 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)
+    if (!classTag) {
         return 'No class_tag provided. Usage: pass class_tag matching a class used in past predictions (e.g. "migration-effort").';
-    const baserate = await predictionBaserate({ hippoRoot, tenantId, actor: mcpActor(ctx), store: ctx?.store }, classTag);
+    }
+    const baserate = await predictionBaserate({ hippoRoot, tenantId, actor: mcpActor(ctx), store }, classTag);
     if (baserate.nClosed === 0) {
-        return `No closed predictions in class "${classTag}" yet. Create one via hippo_predict (or 'hippo predict ...' CLI) ` +
+        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.`;
+            `Base rates need closed predictions with numeric actual_value to compute.`);
     }
     const lines = [baserate.summary, ''];
     lines.push(`n_closed:         ${baserate.nClosed}`);
     lines.push(`n_ratio_eligible: ${baserate.nRatioEligible}`);
-    if (baserate.meanEstimate !== null)
+    if (baserate.meanEstimate !== null) {
         lines.push(`mean_estimate:    ${baserate.meanEstimate.toFixed(BASERATE_DECIMALS)}`);
+    }
     if (baserate.meanActual !== null)
         lines.push(`mean_actual:      ${baserate.meanActual.toFixed(BASERATE_DECIMALS)}`);
     if (baserate.meanRatio !== null)
@@ -36,9 +38,9 @@ export async function runPredictBaserateTool({ args, ctx, hippoRoot, tenantId })
         lines.push(`mae:              ${baserate.mae.toFixed(BASERATE_DECIMALS)}`);
     return lines.join('\n');
 }
-export function runStatusTool({ ctx, hippoRoot, config, tenantId }) {
+export async function runStatusTool({ ctx, hippoRoot, config, tenantId, store }) {
     // honors HIPPO_FAKE_NOW (eval-only; see ablation.ts)
-    const tallies = getMemoryStatus({ hippoRoot, tenantId, actor: mcpActor(ctx), store: ctx?.store }, evalNow(), 0.1);
+    const tallies = await getMemoryStatus({ hippoRoot, tenantId, actor: mcpActor(ctx), store }, evalNow(), 0.1);
     const avgStrength = tallies.total > 0 ? (tallies.strengthSum / tallies.total).toFixed(2) : '0';
     return [
         `Memories: ${tallies.total} (${tallies.pinned} pinned, ${tallies.errors} errors)`,
@@ -48,14 +50,14 @@ export function runStatusTool({ ctx, hippoRoot, config, tenantId }) {
         `Half-life default: ${config.defaultHalfLifeDays}d`,
     ].join('\n');
 }
-export function runConflictsTool(call) {
-    const { ctx, hippoRoot, tenantId } = call;
-    const conflicts = listOpenConflicts({ hippoRoot, tenantId, actor: mcpActor(ctx), store: ctx?.store }, ctx?.project);
+export async function runConflictsTool(call) {
+    const { ctx, hippoRoot, tenantId, store } = call;
+    const conflicts = await listOpenConflicts({ hippoRoot, tenantId, actor: mcpActor(ctx), store }, ctx?.project);
     if (conflicts.length === 0)
         return 'No open conflicts.';
     return conflicts.map((c) => `conflict_${c.id}: ${c.memory_a_id} <-> ${c.memory_b_id} (score=${c.score.toFixed(2)}) — ${c.reason}`).join('\n');
 }
-export function runResolveTool({ args, ctx, hippoRoot, tenantId }) {
+export async function runResolveTool({ args, ctx, hippoRoot, tenantId, store }) {
     const conflictId = Number(args.conflict_id);
     const keepId = String(args.keep || '');
     const forget = Boolean(args.forget);
@@ -65,11 +67,12 @@ export function runResolveTool({ args, ctx, hippoRoot, tenantId }) {
         return 'Required: conflict_id and keep.';
     let loserId;
     try {
-        const apiCtx = { hippoRoot, tenantId, actor: mcpActor(ctx), store: ctx?.store };
-        ({ loserId } = resolveMemoryConflict(apiCtx, conflictId, { keepId, forget, rejectLoser, reason }));
+        const apiCtx = { hippoRoot, tenantId, actor: mcpActor(ctx), store };
+        ({ loserId } = await resolveMemoryConflict(apiCtx, conflictId, { keepId, forget, rejectLoser, reason }));
     }
     catch (err) {
-        // A missing, unreachable or settled conflict answers alike, so the reply says nothing of a pair the caller cannot touch.
+        // A missing, unreachable or settled conflict answers alike, so
+        // the reply says nothing of a pair the caller cannot touch.
         if (err instanceof NotFoundError || err instanceof ConflictError)
             return NOT_RESOLVED;
         throw err;
@@ -77,16 +80,16 @@ export function runResolveTool({ args, ctx, hippoRoot, tenantId }) {
     const action = rejectLoser ? 'rejected (tombstoned) and removed' : forget ? 'deleted' : 'weakened';
     return `Resolved conflict ${conflictId}: kept ${keepId}, ${action} ${loserId}`;
 }
-export async function runShareTool({ args, ctx, hippoRoot, tenantId }) {
+export async function runShareTool({ args, ctx, hippoRoot, tenantId, store }) {
     const shareId = String(args.id || '');
     if (!shareId)
         return 'Required: id (memory ID to share).';
     const force = Boolean(args.force);
     const actor = mcpActor(ctx);
     // Checked before shareMemory, whose personal-row refusal would tell another person the id exists.
-    await getTouchableMemory({ hippoRoot, tenantId, actor, store: ctx?.store }, shareId);
-    // Pass tenantId so shareMemory's readEntry filters by tenant; otherwise a Bearer for tenant A could share tenant B's id to the global store.
-    // The 'Memory not found' error matches the cross-tenant deny shape elsewhere.
+    await getTouchableMemory({ hippoRoot, tenantId, actor, store }, shareId);
+    // Pass tenantId so shareMemory's readEntry filters by tenant; otherwise a Bearer for tenant A could share tenant B's
+    // id to the global store. The 'Memory not found' error matches the cross-tenant deny shape elsewhere.
     const shared = shareMemory(hippoRoot, shareId, { force, tenantId });
     if (!shared)
         return 'Transfer score too low. Use force=true to override.';
@@ -97,6 +100,8 @@ 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, DATE_PREFIX_CHARS)})`).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

@@ -2,7 +2,7 @@ import type { SearchResult } from '../core/search-types.js';
 import type { SessionEvent, TaskSnapshot } from '../store/rows.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 { detectAnchoring } from '../api/recall/finish.js';
 import { detectAvailabilityBias } from '../api/availability.js';
 export declare function formatContinuityBlock(block: ContinuityBlock): string;
 export declare function formatMemories(results: ReadonlyArray<Pick<SearchResult, 'entry'>>): string;

package/dist/mcp/format.js

@@ -126,11 +126,13 @@ export function tailSection(rows) {
 export function planningSection(r) {
     if (r.planningFallacyHint) {
         const h = r.planningFallacyHint;
-        return `## Planning fallacy hint\nClass: ${h.classTag}\n${h.baserateSummary}\n(detected: ${JSON.stringify(h.detectedPhrase)})\n\n---\n\n`;
+        return `## Planning fallacy hint\nClass: ${h.classTag}\n${h.baserateSummary}\n(detected: ` +
+            `${JSON.stringify(h.detectedPhrase)})\n\n---\n\n`;
     }
     if (r.planningFallacyWatching) {
         const w = r.planningFallacyWatching;
-        return `## Planning fallacy watch\nReason: ${w.reason}\n${w.suggestion}\n(detected: ${JSON.stringify(w.detectedPhrase)})\n\n---\n\n`;
+        return `## Planning fallacy watch\nReason: ${w.reason}\n${w.suggestion}\n(detected: ` +
+            `${JSON.stringify(w.detectedPhrase)})\n\n---\n\n`;
     }
     return '';
 }

package/dist/mcp/framing.d.ts

@@ -1,4 +1,6 @@
-/** What of a refused frame has not arrived yet: a byte count when its header declared one, else the rest of its line. */
+/**
+ * What of a refused frame has not arrived yet: a byte count when its header declared one, else the rest of its line.
+ */
 export type FrameRemainder = number | 'line';
 export type FrameResult = {
     kind: 'message';

package/dist/mcp/framing.js

@@ -4,14 +4,21 @@
 import { MAX_BODY_BYTES } from '../util/http-util.js';
 const HEADER_DELIM = Buffer.from('\r\n\r\n');
 const EMPTY = Buffer.alloc(0);
-export function parseFrame(buffer) {
-    // Strip leading whitespace/newlines between messages.
+function skipWhitespace(buffer) {
     let start = 0;
     while (start < buffer.length &&
-        (buffer[start] === 0x0a || buffer[start] === 0x0d ||
-            buffer[start] === 0x20 || buffer[start] === 0x09)) {
+        (buffer[start] === 0x0a || buffer[start] === 0x0d || buffer[start] === 0x20 || buffer[start] === 0x09)) {
         start++;
     }
+    return start;
+}
+function incompleteOrOversize(trimmed) {
+    return trimmed.length > MAX_BODY_BYTES
+        ? { kind: 'oversize', rest: EMPTY, remainder: 'line' }
+        : { kind: 'incomplete' };
+}
+export function parseFrame(buffer) {
+    const start = skipWhitespace(buffer);
     if (start === buffer.length)
         return { kind: 'incomplete' };
     const trimmed = buffer.subarray(start);
@@ -19,7 +26,7 @@ export function parseFrame(buffer) {
     if (trimmed[0] === 0x43 /* 'C' */ || trimmed[0] === 0x63 /* 'c' */) {
         const headerEnd = trimmed.indexOf(HEADER_DELIM);
         if (headerEnd === -1)
-            return trimmed.length > MAX_BODY_BYTES ? { kind: 'oversize', rest: EMPTY, remainder: 'line' } : { kind: 'incomplete' };
+            return incompleteOrOversize(trimmed);
         const header = trimmed.subarray(0, headerEnd).toString('utf-8');
         const match = header.match(/Content-Length:\s*(\d+)/i);
         if (!match)
@@ -28,17 +35,22 @@ export function parseFrame(buffer) {
         const bodyStart = headerEnd + 4;
         if (contentLength > MAX_BODY_BYTES) {
             const end = bodyStart + contentLength;
-            return { kind: 'oversize', rest: Buffer.from(trimmed.subarray(Math.min(end, trimmed.length))), remainder: Math.max(0, end - trimmed.length) };
+            return {
+                kind: 'oversize',
+                rest: Buffer.from(trimmed.subarray(Math.min(end, trimmed.length))),
+                remainder: Math.max(0, end - trimmed.length),
+            };
         }
-        if (trimmed.length < bodyStart + contentLength)
+        if (trimmed.length < bodyStart + contentLength) {
             return { kind: 'incomplete', needs: start + bodyStart + contentLength };
+        }
         const body = trimmed.subarray(bodyStart, bodyStart + contentLength).toString('utf-8');
         return { kind: 'message', body, rest: Buffer.from(trimmed.subarray(bodyStart + contentLength)) };
     }
     // Newline-delimited JSON (MCP spec).
     const newlineIdx = trimmed.indexOf(0x0a);
     if (newlineIdx === -1)
-        return trimmed.length > MAX_BODY_BYTES ? { kind: 'oversize', rest: EMPTY, remainder: 'line' } : { kind: 'incomplete' };
+        return incompleteOrOversize(trimmed);
     const rest = Buffer.from(trimmed.subarray(newlineIdx + 1));
     if (newlineIdx > MAX_BODY_BYTES)
         return { kind: 'oversize', rest, remainder: 0 };

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

@@ -1,5 +1,5 @@
 import { type ToolCall } from './protocol.js';
-export declare function runRememberTool({ args, ctx, hippoRoot, config, tenantId }: ToolCall): Promise<string>;
-export declare function runOutcomeTool({ args, ctx, hippoRoot, tenantId }: ToolCall): Promise<string>;
-export declare function runLearnTool({ args, ctx, hippoRoot, tenantId }: ToolCall): Promise<string>;
+export declare function runRememberTool({ args, ctx, hippoRoot, config, tenantId, store }: ToolCall<'entryWrites'>): Promise<string>;
+export declare function runOutcomeTool({ args, ctx, hippoRoot, tenantId, store }: ToolCall<'entryWrites'>): Promise<string>;
+export declare function runLearnTool({ args, ctx, hippoRoot, tenantId, store }: ToolCall<'lessonWrites'>): Promise<string>;
 //# sourceMappingURL=memory-tools.d.ts.map

package/dist/mcp/memory-tools.js

@@ -1,10 +1,10 @@
 // Write-side tool handlers: hippo_remember, hippo_outcome and hippo_learn.
 import { hasGroup } from '../store/index.js';
-import { startAutoSleepIfDue } from '../api/auto-sleep.js';
-import { remember as apiRemember, outcome as apiOutcome, learn as apiLearn, MCP_LEARN } from '../api/index.js';
+import { startAutoSleepIfDue } from '../api/sleep/auto-sleep.js';
+import { remember as apiRemember, outcome as apiOutcome, learn as apiLearn, MCP_LEARN, } from '../api/index.js';
 import { mcpActor } from './protocol.js';
 import { lastRecalledIds, resolveClientKey } from './session-state.js';
-export async function runRememberTool({ args, ctx, hippoRoot, config, tenantId }) {
+export async function runRememberTool({ args, ctx, hippoRoot, config, tenantId, store }) {
     const text = String(args.text || '');
     if (!text)
         return 'No text provided.';
@@ -13,12 +13,13 @@ export async function runRememberTool({ args, ctx, hippoRoot, config, tenantId }
         tags.push('error');
     if (args.tag)
         tags.push(String(args.tag));
-    // Route through api/index.ts so audit_log captures the caller identity like CLI/REST: the auth-resolved ctx.actor under HTTP-MCP, 'mcp' for stdio.
+    // Route through api/index.ts so audit_log captures the caller identity like CLI/REST: the auth-resolved ctx.actor
+    // under HTTP-MCP, 'mcp' for stdio.
     const apiCtx = {
         hippoRoot,
         tenantId,
         actor: mcpActor(ctx),
-        store: ctx?.store,
+        store,
     };
     const result = await apiRemember(apiCtx, {
         content: text,
@@ -27,33 +28,36 @@ export async function runRememberTool({ args, ctx, hippoRoot, config, tenantId }
         project: ctx?.project,
     });
     // Auto-sleep runs on hippo.db, so another store skips it.
-    const allowed = (ctx?.store === undefined || hasGroup(ctx.store, 'localFiles')) && ctx?.autoSleep !== false;
-    startAutoSleepIfDue(hippoRoot, tenantId, config.autoSleep, allowed, ctx?.autoSleepRunner);
+    const allowed = hasGroup(store, 'localFiles') && ctx.autoSleep !== false;
+    const run = ctx.autoSleepRunner;
+    if (run !== undefined)
+        startAutoSleepIfDue(hippoRoot, tenantId, config.autoSleep, allowed, run);
     const tagStr = result.tags.join(', ') || 'none';
     const warnings = (result.warnings ?? []).map((w) => `\nWarning: ${w}`).join('');
     return `Remembered [${result.id}] (half-life: ${result.halfLifeDays}d, tags: ${tagStr})${warnings}`;
 }
-export async function runOutcomeTool({ args, ctx, hippoRoot, tenantId }) {
+export async function runOutcomeTool({ args, ctx, hippoRoot, tenantId, store }) {
     const good = Boolean(args.good);
     const clientKey = resolveClientKey(ctx);
     const ids = lastRecalledIds.get(clientKey) ?? [];
     if (ids.length === 0)
         return 'No recent recalls to apply outcome to.';
-    // Route through src/api/index.ts so audit_log captures the caller identity (auth-resolved ctx.actor under HTTP-MCP, 'mcp' for stdio) and tenant scoping is
-    // uniform; outcome() also skips cross-tenant ids silently.
+    // Route through src/api/index.ts so audit_log captures the caller identity (auth-resolved ctx.actor under HTTP-MCP,
+    // 'mcp' for stdio) and tenant scoping is uniform; outcome() also skips cross-tenant ids silently.
     const apiCtx = {
         hippoRoot,
         tenantId,
         actor: mcpActor(ctx),
-        store: ctx?.store,
+        store,
     };
     const { applied } = await apiOutcome(apiCtx, ids, good);
     return `Applied ${good ? 'positive' : 'negative'} outcome to ${applied} memories`;
 }
-export async function runLearnTool({ args, ctx, hippoRoot, tenantId }) {
+export async function runLearnTool({ args, ctx, hippoRoot, tenantId, store }) {
     const days = Number(args.days) || 7;
-    // process.cwd() is the server's repo, not a remote caller's, so api learn refuses all but stdio and a host admin (mcpActor fails closed).
-    const result = await apiLearn({ hippoRoot, tenantId, actor: mcpActor(ctx), store: ctx?.store }, { repoPath: process.cwd(), days, profile: MCP_LEARN });
+    // process.cwd() is the server's repo, not a remote caller's, so api learn refuses all but stdio and a host admin
+    // (mcpActor fails closed).
+    const result = await apiLearn({ hippoRoot, tenantId, actor: mcpActor(ctx), store }, { repoPath: process.cwd(), days, profile: MCP_LEARN });
     if (result.status === 'not-a-repo')
         return 'No git history found.';
     if (result.status === 'no-commits')

package/dist/mcp/protocol.d.ts

@@ -3,8 +3,9 @@ import type { Actor as ApiActor } from '../api/index.js';
 import { type ResolveProjectIdentityOpts } from '../core/project-identity.js';
 import { type JsonValue } from '../util/json.js';
 import type { CallerProject } from '../api/prompt-hook.js';
-import type { HippoStore } from '../store/index.js';
-import type { AutoSleepRunner } from '../api/auto-sleep.js';
+import type { HippoStore, StoreGroup, StoreWith } from '../store/index.js';
+import type { StoreReach } from '../store/port.js';
+import type { AutoSleepRunner } from '../api/sleep/auto-sleep.js';
 /** Same bounded walk as the CLI (ends at home, so HIPPO_HOME wins over ~/.hippo); cwd/opts are the test seam. */
 export declare function findHippoRoot(cwd?: string, opts?: ResolveProjectIdentityOpts): string | null;
 interface McpRequest {
@@ -25,16 +26,18 @@ interface McpResponse {
         };
     };
 }
-/** JSON-RPC reply for a request that threw: typed API errors keep their text; anything else is logged and answered generically. */
+/** JSON-RPC reply for a request that threw: typed API errors keep
+ * their text; anything else is logged and answered generically. */
 export declare function mcpErrorResponse<E>(id: McpResponse['id'], err: E, requestId?: string, call?: string): McpResponse;
 export type { McpRequest, McpResponse };
-/** Optional context from a non-stdio transport (the HTTP server's bound hippoRoot and auth-resolved tenantId/actor), so executeTool skips the
- * findHippoRoot() walk and the env-based resolveTenantId({}) fallback, which would pick the wrong store and tenant for HTTP callers. Stdio passes nothing. */
+/** Optional context from a non-stdio transport (the HTTP server's bound hippoRoot and auth-resolved tenantId/actor), so
+ * executeTool skips the findHippoRoot() walk and the env-based tenant fallback, which would pick the wrong store. */
 export interface McpContext {
     hippoRoot: string;
     tenantId: string;
     actor: string;
-    /** The caller's authenticated role. Required so no transport can forget it; only stdio, which passes no context, is admin without one. */
+    /** The caller's authenticated role. Required so no transport can forget it; only stdio, which passes no context,
+     * is admin without one. */
     role: 'admin' | 'member';
     /** Scope grants for the HTTP-MCP caller's key. Absent for stdio (admin, needs none). */
     scopes?: readonly string[];
@@ -43,26 +46,39 @@ export interface McpContext {
     hostAdmin?: true;
     owner?: string;
     project?: CallerProject;
-    store?: HippoStore;
+    /** The store this transport's calls run on. */
+    store: HippoStore;
+    /** Set by the stdio host: the operator's own process, so no shared-store gate applies. */
+    stdio?: true;
+    reach?: StoreReach;
     autoSleep?: false;
-    /** Set by the HTTP transport so auto-sleep runs off the server's event loop; stdio consolidates in its own process. */
+    /** How an auto-sleep runs: the HTTP transport runs it off the server's event loop, stdio in its own process.
+     * Without one, no auto-sleep starts. */
     autoSleepRunner?: AutoSleepRunner;
-    /** Per-client key for state isolation under HTTP-MCP: 'stdio-${pid}' for stdio, hash(bearer + remoteAddr) for HTTP (built in src/server/mcp-http.ts);
-     * defaults to `${tenantId}:default`. */
+    /** Per-client key for state isolation under HTTP-MCP: 'stdio-${pid}' for stdio, hash(bearer + remoteAddr) for HTTP
+     * (built in src/server/mcp-http.ts); defaults to `${tenantId}:default`. */
     clientKey?: string;
 }
-/** The api-layer actor for a tool call. Only stdio passes no context: it is the local operator, host admin. Any context runs as its own role, and an
- * untyped caller that sends none runs as a member, so a missing role fails closed. */
+/** The api-layer actor for a tool call. Only stdio passes no context: it is the local operator, host admin. Any context
+ * runs as its own role, and an untyped caller that sends none runs as a member, so a missing role fails closed. */
 export declare function mcpActor(ctx: McpContext | undefined): ApiActor;
 /** Stdio or a host admin: the only callers whose server cwd and git history are their own to read. */
 export declare function ownsServerCwd(ctx: McpContext | undefined): boolean;
-/** One tool call after the store, config and tenant are resolved; every handler reads the same four. */
-export interface ToolCall {
+/** What the stdio transport takes from its composition root: the context for a folder, and the scope each frame runs
+ * in. The root names the store adapter and the scope plumbing, so src/mcp names neither. */
+export interface McpHost {
+    contextFor(hippoRoot: string, tenantId: string): McpContext;
+    runRequest<T>(run: () => Promise<T>): Promise<T>;
+}
+/** One tool call after the store, config and tenant are resolved; every handler reads the same five. `G` is the group
+ * the dispatch gate proved on the store. */
+export interface ToolCall<G extends StoreGroup = 'base'> {
     args: Record<string, JsonValue>;
-    ctx?: McpContext;
+    ctx: McpContext;
     hippoRoot: string;
+    store: StoreWith<G>;
     config: ReturnType<typeof loadConfig>;
     tenantId: string;
 }
-export type ToolHandler = (call: ToolCall) => string | Promise<string>;
+export type ToolHandler<G extends StoreGroup = 'base'> = (call: ToolCall<G>) => string | Promise<string>;
 //# sourceMappingURL=protocol.d.ts.map