hippo-memory 1.69.0 → 1.71.0

package/dist/mcp/memory-tools.js

@@ -1,13 +1,9 @@
 // Write-side tool handlers: hippo_remember, hippo_outcome and hippo_learn.
-import { log } from '../log.js';
-import { storeFor } from '../store-port.js';
-import { countCreatedSinceLastSleep } from '../store/index-and-stats.js';
-import { consolidate } from '../consolidate/sleep.js';
-import { outsideRequestStores, runWithRequestStores, scopedBusyWait } from '../db.js';
-import { resolveTenantId } from '../tenant.js';
-import { remember as apiRemember, outcome as apiOutcome, learn as apiLearn, MCP_LEARN } from '../api.js';
+import { storeFor } from '../store/index.js';
+import { startAutoSleepIfDue } from '../api/auto-sleep.js';
+import { remember as apiRemember, outcome as apiOutcome, learn as apiLearn, MCP_LEARN } from '../api/index.js';
 import { mcpActor } from './protocol.js';
-import { lastRecalledIds, autoSleepInFlight, resolveClientKey } from './session-state.js';
+import { lastRecalledIds, resolveClientKey } from './session-state.js';
 export async function runRememberTool({ args, ctx, hippoRoot, config, tenantId }) {
     const text = String(args.text || '');
     if (!text)
@@ -17,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,
@@ -35,24 +28,8 @@ export async function runRememberTool({ args, ctx, hippoRoot, config, tenantId }
         project: ctx?.project,
     });
     const [entry] = await storeFor(apiCtx).entriesByIds([result.id], tenantId);
-    // Auto-sleep: one run per store at a time, triggered by what arrived since the last one.
-    // Consolidation is host-wide, so only the host tenant's writes may start it. It runs on hippo.db, so another store skips it.
-    if ((ctx?.store === undefined || ctx.store.kind === 'sqlite') &&
-        ctx?.autoSleep !== false &&
-        config.autoSleep.enabled &&
-        tenantId === resolveTenantId({}) &&
-        !autoSleepInFlight.has(hippoRoot) &&
-        countCreatedSinceLastSleep(hippoRoot, tenantId) >= config.autoSleep.threshold) {
-        autoSleepInFlight.add(hippoRoot);
-        // Fire-and-forget (never block the response); an unhandled rejection would kill the server, so log it.
-        // Its own scope: the call's closes a handle the sleep still holds across its pauses, but the caller's lock wait carries over.
-        const busyWaitMs = scopedBusyWait();
-        outsideRequestStores(() => runWithRequestStores(() => consolidate(hippoRoot), { busyWaitMs }))
-            .catch((err) => {
-            log.error(`auto-sleep consolidate failed (tenant ${tenantId}): ${err instanceof Error ? err.message : String(err)}`);
-        })
-            .finally(() => autoSleepInFlight.delete(hippoRoot));
-    }
+    // Auto-sleep runs on hippo.db, so another store skips it.
+    startAutoSleepIfDue(hippoRoot, tenantId, config.autoSleep, (ctx?.store === undefined || ctx.store.kind === 'sqlite') && ctx?.autoSleep !== false);
     const halfLife = entry?.half_life_days ?? config.defaultHalfLifeDays;
     const tagStr = entry?.tags.join(', ') || tags.join(', ') || 'none';
     const warnings = (result.warnings ?? []).map((w) => `\nWarning: ${w}`).join('');
@@ -64,10 +41,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.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,

package/dist/mcp/protocol.d.ts

@@ -1,9 +1,9 @@
-import { loadConfig } from '../config.js';
-import type { Actor as ApiActor } from '../api.js';
-import { type ResolveProjectIdentityOpts } from '../project-identity.js';
-import type { JsonValue } from '../json.js';
-import type { CallerProject } from '../prompt-hook.js';
-import type { HippoStore } from '../store-port.js';
+import { loadConfig } from '../core/config.js';
+import type { Actor as ApiActor } from '../api/index.js';
+import { type ResolveProjectIdentityOpts } from '../core/project-identity.js';
+import { type JsonValue } from '../util/json.js';
+import type { CallerProject } from '../api/prompt-hook.js';
+import type { HippoStore } from '../store/index.js';
 /** Same bounded walk as the CLI (ends at home, so HIPPO_HOME wins over ~/.hippo); cwd/opts are the test seam. */
 export declare function findHippoRoot(cwd?: string, opts?: ResolveProjectIdentityOpts): string | null;
 interface McpRequest {
@@ -27,25 +27,14 @@ 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 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.
-     */
+    /** 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';
     /** Scope grants for the HTTP-MCP caller's key. Absent for stdio (admin, needs none). */
     scopes?: readonly string[];
@@ -56,24 +45,13 @@ export interface McpContext {
     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`.
-     */
+    /** 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: 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. */
 export declare function mcpActor(ctx: McpContext | undefined): ApiActor;
-export declare function isJsonBoolean(v: JsonValue | undefined): v is boolean;
-export declare function isJsonObjectRecord(v: JsonValue | undefined): v is {
-    [key: string]: JsonValue;
-};
 /** One tool call after the store, config and tenant are resolved; every handler reads the same four. */
 export interface ToolCall {
     args: Record<string, JsonValue>;

package/dist/mcp/protocol.js

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

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

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

package/dist/mcp/recall-tools.js

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

package/dist/mcp/request.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