hippo-memory 1.63.2 → 1.64.0

package/dist/server/mcp-http.js

@@ -1,8 +1,10 @@
 // MCP over HTTP: POST /mcp and the GET /mcp/stream SSE keepalive.
 import { envMcpSseHeartbeatMs, envMcpSseMaxAgeSec, envMcpSseMaxStreams } from '../env.js';
 import { createHash } from 'node:crypto';
+import { isSharedStore } from '../config.js';
 import { handleMcpRequest, mcpErrorResponse } from '../mcp/server.js';
 import { HttpError, isJsonObjectRecord, readBody, sendJson } from '../http-util.js';
+import { assertCallerProject } from '../project-identity.js';
 import { buildContextWithAuth, heartbeatVerdict, readAuthHeader, requireAuth } from './auth.js';
 import { clientIpForRateLimit } from './client-ip.js';
 import { requestIds } from './request.js';
@@ -44,6 +46,57 @@ function buildMcpClientKey(req) {
 //
 // Auth: same as /v1/* — Bearer token validated via `requireAuth`, with the
 // loopback no-auth fallback. SSE check runs once at stream-open.
+// Percent-encoded by the client, so any lowercase Unicode name fits a Latin-1 header.
+const HEADER_PIECE = /^[A-Za-z0-9\-_.!~*'()%]+$/;
+function decodeHeaderPiece(raw, header) {
+    if (!HEADER_PIECE.test(raw))
+        throw new HttpError(400, `${header} must be percent-encoded, with no empty names`);
+    try {
+        return decodeURIComponent(raw);
+    }
+    catch {
+        throw new HttpError(400, `${header} holds a bad percent escape`);
+    }
+}
+/** On a shared store, the caller's project from X-Hippo-Project and the comma-separated X-Hippo-Project-Aliases; any other store ignores both. */
+export function callerProjectFromHeaders(req, hippoRoot) {
+    if (!isSharedStore(hippoRoot))
+        return undefined;
+    const names = req.headersDistinct['x-hippo-project'];
+    const aliasHeaders = req.headersDistinct['x-hippo-project-aliases'];
+    if (names === undefined) {
+        if (aliasHeaders !== undefined)
+            throw new HttpError(400, 'X-Hippo-Project-Aliases needs X-Hippo-Project');
+        return undefined;
+    }
+    if (names.length > 1 || (aliasHeaders?.length ?? 0) > 1)
+        throw new HttpError(400, 'send X-Hippo-Project and X-Hippo-Project-Aliases once each');
+    const name = decodeHeaderPiece(names[0], 'X-Hippo-Project');
+    const rawAliases = aliasHeaders?.[0] ?? '';
+    const aliases = rawAliases === '' ? [] : rawAliases.split(',').map((a) => decodeHeaderPiece(a, 'X-Hippo-Project-Aliases'));
+    assertCallerProject({ name, aliases });
+    return { name, legacyName: name, aliases };
+}
+export function mcpContextFor(ctx, clientKey, autoSleep, project) {
+    const mcpCtx = {
+        hippoRoot: ctx.hippoRoot,
+        tenantId: ctx.tenantId,
+        // McpContext.actor stays string; extract subject at the boundary.
+        actor: ctx.actor.subject,
+        // The caller's real role: MCP tools must not run a member key as admin.
+        role: ctx.actor.role,
+        scopes: ctx.actor.scopes,
+        viaAuthResolver: ctx.actor.viaAuthResolver,
+        hostAdmin: ctx.actor.hostAdmin,
+        owner: ctx.actor.owner,
+        clientKey,
+        store: ctx.store,
+        autoSleep,
+    };
+    if (project !== undefined)
+        mcpCtx.project = project;
+    return mcpCtx;
+}
 export async function handleMcpPost(req, res, opts) {
     // Build the same Context the /v1/* routes use so MCP tool calls inherit
     // the server's bound hippoRoot and the auth-resolved tenantId / actor.
@@ -51,6 +104,7 @@ export async function handleMcpPost(req, res, opts) {
     // pull tenant from HIPPO_TENANT, dropping a valid Bearer for tenant B
     // back to whatever the env says.
     const ctx = await buildContextWithAuth(req, opts);
+    const project = callerProjectFromHeaders(req, ctx.hippoRoot);
     const raw = await readBody(req);
     let mcpReq;
     try {
@@ -68,18 +122,7 @@ export async function handleMcpPost(req, res, opts) {
     const rpcReq = mcpReq;
     let mcpRes;
     try {
-        mcpRes = await handleMcpRequest(rpcReq, {
-            hippoRoot: ctx.hippoRoot,
-            tenantId: ctx.tenantId,
-            // McpContext.actor stays string; extract subject at the boundary.
-            actor: ctx.actor.subject,
-            // The caller's real role: MCP tools must not run a member key as admin.
-            role: ctx.actor.role,
-            scopes: ctx.actor.scopes,
-            viaAuthResolver: ctx.actor.viaAuthResolver,
-            hostAdmin: ctx.actor.hostAdmin,
-            clientKey: buildMcpClientKey(req),
-        });
+        mcpRes = await handleMcpRequest(rpcReq, mcpContextFor(ctx, buildMcpClientKey(req), opts.autoSleep, project));
     }
     catch (err) {
         mcpRes = mcpErrorResponse(rpcReq.id, err, requestIds.get(req));
@@ -107,7 +150,7 @@ function acquireStreamSlot(req, res, slots) {
     const key = streamSlotKey(req);
     const open = slots.get(key) ?? 0;
     if (open >= max)
-        throw new HttpError(429, `too many open streams for this client (limit ${max}); close one first`);
+        throw new HttpError(429, `too many open streams for this client (limit ${max}); close one first`, 60);
     slots.set(key, open + 1);
     res.once('close', () => {
         const left = (slots.get(key) ?? 1) - 1;

package/dist/server/request.d.ts

@@ -1,7 +1,7 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 /** The caller's `X-Request-Id` when it is a short plain token, else a fresh UUID. */
 export declare function resolveRequestId(header: string | string[] | undefined): string;
-/** One line per failed request; 4xx is the caller's mistake and a busy 503 is back-pressure the client retries, so neither logs as an error. */
+/** One line per failed request; 4xx is the caller's mistake, a busy 503 is back-pressure and a 501 is a route not on this store, so none logs as an error. */
 export declare function logRequestFailure<E>(req: IncomingMessage, err: E, requestId: string, status: number): void;
 /** The status and client message for a failed request; a held write lock is a retryable 503, never a 500. */
 export declare function replyFor<E>(err: E): {

package/dist/server/request.js

@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto';
-import { isSqliteBusy, STORE_BUSY_MESSAGE } from '../db.js';
+import { isStoreBusy, STORE_BUSY_MESSAGE } from '../db.js';
 import { errorFields, log } from '../log.js';
 import { HttpError, mapApiError, sendJson } from '../http-util.js';
 // The caller's id lands in a response header and in logs, so only a short plain token is echoed back.
@@ -9,20 +9,20 @@ export function resolveRequestId(header) {
     const value = Array.isArray(header) ? undefined : header;
     return value && REQUEST_ID_RE.test(value) ? value : randomUUID();
 }
-/** One line per failed request; 4xx is the caller's mistake and a busy 503 is back-pressure the client retries, so neither logs as an error. */
+/** One line per failed request; 4xx is the caller's mistake, a busy 503 is back-pressure and a 501 is a route not on this store, so none logs as an error. */
 export function logRequestFailure(req, err, requestId, status) {
     const message = err instanceof Error ? err.message : String(err);
     const line = `${req.method ?? 'GET'} ${(req.url ?? '/').split('?')[0]} failed: ${message}`;
-    if (isSqliteBusy(err))
+    if (isStoreBusy(err))
         log.warn(line, { requestId, status });
-    else if (status >= 500)
+    else if (status >= 500 && status !== 501)
         log.error(line, { requestId, status, ...errorFields(err) });
     else
         log.info(line, { requestId, status });
 }
 /** The status and client message for a failed request; a held write lock is a retryable 503, never a 500. */
 export function replyFor(err) {
-    return isSqliteBusy(err) ? { status: 503, message: STORE_BUSY_MESSAGE } : mapApiError(err);
+    return isStoreBusy(err) ? { status: 503, message: STORE_BUSY_MESSAGE } : mapApiError(err);
 }
 export function sendError(res, status, message) {
     sendJson(res, status, { error: message });

package/dist/server/routes/admin.js

@@ -1,12 +1,16 @@
 // Admin routes: API keys, quarantine and the audit log.
 import { AUDIT_OPS } from '../../audit.js';
 import { auditList, authCreate, authListRows, authRevoke, quarantineApprove, quarantineList, quarantineReject } from '../../api.js';
-import { HttpError, sendJson } from '../../http-util.js';
+import { HttpError, readBody, sendJson } from '../../http-util.js';
 import { assertCrossTenantAdmin, buildContextWithAuth } from '../auth.js';
 import { pageOf, parseCursor, setNextCursorHeader } from '../cursor.js';
-import { isSetMember, parseJsonBody, parseListLimit, validateIdSegment } from '../validation.js';
+import { isSetMember, parseJsonObjectText, parseListLimit, validateIdSegment } from '../validation.js';
 import { isJsonString } from '../../json.js';
 const VALID_AUDIT_OPS = new Set(AUDIT_OPS);
+// POST /v1/auth/keys reads its body before auth, so an unauthenticated caller can make the server buffer at most this many bytes and wait at most this many ms.
+// ServeOpts.mintBodyDeadlineMs overrides the wait for tests only, so a 408 test need not sit through it.
+const MINT_BODY_MAX_BYTES = 4 * 1024;
+const MINT_BODY_DEADLINE_MS = 10_000;
 // Cap on GET /v1/audit?limit=. Matches docs/api.md (when written) and is large
 // enough to dump a small deployment's full audit log without paginating, but
 // small enough that a malicious client can't ask for the world.
@@ -17,8 +21,10 @@ const MAX_AUTH_KEYS_PAGE = 1000;
 // body: the HTTP layer hands it to the client; the user-facing
 // "store this somewhere safe" warning belongs in the CLI client, not here.
 export async function handleCreateAuthKey({ req, res, opts }) {
+    // Body first, so the resolver's check (and any gate in it) runs right before the mint with no wait between.
+    const raw = await readBody(req, { maxBytes: MINT_BODY_MAX_BYTES, deadlineMs: opts.mintBodyDeadlineMs ?? MINT_BODY_DEADLINE_MS });
     const ctx = await buildContextWithAuth(req, opts);
-    const body = await parseJsonBody(req, ctx);
+    const body = parseJsonObjectText(raw);
     const labelRaw = body['label'];
     if (labelRaw !== undefined && !isJsonString(labelRaw)) {
         throw new HttpError(400, 'label must be a string');
@@ -47,7 +53,7 @@ export async function handleCreateAuthKey({ req, res, opts }) {
 }
 // GET /v1/auth/keys?active=true&limit=&cursor=: list keys visible to ctx.tenantId.
 // `active` defaults to true so the common case (show me usable keys) is
-// a single GET; ?active=false includes revoked rows.
+// a single GET; ?active=false includes revoked and expired rows.
 export async function handleListAuthKeys({ req, res, opts, query }) {
     const activeRaw = query.get('active');
     let active = true;
@@ -67,8 +73,8 @@ export async function handleListAuthKeys({ req, res, opts, query }) {
     sendJson(res, 200, page.items.map((r) => r.key));
     return;
 }
-// DELETE /v1/auth/keys/:keyId — revoke. Missing or cross-tenant keys are 404
-// (no info leak); a member key targeting any key but its own is 403.
+// DELETE /v1/auth/keys/:keyId — revoke. Missing or cross-tenant keys are 404 (no info leak); a member
+// is 403 on any key but its own key or, signed in through the resolver, the keys it minted.
 // 200 with the body rather than 204 so the caller sees revokedAt.
 export async function handleRevokeAuthKey({ req, res, opts }, keyMatch) {
     validateIdSegment(keyMatch.keyId, 'key id');

package/dist/server/routes/memories.js

@@ -3,8 +3,9 @@ import { archiveRaw, forget, outcome, outcomeForLastRecall, promote, remember, s
 import { buildGraphModel } from '../../graph-view.js';
 import { MAX_ENTITY_NAME_LEN } from '../../graph/types.js';
 import { HttpError, sendJson } from '../../http-util.js';
+import { canReadScope } from '../../recall-scope.js';
 import { assertCrossTenantAdmin, buildContextWithAuth, isLoopback } from '../auth.js';
-import { getString, getStringArray, isJsonBoolean, isSetMember, parseJsonBody, parseListLimit, validateIdSegment } from '../validation.js';
+import { getCallerProject, getString, getStringArray, isJsonBoolean, isSetMember, parseJsonBody, parseListLimit, validateIdSegment } from '../validation.js';
 import { isJsonString } from '../../json.js';
 const VALID_KINDS = new Set([
     'raw',
@@ -24,6 +25,10 @@ export async function handleCreateMemory({ req, res, opts }) {
     if (kindRaw !== undefined && !isSetMember(VALID_KINDS, kindRaw)) {
         throw new HttpError(400, `invalid kind: ${kindRaw}`);
     }
+    const personalRaw = body['personal'];
+    if (personalRaw !== undefined && !isJsonBoolean(personalRaw)) {
+        throw new HttpError(400, 'personal must be a boolean');
+    }
     const result = remember(ctx, {
         content,
         kind: kindRaw,
@@ -31,6 +36,8 @@ export async function handleCreateMemory({ req, res, opts }) {
         owner: getString(body, 'owner'),
         artifactRef: getString(body, 'artifactRef'),
         tags: getStringArray(body, 'tags'),
+        project: getCallerProject(body),
+        personal: personalRaw === true,
     });
     sendJson(res, 200, result);
     return;
@@ -48,6 +55,7 @@ export async function handleGetGraph({ req, res, opts, query }) {
     const model = buildGraphModel(ctx.hippoRoot, ctx.tenantId, {
         entity: entityRaw ?? undefined,
         limit,
+        canRead: (s) => s === null || canReadScope(ctx.actor, s),
     });
     sendJson(res, 200, model);
     return;

package/dist/server/routes/recall.js

@@ -1,6 +1,7 @@
 // Recall routes: /v1/memories search, assemble, drill and /v1/context.
 import { dirname, resolve } from 'node:path';
-import { resolveProjectIdentity } from '../../project-identity.js';
+import { assertCallerProject, resolveProjectIdentity } from '../../project-identity.js';
+import { isSharedStore } from '../../config.js';
 import { assembleCost, contextCost, drillCost } from '../../context-render.js';
 import { closeHippoDb, openHippoDb } from '../../db.js';
 import { updateStats } from '../../store/index-and-stats.js';
@@ -272,6 +273,17 @@ export async function handleDrillRecall({ req, res, opts, query }, drillMatch) {
     sendJson(res, 200, result);
     return;
 }
+/** A shared store's folder is no caller's project, so the caller names it (`project`, repeated `alias`); with none, getContext refuses. */
+function contextReader(hippoRoot, query) {
+    if (!isSharedStore(hippoRoot))
+        return resolveProjectIdentity(dirname(resolve(hippoRoot)));
+    const name = query.get('project');
+    if (name === null)
+        return '';
+    const aliases = query.getAll('alias');
+    assertCallerProject({ name, aliases });
+    return { name, legacyName: name, aliases };
+}
 // GET /v1/context — assemble a budget-bounded context bundle. Returns
 // ContextResult JSON (entries + tokens + activeSnapshot + sessionHandoff
 // + recentEvents). No server-side rendering; clients render. Tenant-scoped
@@ -332,7 +344,7 @@ export async function handleGetContext({ req, res, opts, query }) {
         scope,
         includeRecent,
         crossProject,
-        currentProject: resolveProjectIdentity(dirname(resolve(opts.hippoRoot))),
+        currentProject: contextReader(opts.hippoRoot, query),
         cost: contextCost('markdown', 'observe'), // clients render; the budget prices the block `hippo context` would print
     });
     recordTokens(ctx, 'http_context', { items: result.entries.length, tokens: result.tokens });

package/dist/server/types.d.ts

@@ -1,4 +1,8 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { Context } from '../api.js';
+import type { JsonValue } from '../json.js';
+import type { RateLimiter } from '../rate-limit.js';
+import type { HippoStore } from '../store-port.js';
 export interface ServerHandle {
     port: number;
     url: string;
@@ -19,6 +23,20 @@ export interface ResolvedBearer {
 }
 /** Sole judge of non-`hk_` bearer tokens: null is a 401; a throw or missed deadline is a 503, so throw only when upstream is down. */
 export type AuthResolver = (token: string) => ResolvedBearer | null | Promise<ResolvedBearer | null>;
+/** What an add-on route's handler gets: the caller core authenticated and the parsed JSON body. */
+export interface AddonCall {
+    readonly ctx: Context;
+    readonly body: Readonly<Record<string, JsonValue>>;
+}
+/** A POST /v1 route an add-on mounts through serve(): core authenticates and parses first, then sends the returned value as 200 JSON. */
+export interface AddonRoute {
+    readonly path: string;
+    readonly handler: (call: AddonCall) => Promise<JsonValue>;
+}
+export interface RateLimitSpec {
+    ratePerSec: number;
+    burst: number;
+}
 export interface ServeOpts {
     hippoRoot: string;
     /** Runs on every request and SSE heartbeat, so keep it cache-backed; API keys never reach it. */
@@ -31,26 +49,45 @@ export interface ServeOpts {
     handleSignals?: boolean;
     /** How long stop() lets in-flight requests finish before closing their sockets; defaults to 5000 ms. */
     shutdownDrainMs?: number;
+    /** Defaults to hippo.db under `hippoRoot`. A store of another kind runs only the routes ported to it; its caller closes it. */
+    store?: HippoStore;
+    autoSleep?: false;
+    routes?: readonly AddonRoute[];
+    mintBodyDeadlineMs?: number;
+    /** Static JSON served to anyone at GET <path>; built once at boot and never authenticated, so it must hold nothing secret. */
+    publicJson?: Readonly<Record<string, JsonValue>>;
+    /** Request limits: perCaller after auth; perAddress replaces HIPPO_V1_RPS when set, 'off' disables it; failedAuthPerAddress guards scrypt. */
+    rateLimits?: {
+        perCaller?: RateLimitSpec;
+        perAddress?: RateLimitSpec | 'off';
+        failedAuthPerAddress?: RateLimitSpec;
+    };
 }
+export type ResolvedServeOpts = ServeOpts & {
+    store: HippoStore;
+    publicJsonBodies: ReadonlyMap<string, string>;
+    callerLimiter?: RateLimiter;
+    failedAuthLimiter: RateLimiter;
+};
 /** Per-request values the /v1 route handlers read. */
 export interface RouteRequest {
     req: IncomingMessage;
     res: ServerResponse;
-    opts: ServeOpts;
+    opts: ResolvedServeOpts;
     query: URLSearchParams;
 }
-/** One /v1 route: an exact path, a matchPath pattern, or a regex, each paired with the handler for one method. */
+/** One /v1 route: an exact path, a matchPath pattern, or a regex, each paired with the handler for one method. `storeReady` routes run under any store. */
 export type Route = {
     method: string;
+    storeReady?: true;
+} & ({
     path: string;
     handler: (r: RouteRequest) => Promise<void>;
 } | {
-    method: string;
     pattern: string;
     handler: (r: RouteRequest, params: Record<string, string>) => Promise<void>;
 } | {
-    method: string;
     regex: RegExp;
     handler: (r: RouteRequest, match: RegExpMatchArray) => Promise<void>;
-};
+});
 //# sourceMappingURL=types.d.ts.map

package/dist/server/validation.d.ts

@@ -1,13 +1,16 @@
 import type { IncomingMessage } from 'node:http';
-import type { Context } from '../api.js';
+import type { Context, RememberOpts } from '../api.js';
 import { type JsonValue } from '../json.js';
 export declare function isJsonNumber(value: JsonValue | undefined): value is number;
 export declare function isJsonBoolean(value: JsonValue | undefined): value is boolean;
 export declare function isSetMember<T extends string>(set: ReadonlySet<T>, value: string): value is T;
 export declare function parseListLimit(limitRaw: string | null, defaultLimit?: number, maxLimit?: number): number;
-/** `_authed` is proof the caller passed auth: an unauthenticated request must never make the server read its body. */
+/** `_authed` is proof the caller passed auth, so a full-size body is read only for an authenticated caller; the key mint reads first under its own small cap. */
 export declare function parseJsonBody(req: IncomingMessage, _authed: Context): Promise<Record<string, JsonValue>>;
+export declare function parseJsonObjectText(raw: string): Record<string, JsonValue>;
 export declare function getString(obj: Record<string, JsonValue>, key: string): string | undefined;
 export declare function getStringArray(obj: Record<string, JsonValue>, key: string): string[] | undefined;
+/** Keeps only `name` and `aliases`: a client's `legacy_name` is a folder name, which must never become a row's origin. */
+export declare function getCallerProject(body: Record<string, JsonValue>): RememberOpts['project'];
 export declare function validateIdSegment(id: string, fieldName: string): void;
 //# sourceMappingURL=validation.d.ts.map

package/dist/server/validation.js

@@ -30,9 +30,11 @@ export function parseListLimit(limitRaw, defaultLimit = 100, maxLimit = 1000) {
     }
     return limit;
 }
-/** `_authed` is proof the caller passed auth: an unauthenticated request must never make the server read its body. */
+/** `_authed` is proof the caller passed auth, so a full-size body is read only for an authenticated caller; the key mint reads first under its own small cap. */
 export async function parseJsonBody(req, _authed) {
-    const raw = await readBody(req);
+    return parseJsonObjectText(await readBody(req));
+}
+export function parseJsonObjectText(raw) {
     if (raw.length === 0)
         return {};
     try {
@@ -60,6 +62,21 @@ export function getStringArray(obj, key) {
         return undefined;
     return v;
 }
+/** Keeps only `name` and `aliases`: a client's `legacy_name` is a folder name, which must never become a row's origin. */
+export function getCallerProject(body) {
+    const v = body.project;
+    if (v === undefined || v === null)
+        return undefined;
+    if (!isJsonObjectRecord(v) || !isJsonString(v.name)) {
+        throw new HttpError(400, 'project must be an object with a "name" string');
+    }
+    if (v.aliases === undefined)
+        return { name: v.name };
+    if (!Array.isArray(v.aliases) || !v.aliases.every(isJsonString)) {
+        throw new HttpError(400, 'project.aliases must be an array of strings');
+    }
+    return { name: v.name, aliases: v.aliases };
+}
 /**
  * Charset + length validation for `:id` route captures. Routes call
  * this immediately after `matchPath` to reject empty / overlong / illegal

package/dist/server.d.ts

@@ -1,12 +1,29 @@
-import { type Actor, authRevoke, type Context } from './api.js';
+import { type Actor, authCreateSelf, type AuthCreateSelfOpts, type AuthCreateSelfResult, authRevoke, type Context } from './api.js';
 import { ForbiddenError } from './api-errors.js';
 import type { ServeOpts, ServerHandle } from './server/types.js';
-export { authRevoke, ForbiddenError, type Context, type Actor };
+export { authCreateSelf, authRevoke, ForbiddenError, type AuthCreateSelfOpts, type AuthCreateSelfResult, type Context, type Actor };
 export { isCrossSite, LOOPBACK_HOST_HEADER } from './http-util.js';
 export { __resetSessionRecallHistoryHttp } from './server/routes/recall.js';
 export { clientIpForRateLimit } from './server/client-ip.js';
 export { isLoopback, isReservedActor } from './server/auth.js';
-export type { AuthResolver, ResolvedBearer, ServeOpts, ServerHandle } from './server/types.js';
+export type { AddonCall, AddonRoute, AuthResolver, RateLimitSpec, ResolvedBearer, ServeOpts, ServerHandle } from './server/types.js';
+export { HttpError } from './http-util.js';
+export { promptHookContext, type CallerProject } from './prompt-hook.js';
+export type { JsonValue } from './json.js';
+export { captureSessionTexts, type SessionCaptureRequest, type SessionCaptureResult } from './capture/session-texts.js';
+export { sqliteStore, type HippoStore } from './store-port.js';
+export type { ApiKeyRecord } from './auth.js';
+export { StoreBusyError } from './db.js';
+export { authCreate, type AuthCreateOpts, type AuthCreateResult } from './api.js';
+export { isSharedStore } from './config.js';
+export { ownerOrSubject } from './api.js';
+export { bindSessionOwner } from './session-owners.js';
+export { preCompactForCaller, type CallerHookOutput, type CallerPreCompactRequest } from './capture/pre-compact-caller.js';
+export { compactResumeForCaller, type CallerCompactResumeRequest } from './capture/compact-resume-caller.js';
+export { saveCompactionItemsForCaller, type CallerItemsRequest, type CallerItemsResult } from './capture/compaction-items-caller.js';
+export { captureFailureForCaller, type CallerFailureRequest, type CallerFailureResult } from './capture/failure-caller.js';
+export { sessionEndHandoffForCaller, type CallerEvidence, type CallerSessionEndRequest, type CallerSessionEndResult } from './capture/session-end-caller.js';
+export type { WorkingState } from './capture/working-state.js';
 /**
  * Boot the HTTP daemon on host:port and write the pidfile under hippoRoot.
  *
@@ -15,7 +32,7 @@ export type { AuthResolver, ResolvedBearer, ServeOpts, ServerHandle } from './se
  * requireAuth) has shipped and every route checks it except GET /health
  * (public by design for platform health checks) and the two connector
  * webhooks in PUBLIC_ROUTES, which are HMAC-gated by their own signing
- * secrets and 404 when those secrets are unset. But the loopback
+ * secrets and 404 when those secrets are unset, and any publicJson GET path. But the loopback
  * no-auth fallback inside buildContextWithAuth still admits unauthenticated
  * requests from a loopback remote address (unless they carry Forwarded,
  * X-Forwarded-For/-Host/-Proto, X-Real-IP, Cf-Connecting-Ip or True-Client-Ip, which mark a same-host proxy and get