hippo-memory 1.68.0 → 1.70.0

package/dist/mcp/framing.js

@@ -1,7 +1,9 @@
 // MCP stdio transport framing: newline-delimited JSON-RPC, no embedded newlines
 // (https://modelcontextprotocol.io/specification/.../basic/transports#stdio). Legacy LSP-style
 // `Content-Length` framing is also accepted so a printf-and-pipe smoke test still works.
+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.
     let start = 0;
@@ -17,13 +19,17 @@ export function parseFrame(buffer) {
     if (trimmed[0] === 0x43 /* 'C' */ || trimmed[0] === 0x63 /* 'c' */) {
         const headerEnd = trimmed.indexOf(HEADER_DELIM);
         if (headerEnd === -1)
-            return { kind: 'incomplete' };
+            return trimmed.length > MAX_BODY_BYTES ? { kind: 'oversize', rest: EMPTY, remainder: 'line' } : { kind: 'incomplete' };
         const header = trimmed.subarray(0, headerEnd).toString('utf-8');
         const match = header.match(/Content-Length:\s*(\d+)/i);
         if (!match)
             return { kind: 'skip', rest: Buffer.from(trimmed.subarray(headerEnd + 4)) };
         const contentLength = parseInt(match[1], 10);
         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) };
+        }
         if (trimmed.length < bodyStart + contentLength)
             return { kind: 'incomplete' };
         const body = trimmed.subarray(bodyStart, bodyStart + contentLength).toString('utf-8');
@@ -32,9 +38,11 @@ export function parseFrame(buffer) {
     // Newline-delimited JSON (MCP spec).
     const newlineIdx = trimmed.indexOf(0x0a);
     if (newlineIdx === -1)
-        return { kind: 'incomplete' };
-    const line = trimmed.subarray(0, newlineIdx).toString('utf-8').trimEnd();
+        return trimmed.length > MAX_BODY_BYTES ? { kind: 'oversize', rest: EMPTY, remainder: 'line' } : { kind: 'incomplete' };
     const rest = Buffer.from(trimmed.subarray(newlineIdx + 1));
+    if (newlineIdx > MAX_BODY_BYTES)
+        return { kind: 'oversize', rest, remainder: 0 };
+    const line = trimmed.subarray(0, newlineIdx).toString('utf-8').trimEnd();
     if (!line)
         return { kind: 'skip', rest };
     return { kind: 'message', body: line, rest };

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): string;
-export declare function runOutcomeTool({ args, ctx, hippoRoot, tenantId }: ToolCall): string;
+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): string;
 //# sourceMappingURL=memory-tools.d.ts.map

package/dist/mcp/memory-tools.js

@@ -1,14 +1,10 @@
 // Write-side tool handlers: hippo_remember, hippo_outcome and hippo_learn.
