hippo-memory 1.70.0 → 1.72.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/shared.js';
-import { requireGroup, storeFor } from '../store/index.js';
-import { NotFoundError } from '../core/api-errors.js';
-import { classifyOriginProject } from '../core/project-identity.js';
-import { canTouchScope, passesScopeFilterForRecall, personalScopeOf } from '../store/recall-scope.js';
-import { chunked, loadEntriesByIds, readEntry } from '../store/entry-reads.js';
+import { 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 { 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,37 +59,34 @@ 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}`);
-    // Pass tenantId so shareMemory's readEntry filters by tenant. Without
-    // this, a Bearer for tenant A could call hippo_share with tenant B's
-    // id and copy the row to the global store. The 'Memory not found'
-    // error matches the cross-tenant deny shape elsewhere in the code.
+    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 });
     if (!shared)
         return 'Transfer score too low. Use force=true to override.';

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.js

@@ -13,11 +13,8 @@ export async function runRememberTool({ args, ctx, hippoRoot, config, tenantId }
         tags.push('error');
     if (args.tag)
         tags.push(String(args.tag));
-    // Route through api.ts so audit_log captures the caller identity
-    // uniformly with CLI/REST: the auth-resolved ctx.actor under HTTP-MCP,
-    // 'mcp' for stdio (no ctx). api.ts.remember writes the memory + audit
-    // row in one transaction-friendly path; we re-read the entry to surface
-    // the half-life used in the MCP human-readable response.
+    // 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,
@@ -32,7 +29,8 @@ export async function runRememberTool({ args, ctx, hippoRoot, config, tenantId }
     });
     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 allowed = (ctx?.store === undefined || ctx.store.kind === 'sqlite') && ctx?.autoSleep !== false;
+    startAutoSleepIfDue(hippoRoot, tenantId, config.autoSleep, allowed, ctx?.autoSleepRunner);
     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('');
@@ -44,10 +42,8 @@ export async function runOutcomeTool({ args, ctx, hippoRoot, tenantId }) {
     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 enforced uniformly (same surface as recall/remember).
-    // outcome() also handles cross-tenant id skip 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,
@@ -59,6 +55,7 @@ export async function runOutcomeTool({ args, ctx, hippoRoot, tenantId }) {
 }
 export function runLearnTool({ args, ctx, hippoRoot, tenantId }) {
     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 = 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.';

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,51 +26,36 @@ 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 execution context threaded from a non-stdio transport. When the
- * HTTP transport in src/server.ts calls handleMcpRequest, it knows the
- * server's bound hippoRoot and the auth-resolved tenantId/actor. Passing
- * those through here lets executeTool skip the findHippoRoot() walk and
- * the env-based resolveTenantId({}) fallback — both of which would
- * otherwise produce the wrong store and the wrong tenant for HTTP callers.
- *
- * Stdio callers pass nothing; behavior stays unchanged for that path.
- */
+/** 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. */
 export interface McpContext {
     hippoRoot: string;
     tenantId: string;
     actor: string;
-    /**
-     * The caller's role from the HTTP transport's auth. Absent for stdio, which
-     * is the local operator and runs as admin. Tools must use this rather than
-     * assuming admin, 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;
-    /**
-     * Per-client key for state isolation under HTTP-MCP. For stdio: 'stdio-${pid}'
-     * (one process = one client). For HTTP-SSE / HTTP MCP: hash(bearer + remoteAddr)
-     * built by src/server.ts when constructing McpContext for the request.
-     * Optional for backwards compatibility; defaults to `${tenantId}:default`.
-     */
+    /** 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 transport's authenticated role is used, so
- * a member key never acts as admin through MCP.
- */
+/** 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/shared.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,32 +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 transport's authenticated role is used, so
- * a member key never acts as admin through MCP.
- */
+/** 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, buildSuppressionSummary } 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')
@@ -85,14 +87,14 @@ function recallPresenter(budget, options) {
             const tail = showTail
                 ? dropHeldCopies(tailRows.filter((r) => !shownIds.has(r.id) && !shownKeys.has(duplicateKey(r.content))), (r) => r)
                 : [];
-            const s = buildSuppressionSummary({
+            const s = {
                 totalCandidates: pool.length + droppedByScope,
                 droppedPreRank: droppedByScope + cut.length - list.length, // the bucket CLI and API recall put hidden copies in
                 droppedByBudget: Math.max(0, pool.length - cut.length), // an upper bound: rows that never matched count too
                 summarySubstitutionsAdded: tail.filter((r) => r.isSummary).length,
                 freshTailAdded: tail.filter((r) => r.isFreshTail && !r.isSummary).length,
                 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 = biasHintSections(anchoring, availability);
             if (showPlan)
@@ -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.d.ts

@@ -1,15 +1,7 @@
 import { type McpContext, type McpRequest, type McpResponse } from './protocol.js';
-/**
- * Record the memory text a recall or context tool returned. Best-effort: a
- * ledger failure never fails the tool call. Other tools are not recorded.
- */
+/** Records the memory text a recall or context tool returned; best-effort (a ledger failure never fails the call), other tools are not recorded. */
 export declare function recordMcpTokens(toolName: string, output: string, ctx?: McpContext): Promise<void>;
-/**
- * Transport-agnostic MCP dispatcher. Both the stdio loop (below) and the
- * HTTP/SSE transport in src/server.ts route every incoming JSON-RPC message
- * through this single function. Returns null for notifications (no response
- * expected) and a McpResponse otherwise. Errors thrown by `executeTool` are
- * the caller's problem — wrap with try/catch on the transport side.
- */
+/** Transport-agnostic MCP dispatcher: the stdio loop and the HTTP/SSE transport route every JSON-RPC message through it. Returns null for notifications.
+ * Errors thrown by `executeTool` are the caller's problem: wrap with try/catch on the transport side. */
 export declare function handleMcpRequest(req: McpRequest, ctx?: McpContext): Promise<McpResponse | null>;
 //# sourceMappingURL=request.d.ts.map

package/dist/mcp/request.js

@@ -1,10 +1,11 @@
 // Transport-agnostic request handling: tool dispatch table, tool execution and the JSON-RPC method switch.
 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 { 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 { runWithRequestStores } from '../db/index.js';
+import { rethrowIfSqliteBlocked } from '../util/sqlite-blocked.js';
 import { hasGroup, storeFor } from '../store/index.js';
 import { estimateTokens } from '../util/token-text.js';
 import { PACKAGE_VERSION } from '../util/version.js';
@@ -17,12 +18,8 @@ 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, 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
- * stderr (stdout carries the protocol). `hippo init` in a project later adds
- * a project store, which then takes precedence.
- */
+/** Zero-install first run (`npx -y hippo-memory mcp`, no store anywhere): create the global store instead of failing every tool call, and say so on stderr
+ * (stdout carries the protocol). A later `hippo init` project store takes precedence. */
 function createGlobalStoreOnFirstRun() {
     initGlobal();
     const root = getGlobalRoot();
@@ -34,10 +31,7 @@ const MCP_TOKEN_SURFACES = new Map([
     ['hippo_recall', 'mcp_recall'],
     ['hippo_context', 'mcp_context'],
 ]);
-/**
- * Record the memory text a recall or context tool returned. Best-effort: a
- * ledger failure never fails the tool call. Other tools are not recorded.
- */
+/** Records the memory text a recall or context tool returned; best-effort (a ledger failure never fails the call), other tools are not recorded. */
 export async function recordMcpTokens(toolName, output, ctx) {
     const surface = MCP_TOKEN_SURFACES.get(toolName);
     if (!surface || !output)
@@ -84,16 +78,12 @@ function runsOn(store, toolName) {
     return group !== undefined && hasGroup(store, group);
 }
 async function executeTool(name, args, ctx) {
-    // When a transport hands us a context (HTTP path), trust it: the HTTP
-    // server already resolved hippoRoot from its bound opts and tenantId
-    // from the Bearer token (or the loopback fallback). The stdio path
-    // continues to walk from cwd / fall back to the global root, and to
-    // resolve tenant from HIPPO_TENANT.
+    // With a transport context (HTTP), trust it: hippoRoot comes from the server's bound opts and tenantId from the Bearer (or loopback fallback).
+    // Stdio walks from cwd / the global root and resolves tenant from HIPPO_TENANT.
     const hippoRoot = ctx?.hippoRoot ?? findHippoRoot() ?? createGlobalStoreOnFirstRun();
     const config = loadConfig(hippoRoot);
-    // Every store read in this server returns to the caller and is
-    // tenant-isolated. Resolved once per tool call: prefer the transport's
-    // ctx.tenantId so an HTTP Bearer for tenant B doesn't drop to HIPPO_TENANT.
+    // Every store read here is tenant-isolated, resolved once per tool call; prefer the transport's ctx.tenantId so an HTTP Bearer for tenant B
+    // does not drop to HIPPO_TENANT.
     const tenantId = ctx?.tenantId ?? resolveTenantId({});
     const handler = TOOL_HANDLERS.get(name)?.handler;
     // handleMcpRequest rejects names missing from TOOLS, so reaching here means TOOLS and this table drifted apart.
@@ -155,13 +145,8 @@ async function callTool(id, params, ctx) {
         },
     };
 }
-/**
- * Transport-agnostic MCP dispatcher. Both the stdio loop (below) and the
- * HTTP/SSE transport in src/server.ts route every incoming JSON-RPC message
- * through this single function. Returns null for notifications (no response
- * expected) and a McpResponse otherwise. Errors thrown by `executeTool` are
- * the caller's problem — wrap with try/catch on the transport side.
- */
+/** Transport-agnostic MCP dispatcher: the stdio loop and the HTTP/SSE transport route every JSON-RPC message through it. Returns null for notifications.
+ * Errors thrown by `executeTool` are the caller's problem: wrap with try/catch on the transport side. */
 export async function handleMcpRequest(req, ctx) {
     const { id, method, params } = req;
     switch (method) {

package/dist/mcp/server.d.ts

@@ -1,13 +1,7 @@
 #!/usr/bin/env node
-/**
- * Hippo Memory MCP Server
- *
- * Exposes hippo memory as MCP tools over stdio transport.
- * Uses the programmatic API directly (no child process spawning).
- *
- * Usage: hippo mcp (or npx hippo-memory mcp)
- */
-export { __resetSessionRecallHistoryMcp } from './session-state.js';
+/** Hippo Memory MCP server: exposes hippo memory as MCP tools over stdio via the programmatic API (no child process). Usage: hippo mcp (or npx hippo-memory
+ * mcp). */
+export { _resetSessionRecallHistoryMcpForTests } from './session-state.js';
 export { findHippoRoot, mcpErrorResponse, type McpRequest, type McpResponse, type McpContext } from './protocol.js';
 export { handleMcpRequest } from './request.js';
 export { startStdioLoop } from './stdio.js';

package/dist/mcp/server.js

@@ -1,25 +1,14 @@
 #!/usr/bin/env node
-/**
- * Hippo Memory MCP Server
- *
- * Exposes hippo memory as MCP tools over stdio transport.
- * Uses the programmatic API directly (no child process spawning).
- *
- * Usage: hippo mcp (or npx hippo-memory mcp)
- */
-export { __resetSessionRecallHistoryMcp } from './session-state.js';
+/** Hippo Memory MCP server: exposes hippo memory as MCP tools over stdio via the programmatic API (no child process). Usage: hippo mcp (or npx hippo-memory
+ * mcp). */
+export { _resetSessionRecallHistoryMcpForTests } from './session-state.js';
 export { findHippoRoot, mcpErrorResponse } from './protocol.js';
 export { handleMcpRequest } from './request.js';
 export { startStdioLoop } from './stdio.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
-// module (e.g. src/server.ts wiring up the HTTP/SSE transport) will NOT
-// trigger the stdio loop. The cli imports this file specifically to start
-// stdio; that import is also `import.meta.url === main`-equivalent because
-// it's executed as the program, so we keep a fallback: if HIPPO_MCP_STDIO=1
-// or argv1 ends in /mcp/server.js we start.
+// Auto-start only as the main module (node dist/mcp/server.js or the cli's import('./mcp/server.js')); importing it elsewhere (the HTTP/SSE wiring) must not
+// start stdio. Fallback: HIPPO_MCP_STDIO=1 or argv1 ending in /mcp/server.js also starts it.
 const isMainModule = (() => {
     try {
         const argv1 = process.argv[1] ?? '';

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

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