hippo-memory 1.71.0 → 1.72.0

package/dist/index.js

@@ -36,8 +36,9 @@ export { sleep } from './api/sleep.js';
 // Announced public in CHANGELOG 1.26.3 but never re-exported; the rest of dedupe.js stays internal.
 export { strengthBucket } from './consolidate/dedupe.js';
 // Feature 1: Embedding search
-export { isEmbeddingAvailable, getEmbedding } from './store/embeddings/local.js';
-export { cosineSimilarity, embedMemory, embedAll, } from './store/embeddings/index.js';
+export { isEmbeddingAvailable, getEmbedding } from './embeddings/local.js';
+export { cosineSimilarity } from './store/embeddings/index.js';
+export { embedMemory, embedAll } from './search/embed-memories.js';
 export { loadEmbeddingIndex, saveEmbeddingIndex } from './store/vector-index.js';
 // Feature 2: Auto-learn from errors
 export { captureError, extractLessons, partitionLessons, deduplicateLesson, runWatched, fetchGitLog, } from './learn/autolearn.js';

package/dist/learn/autolearn.d.ts

@@ -15,9 +15,17 @@ export declare function partitionLessons(lessons: string[]): {
 /** Check if a substantially similar memory already exists: true if overlap > threshold (default 0.7).
  *  `tenantId` applies only on the root-string overload; a pre-loaded MemoryEntry[] is already scoped, so it is ignored there. */
 export declare function deduplicateLesson(hippoRootOrEntries: string | MemoryEntry[], lesson: string, threshold?: number, tenantId?: string): boolean;
+/** A transfer command that has not exited in this long is hung on a prompt or a dead remote. */
+export declare const RUN_WATCHED_DEADLINE_MS: number;
+/** The command passed its deadline and was killed. */
+export declare class RunWatchedTimeoutError extends Error {
+    readonly deadlineMs: number;
+    readonly stderr: string;
+    constructor(deadlineMs: number, stderr: string);
+}
 /** Run a command in a shell, streaming stderr live; never pass text the caller did not write.
- *  Returns: { exitCode, stderr }. */
-export declare function runWatched(command: string): Promise<{
+ *  Returns: { exitCode, stderr } with only the last 64 KiB of stderr; rejects with RunWatchedTimeoutError past `deadlineMs`. */
+export declare function runWatched(command: string, deadlineMs?: number): Promise<{
     exitCode: number;
     stderr: string;
 }>;

package/dist/learn/autolearn.js

@@ -1,6 +1,6 @@
 /** Auto-learn from errors and git history.
  *  Agents learn from failures without explicit hippo remember calls. */
-import { execSync, execFileSync, spawn } from 'child_process';
+import { execFileSync, spawn } from 'child_process';
 import { createMemory, Layer, DEFAULT_HALF_LIFE_DAYS } from '../core/memory.js';
 import { loadAllEntries } from '../store/entry-reads.js';
 import { textOverlap } from '../util/tokenize.js';
@@ -97,25 +97,45 @@ export function deduplicateLesson(hippoRootOrEntries, lesson, threshold = 0.7, t
     }
     return false;
 }
+/** The most stderr `runWatched` returns; the terminal still gets all of it. */
+const STDERR_TAIL_BYTES = 64 * 1024;
+/** A transfer command that has not exited in this long is hung on a prompt or a dead remote. */
+export const RUN_WATCHED_DEADLINE_MS = 30 * 60_000;
+/** The command passed its deadline and was killed. */
+export class RunWatchedTimeoutError extends Error {
+    deadlineMs;
+    stderr;
+    constructor(deadlineMs, stderr) {
+        super(`the command did not exit within ${deadlineMs} ms and was killed`);
+        this.deadlineMs = deadlineMs;
+        this.stderr = stderr;
+        this.name = 'RunWatchedTimeoutError';
+    }
+}
 /** Run a command in a shell, streaming stderr live; never pass text the caller did not write.
- *  Returns: { exitCode, stderr }. */
-export function runWatched(command) {
-    return new Promise((resolve) => {
+ *  Returns: { exitCode, stderr } with only the last 64 KiB of stderr; rejects with RunWatchedTimeoutError past `deadlineMs`. */
+export function runWatched(command, deadlineMs = RUN_WATCHED_DEADLINE_MS) {
+    return new Promise((resolve, reject) => {
         // Use shell: true so the command string is handled by the shell as-is
         const child = spawn(command, { shell: true, stdio: ['inherit', 'inherit', 'pipe'], windowsHide: true });
-        const stderrChunks = [];
+        let tail = Buffer.alloc(0);
         child.stderr.on('data', (chunk) => {
-            stderrChunks.push(chunk);
-            // Also pass through to terminal
+            tail = Buffer.concat([tail, chunk]);
+            if (tail.length > STDERR_TAIL_BYTES)
+                tail = tail.subarray(tail.length - STDERR_TAIL_BYTES);
             process.stderr.write(chunk);
         });
+        // SHORTCUT: kills the shell only; on Windows a grandchild can outlive it. A process-tree kill is the upgrade path.
+        const timer = setTimeout(() => {
+            child.kill('SIGKILL');
+            reject(new RunWatchedTimeoutError(deadlineMs, tail.toString('utf8')));
+        }, deadlineMs);
         child.on('close', (code) => {
-            resolve({
-                exitCode: code ?? 1,
-                stderr: Buffer.concat(stderrChunks).toString('utf8'),
-            });
+            clearTimeout(timer);
+            resolve({ exitCode: code ?? 1, stderr: tail.toString('utf8') });
         });
         child.on('error', (err) => {
+            clearTimeout(timer);
             resolve({ exitCode: 1, stderr: err.message });
         });
     });
@@ -123,7 +143,7 @@ export function runWatched(command) {
 /** Check whether a directory is a git work tree. */
 export function isGitRepo(cwd) {
     try {
-        const raw = execSync('git rev-parse --is-inside-work-tree', {
+        const raw = execFileSync('git', ['rev-parse', '--is-inside-work-tree'], {
             encoding: 'utf8',
             cwd,
             timeout: 10000,

package/dist/learn/churn-git.js

@@ -3,12 +3,13 @@ import { execFileSync } from 'child_process';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
-import { DAY_MS } from '../util/time.js';
+import { DAY_MS, MINUTE_MS } from '../util/time.js';
 import { errorMessage } from '../util/log.js';
+import { isJsonObject, isJsonString } from '../util/json.js';
 // A `git log --name-status` dump can run to tens of MB; default 1MB pipe would truncate it.
 const GIT_MAX_BUFFER = 64 * 1024 * 1024;
 // Longer than the 10 s of one-line git reads because a full log dump on a large repo is slow, yet bounded so a wedged git cannot stall sleep.
-const GIT_TIMEOUT_MS = 60_000;
+const GIT_TIMEOUT_MS = MINUTE_MS;
 /** A real git failure (not git grep's expected exit-1-no-match). Callers abort the whole run on this. */
 export class GitReadError extends Error {
 }
@@ -93,9 +94,17 @@ export function packageScriptsAt(repoRoot, rev) {
         return {};
     const raw = runGit(['show', `${rev}:package.json`], repoRoot);
     try {
-        // SAFETY: optional chaining makes a `null` or scalar package.json read as "no scripts".
         const parsed = JSON.parse(raw);
-        return parsed?.scripts ?? {};
+        const scripts = isJsonObject(parsed) ? parsed.scripts : undefined;
+        if (!isJsonObject(scripts))
+            return {};
+        const out = {};
+        for (const [name, command] of Object.entries(scripts)) {
+            if (!isJsonString(command))
+                return {};
+            out[name] = command;
+        }
+        return out;
     }
     catch (err) {
         if (err instanceof SyntaxError)

package/dist/learn/extract.d.ts

@@ -1,4 +1,5 @@
 import { MemoryEntry, EmotionalValence } from '../core/memory.js';
+import { type AnthropicMessageFailure } from '../util/anthropic-messages.js';
 export interface ExtractedFact {
     content: string;
     tags: string[];
@@ -8,8 +9,8 @@ export interface ExtractOptions {
     apiKey: string;
     model?: string;
     fetcher?: typeof fetch;
-    /** Told why a call produced nothing, so callers can surface it instead of guessing. */
-    onError?: (msg: string) => void;
+    /** Told why a call produced nothing, so callers can surface it instead of guessing; `failure` is set when the API call itself failed. */
+    onError?: (msg: string, failure?: AnthropicMessageFailure) => void;
 }
 export declare function extractFacts(text: string, opts: ExtractOptions): Promise<ExtractedFact[]>;
 export declare function storeExtractedFacts(hippoRoot: string, source: MemoryEntry, facts: ExtractedFact[]): MemoryEntry[];

package/dist/learn/extract.js

@@ -1,20 +1,22 @@
 import { Layer, createMemory } from '../core/memory.js';
 import { writeEntry } from '../store/entry-writes.js';
 import { loadConfig } from '../core/config.js';
-import { RejectedValueError } from '../store/rejection.js';
+import { RejectedValueError } from '../core/api-errors.js';
 import { redactSecretsStrict } from '../util/secret-detect.js';
 import { describeMessageFailure, sendAnthropicMessage } from '../util/anthropic-messages.js';
 import { neverAutoShareTags } from '../sharing/share.js';
 import { errorMessage, log } from '../util/log.js';
 import { isJsonString } from '../util/json.js';
 import { certainDefect } from '../core/memory-quality.js';
-const EXTRACTION_PROMPT = `You are extracting factual statements from a conversation or memory entry. Extract 1-8 standalone factual statements that would be useful to remember later.
+const EXTRACTION_PROMPT = `You are extracting factual statements from a conversation or memory entry. ` +
+    `Extract 1-8 standalone factual statements that would be useful to remember later.
 
 Rules:
 - Each fact must be a complete, standalone sentence
 - Include the speaker's name in every fact (e.g. "Alice prefers..." not "She prefers...")
 - Preserve specific details: names, numbers, dates, paths, IDs
-- Return a JSON array of objects with: content (string), tags (array of "speaker:X" and "topic:Y" strings), valence ("neutral", "positive", "negative", or "critical")
+- Return a JSON array of objects with: content (string), tags (array of "speaker:X" and "topic:Y" strings), ` +
+    `valence ("neutral", "positive", "negative", or "critical")
 - Return an empty array [] for small talk with no extractable facts
 - Output ONLY the JSON array, no preamble or explanation
 
@@ -31,7 +33,7 @@ export async function extractFacts(text, opts) {
         fetcher: opts.fetcher,
     });
     if (!reply.ok) {
-        opts.onError?.(describeMessageFailure(reply.failure));
+        opts.onError?.(describeMessageFailure(reply.failure), reply.failure);
         return [];
     }
     try {

package/dist/learn/forward-claim-detector.js

@@ -7,7 +7,8 @@ const FORWARD_CLAIM_PATTERNS = [
     // Verb + duration tail: requires `<verb> take <N> <unit>`, because a bare `will take` matched `who will take ownership of auth?`.
     new RegExp(String.raw `\b(?:will|should|gonna|going\s+to)\s+take\s+${DURATION_TAIL}`, 'i'),
     // Ship + by/in + duration-or-day: a bare `ship in` matched `how does this ship in Docker?`, so a duration tail or literal day-of-week is required.
-    new RegExp(String.raw `\bship(?:ping|s)?\s+(?:by|in)\s+(?:(?:about|around)\s+)?(?:next\s+)?(?:${DURATION_TAIL}|(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday))\b`, 'i'),
+    new RegExp(String.raw `\bship(?:ping|s)?\s+(?:by|in)\s+(?:(?:about|around)\s+)?(?:next\s+)?` +
+        String.raw `(?:${DURATION_TAIL}|(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday))\b`, 'i'),
     /\bestimate(?:d)?\s+(?:at\s+)?(?:~|≈|about|around)?\s*\d+/i,
     /\b(?:by|in|within)\s+(?:about|around|~)?\s*\d+\s*(?:day|week|month|hour)s?\b/i,
     /\bETA\s*(?:is|:)?\s*\d+/i,
@@ -17,7 +18,8 @@ const FORWARD_CLAIM_PATTERNS = [
     /(?<=^|\s)~\s*\d+\s*(?:day|week|month|hour)s?\b/i,
     // Should + verb + duration tail. Same tightening as the leading 'will
     // take' rule: 'should ship by EOD' must include a quantifier.
-    new RegExp(String.raw `\bshould\s+(?:be|ship|finish|complete|land)\s+(?:by|in|within)\s+(?:(?:about|around)\s+)?(?:next\s+)?(?:${DURATION_TAIL}|(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday))\b`, 'i'),
+    new RegExp(String.raw `\bshould\s+(?:be|ship|finish|complete|land)\s+(?:by|in|within)\s+(?:(?:about|around)\s+)?(?:next\s+)?` +
+        String.raw `(?:${DURATION_TAIL}|(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday))\b`, 'i'),
 ];
 /** Pronouns, function words and modal verbs the regex set already gates on; dropped before class resolution so overlap comes from domain tokens. */
 const STOP_WORDS = new Set([

package/dist/learn/invalidation.js

@@ -1,6 +1,7 @@
-import { addTagToEntries, writeEntriesSeparately } from '../store/entry-writes.js';
+import { addTagToEntries, writeEntriesTogether } from '../store/entry-writes.js';
 import { confirmedOutcomeTimes } from '../store/audit.js';
-import { chunked, loadAllEntries, loadEntriesByIds } from '../store/entry-reads.js';
+import { loadAllEntries, loadEntriesByIds, loadEntriesMentioning, readEntry } from '../store/entry-reads.js';
+import { chunked } from '../util/chunked.js';
 import { CHURN_STALE_TAG } from '../core/memory.js';
 import { GitReadError, gitLsFilesAtHead, fetchChurnWindowLog, gitGrepPresence, resolveCommitBefore, packageScriptsAt, } from './churn-git.js';
 const HEADLINE_CHARS = 60;
@@ -46,9 +47,12 @@ export function extractInvalidationTarget(message) {
  *  Tag matching is EXACT: the FULL pattern must equal a tag, so a pattern merely containing a common tag word cannot mass-weaken every memory with that tag. */
 export function invalidateMatching(hippoRoot, target, tenantId, options) {
     // tenantId opt-in: when set, only that tenant's memories are weakened; undefined is host-wide.
-    // options.onlyId filters this tenant-scoped list rather than looking up an id directly, so another tenant's id is invisible here.
-    const { result, weakened } = weakenMatches(loadAllEntries(hippoRoot, tenantId), target, options);
-    writeEntriesSeparately(hippoRoot, weakened);
+    // The onlyId read is tenant-scoped too, so another tenant's id is invisible here.
+    const entries = options?.onlyId === undefined
+        ? loadEntriesMentioning(hippoRoot, invalidationTokenize(target.from), target.from.toLowerCase().trim(), tenantId)
+        : [readEntry(hippoRoot, options.onlyId, tenantId)].filter((entry) => entry !== null);
+    const { result, weakened } = weakenMatches(entries, target, options);
+    writeEntriesTogether(hippoRoot, weakened);
     return result;
 }
 /** invalidateMatching for a batch: matches against `live`, the caller's list of the tenant's rows, and keeps it current.
@@ -59,7 +63,7 @@ export function invalidateMatchingAmong(hippoRoot, live, target, tenantId) {
     // loadEntriesByIds reads at most 500 ids a call.
     const fresh = new Map(chunked(ids, 500).flatMap((chunk) => loadEntriesByIds(hippoRoot, chunk, tenantId)).map((entry) => [entry.id, entry]));
     const { result, weakened } = weakenMatches(ids.flatMap((id) => fresh.get(id) ?? []), target);
-    writeEntriesSeparately(hippoRoot, weakened);
+    writeEntriesTogether(hippoRoot, weakened);
     const byId = new Map(weakened.map((entry) => [entry.id, entry]));
     for (let i = 0; i < live.length; i++)
         live[i] = byId.get(live[i].id) ?? live[i];

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

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

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

@@ -29,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('');
@@ -54,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,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