-import { log } from '../log.js';
-import { readEntry } from '../store/entry-reads.js';
-import { countCreatedSinceLastSleep } from '../store/index-and-stats.js';
-import { consolidate } from '../consolidate/sleep.js';
-import { outsideRequestStores, runWithRequestStores, scopedBusyWait } from '../db.js';
-import { resolveTenantId } from '../tenant.js';
-import { remember as apiRemember, outcome as apiOutcome, learn as apiLearn, MCP_LEARN } from '../api.js';
+import { storeFor } 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 { mcpActor } from './protocol.js';
-import { lastRecalledIds, autoSleepInFlight, resolveClientKey } from './session-state.js';
-export function runRememberTool({ args, ctx, hippoRoot, config, tenantId }) {
+import { lastRecalledIds, resolveClientKey } from './session-state.js';
+export async function runRememberTool({ args, ctx, hippoRoot, config, tenantId }) {
     const text = String(args.text || '');
     if (!text)
         return 'No text provided.';
@@ -28,42 +24,27 @@ export function runRememberTool({ args, ctx, hippoRoot, config, tenantId }) {
         actor: mcpActor(ctx),
         store: ctx?.store,
     };
-    const result = apiRemember(apiCtx, {
+    const result = await apiRemember(apiCtx, {
         content: text,
         tags,
         personal: args.personal === true,
         project: ctx?.project,
     });
-    const entry = readEntry(hippoRoot, result.id, tenantId);
-    // Auto-sleep: one run per store at a time, triggered by what arrived since the last one.
-    // Consolidation is host-wide, so only the host tenant's writes may start it.
-    if (ctx?.autoSleep !== false &&
-        config.autoSleep.enabled &&
-        tenantId === resolveTenantId({}) &&
-        !autoSleepInFlight.has(hippoRoot) &&
-        countCreatedSinceLastSleep(hippoRoot, tenantId) >= config.autoSleep.threshold) {
-        autoSleepInFlight.add(hippoRoot);
-        // Fire-and-forget (never block the response); an unhandled rejection would kill the server, so log it.
-        // Its own scope: the call's closes a handle the sleep still holds across its pauses, but the caller's lock wait carries over.
-        const busyWaitMs = scopedBusyWait();
-        outsideRequestStores(() => runWithRequestStores(() => consolidate(hippoRoot), { busyWaitMs }))
-            .catch((err) => {
-            log.error(`auto-sleep consolidate failed (tenant ${tenantId}): ${err instanceof Error ? err.message : String(err)}`);
-        })
-            .finally(() => autoSleepInFlight.delete(hippoRoot));
-    }
+    const [entry] = await storeFor(apiCtx).entriesByIds([result.id], tenantId);
+    // Auto-sleep runs on hippo.db, so another store skips it.
+    startAutoSleepIfDue(hippoRoot, tenantId, config.autoSleep, (ctx?.store === undefined || ctx.store.kind === 'sqlite') && ctx?.autoSleep !== false);
     const halfLife = entry?.half_life_days ?? config.defaultHalfLifeDays;
     const tagStr = entry?.tags.join(', ') || tags.join(', ') || 'none';
     const warnings = (result.warnings ?? []).map((w) => `\nWarning: ${w}`).join('');
     return `Remembered [${result.id}] (half-life: ${halfLife}d, tags: ${tagStr})${warnings}`;
 }
-export function runOutcomeTool({ args, ctx, hippoRoot, tenantId }) {
+export async function runOutcomeTool({ args, ctx, hippoRoot, tenantId }) {
     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.ts so audit_log captures the caller identity
+    // 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 enforced uniformly (same surface as recall/remember).
     // outcome() also handles cross-tenant id skip silently.
@@ -73,7 +54,7 @@ export function runOutcomeTool({ args, ctx, hippoRoot, tenantId }) {
         actor: mcpActor(ctx),
         store: ctx?.store,
     };
-    const { applied } = apiOutcome(apiCtx, ids, good);
+    const { applied } = await apiOutcome(apiCtx, ids, good);
     return `Applied ${good ? 'positive' : 'negative'} outcome to ${applied} memories`;
 }
 export function runLearnTool({ args, ctx, hippoRoot, tenantId }) {

package/dist/mcp/protocol.d.ts

@@ -1,9 +1,9 @@
-import { loadConfig } from '../config.js';
-import type { Actor as ApiActor } from '../api.js';
-import { type ResolveProjectIdentityOpts } from '../project-identity.js';
-import type { JsonValue } from '../json.js';
-import type { CallerProject } from '../prompt-hook.js';
-import type { HippoStore } from '../store-port.js';
+import { loadConfig } from '../core/config.js';
+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';
 /** 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 {
@@ -70,10 +70,6 @@ export interface McpContext {
  * a member key never acts as admin through MCP.
  */
 export declare function mcpActor(ctx: McpContext | undefined): ApiActor;
-export declare function isJsonBoolean(v: JsonValue | undefined): v is boolean;
-export declare function isJsonObjectRecord(v: JsonValue | undefined): v is {
-    [key: string]: JsonValue;
-};
 /** One tool call after the store, config and tenant are resolved; every handler reads the same four. */
 export interface ToolCall {
     args: Record<string, JsonValue>;

package/dist/mcp/protocol.js

@@ -1,11 +1,12 @@
 // MCP wire types, the caller context, and the JSON predicates every tool handler narrows its arguments with.
 import * as fs from 'fs';
 import { randomUUID } from 'node:crypto';
-import { INTERNAL_ERROR_MESSAGE, mapApiError } from '../http-util.js';
-import { log } from '../log.js';
-import { getGlobalRoot } from '../shared.js';
-import { findHippoStoreDir } from '../project-identity.js';
-import { isStoreBusy, STORE_BUSY_MESSAGE } from '../db.js';
+import { INTERNAL_ERROR_MESSAGE, mapApiError } from '../util/http-util.js';
+import { errorFields, errorMessage, log } from '../util/log.js';
+import { currentRequestId } from '../util/request-scope.js';
+import { getGlobalRoot } from '../sharing/shared.js';
+import { findHippoStoreDir } from '../core/project-identity.js';
+import { isStoreBusy, STORE_BUSY_MESSAGE } from '../db/index.js';
 // ── Find hippo root ──
 /** Same bounded walk as the CLI (ends at home, so HIPPO_HOME wins over ~/.hippo); cwd/opts are the test seam. */
 export function findHippoRoot(cwd = process.cwd(), opts) {
@@ -17,13 +18,13 @@ export function findHippoRoot(cwd = process.cwd(), opts) {
     return fs.existsSync(global) ? global : null;
 }
 /** JSON-RPC reply for a request that threw: typed API errors keep their text; anything else is logged and answered generically. */
-export function mcpErrorResponse(id, err, requestId = randomUUID()) {
+export function mcpErrorResponse(id, err, requestId = currentRequestId() ?? randomUUID()) {
     if (isStoreBusy(err))
         return { jsonrpc: '2.0', id, error: { code: -32603, message: STORE_BUSY_MESSAGE } };
     const { status, message } = mapApiError(err);
     if (status !== 500)
         return { jsonrpc: '2.0', id, error: { code: -32603, message } };
-    log.error(`mcp request failed: ${err instanceof Error ? err.message : String(err)}`, { requestId });
+    log.error(`mcp request failed: ${errorMessage(err)}`, { requestId, ...errorFields(err) });
     return {
         jsonrpc: '2.0',
         id,
@@ -45,11 +46,4 @@ export function mcpActor(ctx) {
         actor.owner = ctx.owner;
     return actor;
 }
-// ── JSON-ish domain type for untrusted MCP tool-call arguments ──
-export function isJsonBoolean(v) {
-    return typeof v === 'boolean';
-}
-export function isJsonObjectRecord(v) {
-    return v !== undefined && v !== null && typeof v === 'object' && !Array.isArray(v);
-}
 //# sourceMappingURL=protocol.js.map

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

@@ -1,6 +1,6 @@
 import { type ToolCall } from './protocol.js';
 export declare function runRecallTool(call: ToolCall): Promise<string>;
-export declare function runAssembleTool({ args, ctx, hippoRoot, tenantId }: ToolCall): string;
-export declare function runDrillTool({ args, ctx, hippoRoot, tenantId }: ToolCall): string;
+export declare function runAssembleTool({ args, ctx, hippoRoot, tenantId }: ToolCall): Promise<string>;
+export declare function runDrillTool({ args, ctx, hippoRoot, tenantId }: ToolCall): Promise<string>;
 export declare function runContextTool({ args, ctx, hippoRoot, config, tenantId }: ToolCall): Promise<string>;
 //# sourceMappingURL=recall-tools.d.ts.map

package/dist/mcp/recall-tools.js

@@ -1,23 +1,65 @@
 // Read-side tool handlers: hippo_recall, hippo_assemble, hippo_drill and hippo_context.
 import * as path from 'path';
 import { fitBudget } from '../search/finalize.js';
-import { dropHeldCopies, duplicateKey, storedTextKeys } from '../same-text.js';
-import { retrieve as apiRetrieve, drillDown as apiDrillDown, assemble as apiAssemble, getContext as apiGetContext, buildSuppressionSummary } from '../api.js';
-import { autoDetectContext } from '../context-auto.js';
-import { resolveProjectIdentity } from '../project-identity.js';
-import { isSharedStore } from '../config.js';
-import { detectAnchoring, hashQueryText, biasHintEnabled, snapshotRing } from '../recall-history.js';
-import { detectAvailabilityBias } from '../availability.js';
-import { estimateTokens } from '../token-ledger.js';
-import { assembleCost, assembleText, drillCost, drillText } from '../context-render.js';
+import { dropHeldCopies, duplicateKey, storedTextKeys } from '../util/same-text.js';
+import { retrieve as apiRetrieve, drillDown as apiDrillDown, assemble as apiAssemble, getContext as apiGetContext, buildSuppressionSummary } from '../api/index.js';
+import { autoDetectContext } from '../api/context-auto.js';
+import { resolveProjectIdentity } from '../core/project-identity.js';
+import { isSharedStore } from '../core/config.js';
+import { detectAnchoring, hashQueryText, biasHintEnabled, snapshotRing } from '../api/recall-history.js';
+import { detectAvailabilityBias } from '../api/availability.js';
+import { estimateTokens } from '../util/token-text.js';
+import { assembleCost, assembleText, drillCost, drillText } from '../api/context-render.js';
 import { mcpActor } from './protocol.js';
 import { lastRecalledIds, resolveClientKey } from './session-state.js';
 import { formatContinuityBlock, formatMemories, memoryCost, memoriesReserve, snapshotPiece, handoffPiece, trailPiece, contextCost, tailSection, planningSection, } from './format.js';
-import { isJsonString } from '../json.js';
+import { isJsonString } from '../util/json.js';
 import { parseContextRequest, parseRecallRequest, toolParams } from '../api/recall-request.js';
 import { noteRecall, sessionRing, shownRecallRows } from '../api/recall-record.js';
-/** Builds the showRanked callback that renders the list MCP shows, parks the render in `out` and hands back its hint rows. */
-function recallPresenter(budget, includeContinuity, anchorRing, queryHash, out, hintRows) {
+function detectBiasHints(list, pool, anchorRing, queryHash) {
+    const anchoring = anchorRing ? detectAnchoring(snapshotRing(anchorRing), queryHash, list[0]?.entry.id ?? null) : null;
+    const availability = biasHintEnabled('availability')
+        ? detectAvailabilityBias({
+            topK: list.map((r) => ({ id: r.entry.id, created: r.entry.created })),
+            pool: pool.map((e) => ({ id: e.id, created: e.created })),
+        })
+        : null;
+    return { anchoring, availability };
+}
+function biasHintSections(anchoring, availability) {
+    let text = anchoring ? `## Anchoring hint\n${anchoring.summary}\n[anchored_on: ${anchoring.memoryId}]\n\n---\n\n` : '';
+    if (availability)
+        text += `## Availability bias\n${availability.summary}\n\n---\n\n`;
+    return text;
+}
+function cutoffSection(s, shown) {
+    const cutoffClauses = [];
+    if (s.droppedByBudget > 0)
+        cutoffClauses.push(`${s.droppedByBudget} dropped to fit limit`);
+    if (s.droppedPreRank > 0)
+        cutoffClauses.push(`${s.droppedPreRank} filtered pre-rank`);
+    if (s.summarySubstitutionsAdded > 0)
+        cutoffClauses.push(`${s.summarySubstitutionsAdded} summary substitutions added`);
+    if (s.freshTailAdded > 0)
+        cutoffClauses.push(`${s.freshTailAdded} fresh-tail added`);
+    if (s.suppressedByInterference > 0)
+        cutoffClauses.push(`${s.suppressedByInterference} suppressed by interference`);
+    if (cutoffClauses.length === 0)
+        return '';
+    return `## Cutoff\nShowing ${shown} of ${s.totalCandidates} candidates; ${cutoffClauses.join('; ')}.\n\n---\n\n`;
+}
+function renderWithinBudget(ranked, limits, render) {
+    let results = fitBudget(ranked, Math.max(0, limits.room), 1, memoryCost);
+    let rendered = render(results);
+    // The hints, Cutoff block and heading vary with the list, so the lowest-ranked entry goes until the whole response fits.
+    while (results.length > 1 && estimateTokens(rendered.text) > limits.budget) {
+        results = results.slice(0, -1);
+        rendered = render(results);
+    }
+    return rendered;
+}
+function recallPresenter(budget, options) {
+    const { includeContinuity, anchorRing, queryHash, out, hintRows } = options;
     return ({ ranked, pool, droppedByScope }, apiResult) => {
         // Sections are paid in print order, ahead of the memories and after the heading; one that does not fit is dropped whole.
         let left = budget - memoriesReserve(budget);
@@ -37,13 +79,7 @@ function recallPresenter(budget, includeContinuity, anchorRing, queryHash, out,
         // The hints and Cutoff block describe the list MCP shows, not the window band in apiResult.
         const render = (cut) => {
             const list = dropHeldCopies(cut, (r) => r.entry); // after every cut, so a merged row cut here never hides its sources
-            const anchoring = anchorRing ? detectAnchoring(snapshotRing(anchorRing), queryHash, list[0]?.entry.id ?? null) : null;
-            const availability = biasHintEnabled('availability')
-                ? detectAvailabilityBias({
-                    topK: list.map((r) => ({ id: r.entry.id, created: r.entry.created })),
-                    pool: pool.map((e) => ({ id: e.id, created: e.created })),
-                })
-                : null;
+            const { anchoring, availability } = detectBiasHints(list, pool, anchorRing, queryHash);
             const shownIds = new Set(list.map((r) => r.entry.id));
             const shownKeys = storedTextKeys(list.map((r) => r.entry));
             const tail = showTail
@@ -58,36 +94,15 @@ function recallPresenter(budget, includeContinuity, anchorRing, queryHash, out,
                 suppressedByInterference: anchoring?.reason === 'memory_dominance' ? 1 : 0,
             });
             // Anchoring is the stronger pull, so it prints first; the Cutoff block sits above the list, where the agent reads it.
-            let text = anchoring ? `## Anchoring hint\n${anchoring.summary}\n[anchored_on: ${anchoring.memoryId}]\n\n---\n\n` : '';
-            if (availability)
-                text += `## Availability bias\n${availability.summary}\n\n---\n\n`;
+            let text = biasHintSections(anchoring, availability);
             if (showPlan)
                 text += planPiece;
-            const cutoffClauses = [];
-            if (s.droppedByBudget > 0)
-                cutoffClauses.push(`${s.droppedByBudget} dropped to fit limit`);
-            if (s.droppedPreRank > 0)
-                cutoffClauses.push(`${s.droppedPreRank} filtered pre-rank`);
-            if (s.summarySubstitutionsAdded > 0)
-                cutoffClauses.push(`${s.summarySubstitutionsAdded} summary substitutions added`);
-            if (s.freshTailAdded > 0)
-                cutoffClauses.push(`${s.freshTailAdded} fresh-tail added`);
-            if (s.suppressedByInterference > 0)
-                cutoffClauses.push(`${s.suppressedByInterference} suppressed by interference`);
-            if (cutoffClauses.length > 0) {
-                text += `## Cutoff\nShowing ${list.length} of ${s.totalCandidates} candidates; ${cutoffClauses.join('; ')}.\n\n---\n\n`;
-            }
+            text += cutoffSection(s, list.length);
             // The window band's fresh-tail and summary rows follow the ranked list, or the MCP fields go unanswered.
             text += formatMemories(list) + tailSection(tail) + (showContinuity ? continuityPiece : '');
             return { anchoring, availability, text, list };
         };
-        let results = fitBudget(ranked, Math.max(0, left), 1, memoryCost);
-        let rendered = render(results);
-        // The hints, Cutoff block and heading vary with the list, so the lowest-ranked entry goes until the whole response fits.
-        while (results.length > 1 && estimateTokens(rendered.text) > budget) {
-            results = results.slice(0, -1);
-            rendered = render(results);
-        }
+        const rendered = renderWithinBudget(ranked, { room: left, budget }, render);
         out.rendered = rendered;
         return { ids: rendered.list.map((r) => r.entry.id), audit: hintRows(rendered) };
     };
@@ -117,9 +132,12 @@ export async function runRecallTool(call) {
         suppressAvailabilityHint: true,
         keepHeldCopies: true,
         project: ctx?.project,
-        showRanked: recallPresenter(budget, includeContinuity, anchorRing, queryHash, out, ({ list, anchoring, availability }) => shownRecallRows(who, {
-            query, ring: anchorRing, topId: list[0]?.entry.id ?? null, anchoring, availability,
-        })),
+        showRanked: recallPresenter(budget, {
+            includeContinuity, anchorRing, queryHash, out,
+            hintRows: ({ list, anchoring, availability }) => shownRecallRows(who, {
+                query, ring: anchorRing, topId: list[0]?.entry.id ?? null, anchoring, availability,
+            }),
+        }),
     });
     const { rendered } = out;
     if (!rendered)
@@ -130,7 +148,7 @@ export async function runRecallTool(call) {
         noteRecall(anchorRing, query, rendered.list[0]?.entry.id ?? null, rendered.anchoring?.memoryId);
     return rendered.text;
 }
-export function runAssembleTool({ args, ctx, hippoRoot, tenantId }) {
+export async function runAssembleTool({ args, ctx, hippoRoot, tenantId }) {
     const sessionId = String(args.session_id || '');
     if (!sessionId)
         return 'No session_id provided.';
@@ -153,7 +171,7 @@ export function runAssembleTool({ args, ctx, hippoRoot, tenantId }) {
         assembleExtra.freshTailCount = freshTailCount;
     if (explicitScope !== undefined)
         assembleExtra.scope = explicitScope;
-    const r = apiAssemble(apiCtx, sessionId, {
+    const r = await apiAssemble(apiCtx, sessionId, {
         summarizeOlder,
         project: ctx?.project,
         ...assembleExtra,
@@ -161,7 +179,7 @@ export function runAssembleTool({ args, ctx, hippoRoot, tenantId }) {
     });
     return assembleText(r);
 }
-export function runDrillTool({ args, ctx, hippoRoot, tenantId }) {
+export async function runDrillTool({ args, ctx, hippoRoot, tenantId }) {
     const summaryId = String(args.summary_id || '');
     if (!summaryId)
         return 'No summary_id provided.';
@@ -182,7 +200,7 @@ export function runDrillTool({ args, ctx, hippoRoot, tenantId }) {
         drillExtra.budget = budget;
     if (depth !== undefined)
         drillExtra.depth = depth;
-    const r = apiDrillDown(apiCtx, summaryId, { ...drillExtra, project: ctx?.project, cost: drillCost });
+    const r = await apiDrillDown(apiCtx, summaryId, { ...drillExtra, project: ctx?.project, cost: drillCost });
     if ('failure' in r) {
         // Only not_drillable is caller-actionable. not_found merges cross-tenant, scope-blocked and
         // missing, because telling scope_blocked apart would leak private-row existence.

package/dist/mcp/request.js

@@ -1,22 +1,22 @@
 // Transport-agnostic request handling: tool dispatch table, tool execution and the JSON-RPC method switch.
-import { log } from '../log.js';
-import { STORE_NOT_PORTED_MESSAGE } from '../http-util.js';
-import { getGlobalRoot, initGlobal } from '../shared.js';
-import { loadConfig } from '../config.js';
-import { resolveTenantId } from '../tenant.js';
-import { rethrowIfSqliteBlocked, runWithRequestStores } from '../db.js';
-import { hasGroup, storeFor } from '../store-port.js';
-import { estimateTokens } from '../token-ledger.js';
-import { PACKAGE_VERSION } from '../version.js';
+import { errorMessage, log } from '../util/log.js';
+import { STORE_NOT_PORTED_MESSAGE } from '../util/http-util.js';
+import { getGlobalRoot, initGlobal } from '../sharing/shared.js';
+import { loadConfig } from '../core/config.js';
+import { resolveTenantId } from '../store/tenant.js';
+import { rethrowIfSqliteBlocked, runWithRequestStores } from '../db/index.js';
+import { hasGroup, storeFor } from '../store/index.js';
+import { estimateTokens } from '../util/token-text.js';
+import { PACKAGE_VERSION } from '../util/version.js';
 import { validateToolArgs } from './tool-args.js';
 import { RecallRequestError } from '../api/recall-request.js';
-import { findHippoRoot, isJsonObjectRecord } from './protocol.js';
+import { findHippoRoot } from './protocol.js';
 import { TOOLS, TOOLS_BY_NAME, ARGS_CHECKED_BY_API } from './tools.js';
 import { runRecallTool, runAssembleTool, runDrillTool, runContextTool } from './recall-tools.js';
 import { runRememberTool, runOutcomeTool, runLearnTool } from './memory-tools.js';
 import { runPredictBaserateTool, runStatusTool, runConflictsTool, runResolveTool, runShareTool, runPeersTool } from './admin-tools.js';
 import { sharedStoreRefusal } from './shared-gate.js';
-import { isJsonString } from '../json.js';
+import { isJsonString, isJsonObject } from '../util/json.js';
 /**
  * Zero-install first run (`npx -y hippo-memory mcp` with no store anywhere):
  * create the global store instead of failing every tool call, and say so on
@@ -56,17 +56,17 @@ export async function recordMcpTokens(toolName, output, ctx) {
     }
     catch (err) {
         rethrowIfSqliteBlocked(err);
-        log.warnThenDebug('mcp-token-ledger', `token ledger write failed; the tool reply is unaffected: ${err instanceof Error ? err.message : String(err)}`);
+        log.warnThenDebug('mcp-token-ledger', `token ledger write failed; the tool reply is unaffected: ${errorMessage(err)}`);
     }
 }
 const TOOL_HANDLERS = new Map([
     ['hippo_recall', { handler: runRecallTool, storeReady: 'base' }],
-    ['hippo_assemble', { handler: runAssembleTool }],
-    ['hippo_drill', { handler: runDrillTool }],
-    ['hippo_predict_baserate', { handler: runPredictBaserateTool }],
-    ['hippo_remember', { handler: runRememberTool }],
-    ['hippo_outcome', { handler: runOutcomeTool }],
-    ['hippo_context', { handler: runContextTool }],
+    ['hippo_assemble', { handler: runAssembleTool, storeReady: 'dagReads' }],
+    ['hippo_drill', { handler: runDrillTool, storeReady: 'dagReads' }],
+    ['hippo_predict_baserate', { handler: runPredictBaserateTool, storeReady: 'predictions' }],
+    ['hippo_remember', { handler: runRememberTool, storeReady: 'entryWrites' }],
+    ['hippo_outcome', { handler: runOutcomeTool, storeReady: 'entryWrites' }],
+    ['hippo_context', { handler: runContextTool, storeReady: 'contextReads' }],
     ['hippo_status', { handler: runStatusTool }],
     ['hippo_learn', { handler: runLearnTool }],
     ['hippo_conflicts', { handler: runConflictsTool }],
@@ -110,6 +110,51 @@ function invalidArgs(id, toolName, problems) {
         result: { content: [{ type: 'text', text: `Invalid arguments for ${toolName}: ${problems.join('; ')}` }], isError: true },
     };
 }
+async function callTool(id, params, ctx) {
+    const nameValue = params?.name;
+    const toolName = isJsonString(nameValue) ? nameValue : '';
+    const tool = TOOLS_BY_NAME.get(toolName);
+    if (!tool) {
+        return { jsonrpc: '2.0', id, error: { code: -32602, message: `Unknown tool: ${toolName.slice(0, 128)}` } };
+    }
+    // The same refusal a ported tool gives when it reaches hippo.db, so a client handles one shape.
+    const other = otherStore(ctx);
+    if (other && !runsOn(other, toolName)) {
+        return { jsonrpc: '2.0', id, error: { code: -32603, message: STORE_NOT_PORTED_MESSAGE } };
+    }
+    const refusal = sharedStoreRefusal(toolName, ctx);
+    if (refusal !== undefined)
+        return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: refusal }], isError: true } };
+    const argumentsValue = params?.arguments;
+    if (argumentsValue !== undefined && argumentsValue !== null && !isJsonObject(argumentsValue)) {
+        return { jsonrpc: '2.0', id, error: { code: -32602, message: `${toolName}: arguments must be an object` } };
+    }
+    const toolArgs = isJsonObject(argumentsValue) ? argumentsValue : {};
+    const problems = validateToolArgs(tool.inputSchema, toolArgs, ARGS_CHECKED_BY_API.get(toolName));
+    if (problems.length > 0)
+        return invalidArgs(id, toolName, problems);
+    let output;
+    try {
+        // One handle per store for the tool and its ledger row; stdio interleaves calls, so each gets its own scope.
+        output = await runWithRequestStores(async () => {
+            const text = await executeTool(toolName, toolArgs, ctx);
+            await recordMcpTokens(toolName, text, ctx);
+            return text;
+        });
+    }
+    catch (err) {
+        if (!(err instanceof RecallRequestError))
+            throw err;
+        return invalidArgs(id, toolName, [err.message]);
+    }
+    return {
+        jsonrpc: '2.0',
+        id,
+        result: {
+            content: [{ type: 'text', text: output || 'Done.' }],
+        },
+    };
+}
 /**
  * Transport-agnostic MCP dispatcher. Both the stdio loop (below) and the
  * HTTP/SSE transport in src/server.ts route every incoming JSON-RPC message
@@ -136,51 +181,8 @@ export async function handleMcpRequest(req, ctx) {
             const other = otherStore(ctx);
             return { jsonrpc: '2.0', id, result: { tools: other ? TOOLS.filter((t) => runsOn(other, t.name)) : TOOLS } };
         }
-        case 'tools/call': {
-            const nameValue = params?.name;
-            const toolName = isJsonString(nameValue) ? nameValue : '';
-            const tool = TOOLS_BY_NAME.get(toolName);
-            if (!tool) {
-                return { jsonrpc: '2.0', id, error: { code: -32602, message: `Unknown tool: ${toolName.slice(0, 128)}` } };
-            }
-            // The same refusal a ported tool gives when it reaches hippo.db, so a client handles one shape.
-            const other = otherStore(ctx);
-            if (other && !runsOn(other, toolName)) {
-                return { jsonrpc: '2.0', id, error: { code: -32603, message: STORE_NOT_PORTED_MESSAGE } };
-            }
-            const refusal = sharedStoreRefusal(toolName, ctx);
-            if (refusal !== undefined)
-                return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: refusal }], isError: true } };
-            const argumentsValue = params?.arguments;
-            if (argumentsValue !== undefined && argumentsValue !== null && !isJsonObjectRecord(argumentsValue)) {
-                return { jsonrpc: '2.0', id, error: { code: -32602, message: `${toolName}: arguments must be an object` } };
-            }
-            const toolArgs = isJsonObjectRecord(argumentsValue) ? argumentsValue : {};
-            const problems = validateToolArgs(tool.inputSchema, toolArgs, ARGS_CHECKED_BY_API.get(toolName));
-            if (problems.length > 0)
-                return invalidArgs(id, toolName, problems);
-            let output;
-            try {
-                // One handle per store for the tool and its ledger row; stdio interleaves calls, so each gets its own scope.
-                output = await runWithRequestStores(async () => {
-                    const text = await executeTool(toolName, toolArgs, ctx);
-                    await recordMcpTokens(toolName, text, ctx);
-                    return text;
-                });
-            }
-            catch (err) {
-                if (!(err instanceof RecallRequestError))
-                    throw err;
-                return invalidArgs(id, toolName, [err.message]);
-            }
-            return {
-                jsonrpc: '2.0',
-                id,
-                result: {
-                    content: [{ type: 'text', text: output || 'Done.' }],
-                },
-            };
-        }
+        case 'tools/call':
+            return callTool(id, params, ctx);
         default:
             // Notifications (no id) must not receive a response
             if (method.startsWith('notifications/'))

package/dist/mcp/server.js

@@ -11,7 +11,7 @@ export { __resetSessionRecallHistoryMcp } from './session-state.js';
 export { findHippoRoot, mcpErrorResponse } from './protocol.js';
 export { handleMcpRequest } from './request.js';
 export { startStdioLoop } from './stdio.js';
-import { envMcpStdio } from '../env.js';
+import { envMcpStdio } from '../util/env.js';
 import { startStdioLoop } from './stdio.js';
 // Auto-start when invoked as the main module (node dist/mcp/server.js or via
 // the cli's `import('./mcp/server.js')`). Importing this file from another

package/dist/mcp/session-state.d.ts

@@ -1,8 +1,7 @@
 /** Test-only: reset the MCP recall rings. Call from beforeEach. */
 export declare function __resetSessionRecallHistoryMcp(): void;
-export declare const MAX_RECALL_CLIENTS = 4096;
 export declare const lastRecalledIds: Map<string, string[]>;
-export declare const autoSleepInFlight: Set<string>;
+export { autoSleepInFlight } from '../api/auto-sleep.js';
 export declare function resolveClientKey(ctx: {
     clientKey?: string;
     tenantId: string;

package/dist/mcp/session-state.js

@@ -13,7 +13,7 @@ export function __resetSessionRecallHistoryMcp() {
 // back to `'stdio-${pid}'` (one process = one client) or
 // `${tenantId}:default` if a McpContext is constructed in tests without a
 // pid-bound transport.
-export const MAX_RECALL_CLIENTS = 4096;
+const MAX_RECALL_CLIENTS = 4096;
 // The caller names the project half of each key, so a set past the cap drops the client that recalled longest ago.
 class RecentRecalls extends Map {
     set(key, ids) {
@@ -26,7 +26,7 @@ class RecentRecalls extends Map {
     }
 }
 export const lastRecalledIds = new RecentRecalls();
-export const autoSleepInFlight = new Set();
+export { autoSleepInFlight } from '../api/auto-sleep.js';
 export function resolveClientKey(ctx) {
     const base = ctx?.clientKey ? ctx.clientKey : `stdio-${process.pid}:${ctx?.tenantId || 'default'}`;
     return ctx?.project ? `${base}:${ctx.project.name}` : base;

package/dist/mcp/shared-gate.js

@@ -1,5 +1,5 @@
 // Which MCP tools run on a shared store, and which need the caller's project first.
-import { isSharedStore } from '../config.js';
+import { isSharedStore } from '../core/config.js';
 // A shared store holds many repos' rows, so a memory tool needs the caller's project and four tools never run.
 const OFF_ON_SHARED = new Map([
     ['hippo_learn', "reads the server's git history"],