hippo-memory 1.71.0 → 2.0.0

package/dist/mcp/admin-tools.js

@@ -1,30 +1,25 @@
 // Store health and admin tool handlers: base rates, status, conflicts, resolve, share and peers.
 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/share.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 { 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 { 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.';
-/** The scope of memory `id`, null when it has none or does not exist. */
-function memoryScope(hippoRoot, id) {
-    return readEntry(hippoRoot, id)?.scope ?? null;
-}
 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 = await requireGroup(storeFor({ hippoRoot, store: ctx?.store }), 'predictions').predictionBaserate(tenantId, classTag, ctx?.actor ?? 'mcp');
+    const baserate = await predictionBaserate({ hippoRoot, tenantId, actor: mcpActor(ctx), store: ctx?.store }, classTag);
     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.`;
+        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.`;
     }
     const lines = [baserate.summary, ''];
     lines.push(`n_closed:         ${baserate.nClosed}`);
@@ -41,36 +36,21 @@ export async function runPredictBaserateTool({ args, ctx, hippoRoot, tenantId })
         lines.push(`mae:              ${baserate.mae.toFixed(BASERATE_DECIMALS)}`);
     return lines.join('\n');
 }
-export function runStatusTool({ hippoRoot, config, tenantId }) {
+export function runStatusTool({ ctx, hippoRoot, config, tenantId }) {
     // honors HIPPO_FAKE_NOW (eval-only; see ablation.ts)
-    const tallies = loadStrengthTallies(hippoRoot, tenantId, evalNow(), 0.1);
+    const tallies = getMemoryStatus({ hippoRoot, tenantId, actor: mcpActor(ctx), store: ctx?.store }, evalNow(), 0.1);
     const avgStrength = tallies.total > 0 ? (tallies.strengthSum / tallies.total).toFixed(2) : '0';
-    const conflicts = countOpenConflicts(hippoRoot, tenantId);
     return [
         `Memories: ${tallies.total} (${tallies.pinned} pinned, ${tallies.errors} errors)`,
         `Avg strength: ${avgStrength}`,
         `At risk (<0.1): ${tallies.atRisk}`,
-        `Open conflicts: ${conflicts}`,
+        `Open conflicts: ${tallies.openConflicts}`,
         `Half-life default: ${config.defaultHalfLifeDays}d`,
     ].join('\n');
 }
-/** 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 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;
-    const touchable = listTouchableConflicts(hippoRoot, 'open', tenantId, mcpActor(ctx));
-    const conflicts = ctx?.project ? recallablePairs(call, touchable, ctx.project) : touchable;
+    const conflicts = listOpenConflicts({ hippoRoot, tenantId, actor: mcpActor(ctx), store: 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');
@@ -79,33 +59,32 @@ export function runResolveTool({ args, ctx, hippoRoot, tenantId }) {
     const conflictId = Number(args.conflict_id);
     const keepId = String(args.keep || '');
     const forget = Boolean(args.forget);
-    // Optional rejectLoser + reason pass straight to resolveConflict, as the CLI's --reject-loser does.
     const rejectLoser = Boolean(args.rejectLoser);
     const reason = isJsonString(args.reason) ? args.reason : undefined;
     if (isNaN(conflictId) || !keepId)
         return 'Required: conflict_id and keep.';
-    if (!listTouchableConflicts(hippoRoot, 'open', tenantId, mcpActor(ctx)).some((c) => c.id === conflictId))
-        return NOT_RESOLVED;
-    const result = resolveConflict(hippoRoot, conflictId, keepId, forget, tenantId, {
-        rejectLoserValue: rejectLoser,
-        reason,
-        // rejectedBy defaults to 'cli', so name the real actor for the tombstone and audit:
-        // ctx.actor for HTTP-MCP, 'mcp' for stdio callers, which pass no ctx.
-        rejectedBy: ctx?.actor ?? 'mcp',
-    });
-    if (!result)
-        return NOT_RESOLVED;
+    let loserId;
+    try {
+        const apiCtx = { hippoRoot, tenantId, actor: mcpActor(ctx), store: ctx?.store };
+        ({ loserId } = 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.
+        if (err instanceof NotFoundError || err instanceof ConflictError)
+            return NOT_RESOLVED;
+        throw err;
+    }
     const action = rejectLoser ? 'rejected (tombstoned) and removed' : forget ? 'deleted' : 'weakened';
-    return `Resolved conflict ${conflictId}: kept ${keepId}, ${action} ${result.loserId}`;
+    return `Resolved conflict ${conflictId}: kept ${keepId}, ${action} ${loserId}`;
 }
-export function runShareTool({ args, ctx, hippoRoot, tenantId }) {
+export async function runShareTool({ args, ctx, hippoRoot, tenantId }) {
     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.
-    if (!canTouchScope(mcpActor(ctx), memoryScope(hippoRoot, shareId)))
-        throw new NotFoundError(`Memory not found: ${shareId}`);
+    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.
     const shared = shareMemory(hippoRoot, shareId, { force, tenantId });

package/dist/mcp/format.js

@@ -1,4 +1,5 @@
 // Text the MCP recall and context tools print, and what each printed piece costs the token budget.
+import { truncateWithEllipsis } from '../util/ellipsize.js';
 import { confidenceLabel } from '../core/memory.js';
 import { formatHandoffEvidenceLine } from '../core/handoff.js';
 import { printedTokens } from '../api/context-render.js';
@@ -25,7 +26,7 @@ function handoffLines(h) {
 }
 function trailLines(events) {
     return events.map((e) => {
-        const preview = e.content.length > MCP_PREVIEW_CHARS ? e.content.slice(0, MCP_PREVIEW_CHARS) + '…' : e.content;
+        const preview = truncateWithEllipsis(e.content, MCP_PREVIEW_CHARS, '…');
         return `- [${e.event_type}] ${preview}`;
     });
 }
@@ -111,7 +112,7 @@ export function tailSection(rows) {
     const lines = ['', '## Fresh tail / substituted summaries'];
     for (const r of rows) {
         const tag = r.isSummary ? '[summary]' : '[tail]';
-        const head = r.content.length > MCP_PREVIEW_CHARS ? r.content.slice(0, MCP_PREVIEW_CHARS) + '…' : r.content;
+        const head = truncateWithEllipsis(r.content, MCP_PREVIEW_CHARS, '…');
         if (r.isSummary && r.substitutedFor && r.substitutedFor.length > 0) {
             lines.push(`- ${tag} ${r.id} (covers ${r.substitutedFor.length} rows): ${head}`);
         }

package/dist/mcp/framing.d.ts

@@ -13,6 +13,7 @@ export type FrameResult = {
     remainder: FrameRemainder;
 } | {
     kind: 'incomplete';
+    needs?: number;
 };
 export declare function parseFrame(buffer: Buffer): FrameResult;
 //# sourceMappingURL=framing.d.ts.map

package/dist/mcp/framing.js

@@ -31,7 +31,7 @@ export function parseFrame(buffer) {
             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' };
+            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)) };
     }

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

package/dist/mcp/memory-tools.js

@@ -1,5 +1,5 @@
 // Write-side tool handlers: hippo_remember, hippo_outcome and hippo_learn.
-import { storeFor } from '../store/index.js';
+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 { mcpActor } from './protocol.js';
@@ -14,7 +14,6 @@ export async function runRememberTool({ args, ctx, hippoRoot, config, tenantId }
     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.
-    // The entry is re-read to surface the half-life used in the MCP response.
     const apiCtx = {
         hippoRoot,
         tenantId,
@@ -27,13 +26,12 @@ export async function runRememberTool({ args, ctx, hippoRoot, config, tenantId }
         personal: args.personal === true,
         project: ctx?.project,
     });
-    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 allowed = (ctx?.store === undefined || hasGroup(ctx.store, 'localFiles')) && ctx?.autoSleep !== false;
+    startAutoSleepIfDue(hippoRoot, tenantId, config.autoSleep, allowed, ctx?.autoSleepRunner);
+    const tagStr = result.tags.join(', ') || 'none';
     const warnings = (result.warnings ?? []).map((w) => `\nWarning: ${w}`).join('');
-    return `Remembered [${result.id}] (half-life: ${halfLife}d, tags: ${tagStr})${warnings}`;
+    return `Remembered [${result.id}] (half-life: ${result.halfLifeDays}d, tags: ${tagStr})${warnings}`;
 }
 export async function runOutcomeTool({ args, ctx, hippoRoot, tenantId }) {
     const good = Boolean(args.good);
@@ -52,9 +50,10 @@ export async function runOutcomeTool({ args, ctx, hippoRoot, tenantId }) {
     const { applied } = await apiOutcome(apiCtx, ids, good);
     return `Applied ${good ? 'positive' : 'negative'} outcome to ${applied} memories`;
 }
-export function runLearnTool({ args, ctx, hippoRoot, tenantId }) {
+export async function runLearnTool({ args, ctx, hippoRoot, tenantId }) {
     const days = Number(args.days) || 7;
-    const result = 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: 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

@@ -4,6 +4,7 @@ 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';
 /** 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,7 +26,7 @@ interface McpResponse {
     };
 }
 /** 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): McpResponse;
+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. */
@@ -33,25 +34,28 @@ export interface McpContext {
     hippoRoot: string;
     tenantId: string;
     actor: string;
-    /** The caller's role from the HTTP transport's auth; absent for stdio (the local operator, admin). Tools must use this, or a member key over HTTP-MCP
-     * would act as admin. */
-    role?: 'admin' | 'member';
+    /** 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[];
     viaAuthResolver?: true;
-    /** Set by the HTTP transport for the host's operator; a context without a role is in-process and implies it. */
+    /** Set by the HTTP transport for the host's operator; never implied by the role. */
     hostAdmin?: true;
     owner?: string;
     project?: CallerProject;
     store?: HippoStore;
     autoSleep?: false;
+    /** Set by the HTTP transport so auto-sleep runs off the server's event loop; stdio consolidates in its own process. */
+    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`. */
     clientKey?: string;
 }
-/** The api-layer actor for a tool call: stdio (no ctx) is the local operator and runs as admin; over HTTP the authenticated role is used, so a member key
- * never acts as admin. */
+/** 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 {
     args: Record<string, JsonValue>;

package/dist/mcp/protocol.js

@@ -1,12 +1,14 @@
 // 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 '../util/http-util.js';
+import { mapApiError } from '../api/error-reply.js';
+import { INTERNAL_ERROR_MESSAGE } from '../util/http-util.js';
 import { errorFields, errorMessage, log } from '../util/log.js';
 import { currentRequestId } from '../util/request-scope.js';
 import { getGlobalRoot } from '../sharing/global-store.js';
 import { findHippoStoreDir } from '../core/project-identity.js';
-import { isStoreBusy, STORE_BUSY_MESSAGE } from '../db/index.js';
+import { STORE_BUSY_MESSAGE } from '../store/port.js';
+import { isStoreBusy } from '../store/sqlite/busy.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) {
@@ -18,29 +20,40 @@ 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 = currentRequestId() ?? randomUUID()) {
-    if (isStoreBusy(err))
+export function mcpErrorResponse(id, err, requestId = currentRequestId() ?? randomUUID(), call) {
+    const where = call === undefined ? '' : ` (${call})`;
+    if (isStoreBusy(err)) {
+        log.warn(`mcp request${where} failed: ${errorMessage(err)}`, { requestId });
         return { jsonrpc: '2.0', id, error: { code: -32603, message: STORE_BUSY_MESSAGE } };
+    }
     const { status, message } = mapApiError(err);
-    if (status !== 500)
+    if (status !== 500) {
+        log.info(`mcp request${where} failed: ${errorMessage(err)}`, { requestId, status });
         return { jsonrpc: '2.0', id, error: { code: -32603, message } };
-    log.error(`mcp request failed: ${errorMessage(err)}`, { requestId, ...errorFields(err) });
+    }
+    log.error(`mcp request${where} failed: ${errorMessage(err)}`, { requestId, ...errorFields(err) });
     return {
         jsonrpc: '2.0',
         id,
         error: { code: -32603, message: `${INTERNAL_ERROR_MESSAGE} (request id ${requestId})`, data: { requestId } },
     };
 }
-/** The api-layer actor for a tool call: stdio (no ctx) is the local operator and runs as admin; over HTTP the authenticated role is used, so a member key
- * never acts as admin. */
+/** 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 function mcpActor(ctx) {
-    const actor = { subject: ctx?.actor ?? 'mcp', role: ctx?.role ?? 'admin', scopes: ctx?.scopes };
-    if (ctx?.viaAuthResolver)
+    if (ctx === undefined)
+        return { subject: 'mcp', role: 'admin', hostAdmin: true };
+    const actor = { subject: ctx.actor ?? 'mcp', role: ctx.role === 'admin' ? 'admin' : 'member', scopes: ctx.scopes };
+    if (ctx.viaAuthResolver)
         actor.viaAuthResolver = true;
-    if (ctx?.role === undefined || ctx.hostAdmin)
+    if (ctx.hostAdmin)
         actor.hostAdmin = true;
-    if (ctx?.owner !== undefined)
+    if (ctx.owner !== undefined)
         actor.owner = ctx.owner;
     return actor;
 }
+/** Stdio or a host admin: the only callers whose server cwd and git history are their own to read. */
+export function ownsServerCwd(ctx) {
+    return mcpActor(ctx).hostAdmin === true;
+}
 //# sourceMappingURL=protocol.js.map

package/dist/mcp/recall-tools.js

@@ -2,7 +2,7 @@
 import * as path from 'path';
 import { fitBudget } from '../search/finalize.js';
 import { dropHeldCopies, duplicateKey, storedTextKeys } from '../util/same-text.js';
-import { retrieve as apiRetrieve, drillDown as apiDrillDown, assemble as apiAssemble, getContext as apiGetContext } from '../api/index.js';
+import { retrieve as apiRetrieve, drillDown as apiDrillDown, assemble as apiAssemble, getContext as apiGetContext, } from '../api/index.js';
 import { autoDetectContext } from '../api/context-auto.js';
 import { resolveProjectIdentity } from '../core/project-identity.js';
 import { isSharedStore } from '../core/config.js';
@@ -10,12 +10,14 @@ import { detectAnchoring, hashQueryText, biasHintEnabled, snapshotRing } from '.
 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 { mcpActor, ownsServerCwd } 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 '../util/json.js';
 import { parseContextRequest, parseRecallRequest, toolParams } from '../api/recall-request.js';
 import { noteRecall, sessionRing, shownRecallRows } from '../api/recall-record.js';
+// Candidate pool the MCP recall ranks before the token budget trims what is shown.
+const MCP_RECALL_LIMIT = 50;
 function detectBiasHints(list, pool, anchorRing, queryHash) {
     const anchoring = anchorRing ? detectAnchoring(snapshotRing(anchorRing), queryHash, list[0]?.entry.id ?? null) : null;
     const availability = biasHintEnabled('availability')
@@ -126,7 +128,7 @@ export async function runRecallTool(call) {
     // RecallContractError throws reach the MCP caller raw, as mcp-recall-fresh-tail-policy.test.ts pins.
     await apiRetrieve(apiCtx, {
         ...recallOpts,
-        limit: 50,
+        limit: MCP_RECALL_LIMIT,
         mode: config.physics?.enabled !== false ? 'physics' : 'hybrid',
         // The hint is computed below over the list MCP shows; the window band's copy would emit its audit row twice.
         suppressAvailabilityHint: true,
@@ -211,10 +213,10 @@ export async function runDrillTool({ args, ctx, hippoRoot, tenantId }) {
     }
     return drillText(r);
 }
-// The served store names the project (an HTTP daemon runs from anywhere); the global root names none, so stdio falls back to its launch cwd.
-function localProject(hippoRoot) {
+// The served store names the project (an HTTP daemon runs from anywhere); the global root names none, so only an owner of the server cwd falls back to it.
+function localProject(hippoRoot, ownsCwd) {
     const storeProject = resolveProjectIdentity(path.dirname(path.resolve(hippoRoot)));
-    return storeProject.name !== '' ? storeProject : resolveProjectIdentity(process.cwd());
+    return storeProject.name !== '' || !ownsCwd ? storeProject : resolveProjectIdentity(process.cwd());
 }
 export async function runContextTool({ args, ctx, hippoRoot, config, tenantId }) {
     // Stdio names no project, and the store's folder or the launch cwd is no caller's; HTTP sends X-Hippo-Project.
@@ -226,12 +228,13 @@ export async function runContextTool({ args, ctx, hippoRoot, config, tenantId })
         return '';
     if (budget < memoriesReserve(budget))
         return ''; // not even the heading fits, so nothing prints, as at budget 0
+    const ownsCwd = ownsServerCwd(ctx);
     const result = await apiGetContext({ hippoRoot, tenantId, actor: mcpActor(ctx), store: ctx?.store }, {
-        // The server's git state is no caller's, so a shared-store caller gets its project's rows without a query.
-        q: ctx?.project ? undefined : autoDetectContext(),
+        // The server's git state is no remote caller's, so a project or remote caller gets rows by strength without a query.
+        q: ctx?.project || !ownsCwd ? undefined : autoDetectContext(),
         budget,
         exactScope,
-        currentProject: ctx?.project ?? localProject(hippoRoot),
+        currentProject: ctx?.project ?? localProject(hippoRoot, ownsCwd),
         cost: contextCost,
     });
     lastRecalledIds.set(resolveClientKey(ctx), result.entries.map((r) => r.entry.id));

package/dist/mcp/request.js

@@ -1,11 +1,14 @@
 // Transport-agnostic request handling: tool dispatch table, tool execution and the JSON-RPC method switch.
 import { errorMessage, log } from '../util/log.js';
+import { currentSignal } from '../util/request-scope.js';
 import { STORE_NOT_PORTED_MESSAGE } from '../util/http-util.js';
 import { getGlobalRoot, initGlobal } from '../sharing/global-store.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 { runWithRequestStores } from '../db/index.js';
+import { rethrowIfSqliteBlocked } from '../util/sqlite-blocked.js';
+import { hasGroup } from '../store/index.js';
+import { storeFor } from '../store/sqlite/store.js';
 import { estimateTokens } from '../util/token-text.js';
 import { PACKAGE_VERSION } from '../util/version.js';
 import { validateToolArgs } from './tool-args.js';
@@ -61,20 +64,15 @@ const TOOL_HANDLERS = new Map([
     ['hippo_outcome', { handler: runOutcomeTool, storeReady: 'entryWrites' }],
     ['hippo_context', { handler: runContextTool, storeReady: 'contextReads' }],
     ['hippo_status', { handler: runStatusTool }],
-    ['hippo_learn', { handler: runLearnTool }],
+    ['hippo_learn', { handler: runLearnTool, storeReady: 'lessonWrites' }],
     ['hippo_conflicts', { handler: runConflictsTool }],
     ['hippo_resolve', { handler: runResolveTool }],
     ['hippo_share', { handler: runShareTool }],
     ['hippo_peers', { handler: runPeersTool }],
 ]);
-/** The served store when it is not hippo.db, else null. */
-function otherStore(ctx) {
-    const store = ctx?.store;
-    return store !== undefined && store.kind !== 'sqlite' ? store : null;
-}
+/** Stdio serves no store and runs every tool on the folder's hippo.db. */
 function runsOn(store, toolName) {
-    const group = TOOL_HANDLERS.get(toolName)?.storeReady;
-    return group !== undefined && hasGroup(store, group);
+    return store === undefined || hasGroup(store, TOOL_HANDLERS.get(toolName)?.storeReady ?? 'localFiles');
 }
 async function executeTool(name, args, ctx) {
     // With a transport context (HTTP), trust it: hippoRoot comes from the server's bound opts and tenantId from the Bearer (or loopback fallback).
@@ -99,6 +97,17 @@ function invalidArgs(id, toolName, problems) {
         result: { content: [{ type: 'text', text: `Invalid arguments for ${toolName}: ${problems.join('; ')}` }], isError: true },
     };
 }
+/** One handle per store for the tool and its ledger row; stdio interleaves calls, so each gets its own scope.
+ *  SHORTCUT: the deadline stops a call only between these steps, not a store read or fetch already running; thread the signal into them. */
+function runToolScoped(toolName, args, ctx) {
+    return runWithRequestStores(async () => {
+        currentSignal()?.throwIfAborted();
+        const text = await executeTool(toolName, args, ctx);
+        currentSignal()?.throwIfAborted();
+        await recordMcpTokens(toolName, text, ctx);
+        return text;
+    });
+}
 async function callTool(id, params, ctx) {
     const nameValue = params?.name;
     const toolName = isJsonString(nameValue) ? nameValue : '';
@@ -107,8 +116,7 @@ async function callTool(id, params, ctx) {
         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)) {
+    if (!runsOn(ctx?.store, toolName)) {
         return { jsonrpc: '2.0', id, error: { code: -32603, message: STORE_NOT_PORTED_MESSAGE } };
     }
     const refusal = sharedStoreRefusal(toolName, ctx);
@@ -124,12 +132,7 @@ async function callTool(id, params, ctx) {
         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;
-        });
+        output = await runToolScoped(toolName, toolArgs, ctx);
     }
     catch (err) {
         if (!(err instanceof RecallRequestError))
@@ -162,8 +165,7 @@ export async function handleMcpRequest(req, ctx) {
         case 'notifications/initialized':
             return null;
         case 'tools/list': {
-            const other = otherStore(ctx);
-            return { jsonrpc: '2.0', id, result: { tools: other ? TOOLS.filter((t) => runsOn(other, t.name)) : TOOLS } };
+            return { jsonrpc: '2.0', id, result: { tools: TOOLS.filter((t) => runsOn(ctx?.store, t.name)) } };
         }
         case 'tools/call':
             return callTool(id, params, ctx);

package/dist/mcp/stdio.js

@@ -1,7 +1,8 @@
 // Stdio transport: newline-delimited JSON-RPC frames in on stdin, replies out on stdout.
 import { exitAfterFlush, installCrashHandlers } from '../util/crash-handlers.js';
 import { errorFields, errorMessage, log } from '../util/log.js';
-import { requestDeadlineMs } from '../server/deadline.js';
+import { requestDeadlineMs } from '../util/request-scope.js';
+import { MAX_BODY_BYTES } from '../util/http-util.js';
 import { parseFrame } from './framing.js';
 import { mcpErrorResponse } from './protocol.js';
 import { handleMcpRequest } from './request.js';
@@ -14,7 +15,10 @@ function send(msg) {
     process.stdout.write(JSON.stringify(msg) + '\n');
 }
 // ── Stdio transport ──
-let buffer = Buffer.alloc(0);
+let pending = [];
+let pendingBytes = 0;
+// Set when the pending bytes hold a Content-Length header whose body has not fully arrived.
+let needs;
 // The part of a refused frame still on its way, dropped as it arrives so it is never buffered or read as a new frame.
 let refused = 0;
 function withoutRefused(chunk) {
@@ -69,8 +73,9 @@ function callName(req) {
     const tool = req.params?.name;
     return isJsonString(tool) ? `${req.method} ${tool.slice(0, 128)}` : req.method;
 }
-/** Answers `req` with one timeout error at the deadline a served request has. The returned function stops the timer and says whether that answer went out, so a later reply is dropped. */
-function watchDeadline(req, owedReply) {
+/** Answers `req` with one timeout error at the deadline a served request has. The returned function stops the timer and says whether that
+ * answer went out, so a later reply is dropped. */
+function watchDeadline(req, owedReply, abort) {
     const ms = requestDeadlineMs();
     if (ms === 0)
         return () => false;
@@ -78,7 +83,8 @@ function watchDeadline(req, owedReply) {
     const timer = setTimeout(() => {
         expired = true;
         const name = callName(req);
-        log.warn(`mcp: ${name} did not answer within ${ms} ms; it keeps running and its reply will be dropped`, { method: req.method });
+        log.warn(`mcp: ${name} did not answer within ${ms} ms; its next step is cancelled and its reply will be dropped`, { method: req.method });
+        abort.abort(new DOMException(`${name} did not finish within ${ms} ms`, 'TimeoutError'));
         if (!owedReply)
             return;
         const requestId = currentRequestId();
@@ -95,7 +101,7 @@ function watchDeadline(req, owedReply) {
         return expired;
     };
 }
-function dispatch(body) {
+function dispatch(body, abort) {
     let parsed;
     try {
         parsed = JSON.parse(body);
@@ -111,31 +117,42 @@ function dispatch(body) {
     }
     const req = parsed;
     if (req.method.startsWith('notifications/')) {
-        const stopWatching = watchDeadline(req, false);
+        const stopWatching = watchDeadline(req, false, abort);
         track(req.method, handleMcpRequest(req).then(() => { }).catch((err) => {
             log.error(`mcp notification ${req.method} failed: ${errorMessage(err)}`, errorFields(err));
         }).finally(stopWatching));
         return;
     }
     // A frame with no id is a notification under any method name, and JSON-RPC forbids answering one.
-    const timedOut = watchDeadline(req, isJsonString(req.id) || isJsonNumber(req.id));
+    const timedOut = watchDeadline(req, isJsonString(req.id) || isJsonNumber(req.id), abort);
     track(req.method, handleMcpRequest(req).then((resp) => { if (!timedOut() && resp)
         send(resp); }).catch((err) => {
-        if (timedOut())
-            log.debug(`mcp: ${callName(req)} failed after its timeout reply: ${errorMessage(err)}`);
+        if (timedOut() && err instanceof DOMException && err.name === 'TimeoutError')
+            log.debug(`mcp: ${callName(req)} stopped at its deadline`);
+        else if (timedOut())
+            log.error(`mcp: ${callName(req)} failed after its timeout reply: ${errorMessage(err)}`, errorFields(err));
         else
-            send(mcpErrorResponse(req.id, err));
+            send(mcpErrorResponse(req.id, err, undefined, callName(req)));
     }));
 }
 /** Wires stdin/stdout to the dispatcher; idempotent. Only the entrypoint (cli.ts `hippo mcp`, or this file run directly) should call it, so the HTTP daemon
  * (which imports `handleMcpRequest`) does not steal stdin or exit when its parent closes a pipe. */
 export function startStdioLoop() {
-    process.stdin.on('data', (chunk) => {
-        buffer = Buffer.concat([buffer, withoutRefused(chunk)]);
+    process.stdin.on('data', (raw) => {
+        const chunk = withoutRefused(raw);
+        pending.push(chunk);
+        pendingBytes += chunk.length;
+        // Joining on every chunk would copy the whole pending frame each time; wait until a frame can have ended.
+        if (needs === undefined ? !chunk.includes(0x0a) && pendingBytes <= MAX_BODY_BYTES : pendingBytes < needs)
+            return;
+        let buffer = Buffer.concat(pending, pendingBytes);
+        needs = undefined;
         while (true) {
             const result = parseFrame(buffer);
-            if (result.kind === 'incomplete')
+            if (result.kind === 'incomplete') {
+                needs = result.needs;
                 break;
+            }
             buffer = result.rest;
             if (result.kind === 'oversize') {
                 refused = result.remainder;
@@ -144,9 +161,13 @@ export function startStdioLoop() {
                 continue;
             }
             // One id per frame, so the error reply and every line logged for the call name the same request.
-            if (result.kind === 'message')
-                runWithRequestId(randomUUID(), () => dispatch(result.body));
+            if (result.kind === 'message') {
+                const abort = new AbortController();
+                runWithRequestId(randomUUID(), () => dispatch(result.body, abort), undefined, abort.signal);
+            }
         }
+        pending = buffer.length > 0 ? [buffer] : [];
+        pendingBytes = buffer.length;
     });
     process.stdin.on('end', () => { void exitWhenDrained(); });
     installCrashHandlers('mcp');