hippo-memory 1.72.0 → 2.1.0

package/dist/server/routes/admin.d.ts

@@ -1,9 +1,9 @@
 import type { AuthedRouteRequest } from '../types.js';
-export declare function handleCreateAuthKey({ req, res, opts }: AuthedRouteRequest): Promise<void>;
-export declare function handleListAuthKeys({ res, ctx, query }: AuthedRouteRequest): Promise<void>;
-export declare function handleRevokeAuthKey({ res, ctx }: AuthedRouteRequest, keyMatch: Record<string, string>): Promise<void>;
-export declare function handleListQuarantine({ res, ctx, query }: AuthedRouteRequest): Promise<void>;
-export declare function handleApproveQuarantine({ res, ctx }: AuthedRouteRequest, quarantineApproveMatch: Record<string, string>): Promise<void>;
-export declare function handleRejectQuarantine({ res, ctx }: AuthedRouteRequest, quarantineRejectMatch: Record<string, string>): Promise<void>;
-export declare function handleListAudit({ res, ctx, query }: AuthedRouteRequest): Promise<void>;
+export declare function handleCreateAuthKey({ req, res, opts }: AuthedRouteRequest<'keyWrites'>): Promise<void>;
+export declare function handleListAuthKeys({ res, ctx, query }: AuthedRouteRequest<'keyWrites'>): Promise<void>;
+export declare function handleRevokeAuthKey({ res, ctx }: AuthedRouteRequest<'keyAudit'>, keyMatch: Record<string, string>): Promise<void>;
+export declare function handleListQuarantine({ res, ctx, query }: AuthedRouteRequest<'quarantine'>): Promise<void>;
+export declare function handleApproveQuarantine({ res, ctx }: AuthedRouteRequest<'quarantine'>, quarantineApproveMatch: Record<string, string>): Promise<void>;
+export declare function handleRejectQuarantine({ res, ctx }: AuthedRouteRequest<'quarantine'>, quarantineRejectMatch: Record<string, string>): Promise<void>;
+export declare function handleListAudit({ res, ctx, query }: AuthedRouteRequest<'auditLog'>): Promise<void>;
 //# sourceMappingURL=admin.d.ts.map

package/dist/server/routes/admin.js

@@ -1,7 +1,7 @@
 // Admin routes: API keys, quarantine and the audit log.
 import { DEFAULT_LIST_LIMIT } from '../../util/limits.js';
 import { AUDIT_OPS } from '../../store/audit.js';
-import { auditList, authCreate, authListRows, authRevoke, quarantineApprove, quarantineList, quarantineReject } from '../../api/index.js';
+import { auditList, authCreate, authListRows, authRevoke, narrowContext, quarantineApprove, quarantineList, quarantineReject, } from '../../api/index.js';
 import { HttpError, readBody, sendJson } from '../../util/http-util.js';
 import { assertCrossTenantAdmin, recheckContextWithAuth } from '../auth.js';
 import { pageOf, parseCursor, setNextCursorHeader } from '../cursor.js';
@@ -12,21 +12,28 @@ const VALID_AUDIT_OPS = new Set(AUDIT_OPS);
 // 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=: large enough to dump a small deployment's audit log unpaginated, small enough that a client cannot ask for the world.
+// Cap on GET /v1/audit?limit=: large enough to dump a small deployment's audit log unpaginated, small enough that a
+// client cannot ask for the world.
 const MAX_AUDIT_LIMIT = 10000;
 // GET /v1/auth/keys had no limit, so its default page is the cap: a deployment below 1000 keys sees no change.
 const MAX_AUTH_KEYS_PAGE = 1000;
-// POST /v1/auth/keys: mints a key; plaintext is in the response body (the CLI client, not this layer, carries the "store this somewhere safe" warning).
+// POST /v1/auth/keys: mints a key; plaintext is in the response body (the CLI client, not this layer, carries the
+// "store this somewhere safe" warning).
 export async function handleCreateAuthKey({ req, res, opts }) {
-    // The dispatch gate authenticated before the body, so an unknown caller costs no read; this recheck runs the resolver right before the mint.
-    const raw = await readBody(req, { maxBytes: MINT_BODY_MAX_BYTES, deadlineMs: opts.mintBodyDeadlineMs ?? MINT_BODY_DEADLINE_MS });
-    const ctx = await recheckContextWithAuth(req, opts);
+    // The dispatch gate authenticated before the body, so an unknown caller costs no read; this recheck runs the resolver
+    // right before the mint.
+    const raw = await readBody(req, {
+        maxBytes: MINT_BODY_MAX_BYTES,
+        deadlineMs: opts.mintBodyDeadlineMs ?? MINT_BODY_DEADLINE_MS,
+    });
+    const ctx = narrowContext(await recheckContextWithAuth(req, opts), 'keyWrites');
     const body = parseJsonObjectText(raw);
     const labelRaw = body['label'];
     if (labelRaw !== undefined && !isJsonString(labelRaw)) {
         throw new HttpError(400, 'label must be a string');
     }
-    // Optional body.role mirrors the --role CLI flag and is validated strictly: anything but 'admin'|'member' is a 400; authCreate refuses a member caller
+    // Optional body.role mirrors the --role CLI flag and is validated strictly: anything but 'admin'|'member' is a 400;
+    // authCreate refuses a member caller
     // with a 403.
     const roleRaw = body['role'];
     let role;
@@ -45,7 +52,8 @@ export async function handleCreateAuthKey({ req, res, opts }) {
     if (noExpiry !== undefined && !isJsonBoolean(noExpiry)) {
         throw new HttpError(400, 'noExpiry must be true or false');
     }
-    // Security: any body `tenantId` is IGNORED; the key is bound to the caller's authenticated tenant, or tenant A could mint a key for tenant B (see
+    // Security: any body `tenantId` is IGNORED; the key is bound to the caller's authenticated tenant, or tenant A could
+    // mint a key for tenant B (see
     // authCreate).
     const result = await authCreate(ctx, {
         label: labelRaw,
@@ -56,7 +64,8 @@ export async function handleCreateAuthKey({ req, res, opts }) {
     sendJson(res, 200, result);
     return;
 }
-// GET /v1/auth/keys?active=true&limit=&cursor=: lists keys visible to ctx.tenantId; `active` defaults to true, ?active=false includes revoked and expired rows.
+// GET /v1/auth/keys?active=true&limit=&cursor=: lists keys visible to ctx.tenantId; `active` defaults to true,
+// ?active=false includes revoked and expired rows.
 export async function handleListAuthKeys({ res, ctx, query }) {
     const activeRaw = query.get('active');
     let active = true;
@@ -70,12 +79,16 @@ export async function handleListAuthKeys({ res, ctx, query }) {
     }
     const limit = parseListLimit(query.get('limit'), MAX_AUTH_KEYS_PAGE, MAX_AUTH_KEYS_PAGE);
     const after = parseCursor(query.get('cursor'), 'integer', 'integer');
-    const page = pageOf(await authListRows(ctx, { active, limit: limit + 1, after }), limit, (r) => ({ key: r.rowId, id: r.rowId }));
+    const page = pageOf(await authListRows(ctx, { active, limit: limit + 1, after }), limit, (r) => ({
+        key: r.rowId,
+        id: r.rowId,
+    }));
     setNextCursorHeader(res, page.nextCursor);
     sendJson(res, 200, page.items.map((r) => r.key));
     return;
 }
-// DELETE /v1/auth/keys/:keyId revokes: missing or cross-tenant keys are 404 (no leak); a member is 403 on any key but its own or, via the resolver, those it
+// DELETE /v1/auth/keys/:keyId revokes: missing or cross-tenant keys are 404 (no leak); a member is 403 on any key but
+// its own or, via the resolver, those it
 // minted. Returns 200 with the body rather than 204 so the caller sees revokedAt.
 export async function handleRevokeAuthKey({ res, ctx }, keyMatch) {
     validateIdSegment(keyMatch.keyId, 'key id');
@@ -83,7 +96,8 @@ export async function handleRevokeAuthKey({ res, ctx }, keyMatch) {
     sendJson(res, 200, result);
     return;
 }
-// GET /v1/quarantine?status=&limit=&cursor=: quarantine review queue. quarantineList carries no role gate itself, so its row's admin gate is the check.
+// GET /v1/quarantine?status=&limit=&cursor=: quarantine review queue. quarantineList carries no role gate itself, so
+// its row's admin gate is the check.
 export async function handleListQuarantine({ res, ctx, query }) {
     const statusRaw = query.get('status');
     let status = 'pending';
@@ -95,7 +109,10 @@ export async function handleListQuarantine({ res, ctx, query }) {
     }
     const limit = parseListLimit(query.get('limit'));
     const after = parseCursor(query.get('cursor'), 'string', 'string');
-    const page = pageOf(await quarantineList(ctx, { status, limit: limit + 1, after }), limit, (q) => ({ key: q.quarantinedAt, id: q.id }));
+    const page = pageOf(await quarantineList(ctx, { status, limit: limit + 1, after }), limit, (q) => ({
+        key: q.quarantinedAt,
+        id: q.id,
+    }));
     sendJson(res, 200, { quarantine: page.items, next_cursor: page.nextCursor });
     return;
 }
@@ -113,7 +130,8 @@ export async function handleRejectQuarantine({ res, ctx }, quarantineRejectMatch
     sendJson(res, 200, { rejected: quarantineRejectMatch.id });
     return;
 }
-// GET /v1/audit?op=&since=&limit=&cursor=: all three filters are validated at the route boundary so an invalid value is a 400 before the DB is hit.
+// GET /v1/audit?op=&since=&limit=&cursor=: all three filters are validated at the route boundary so an invalid value is
+// a 400 before the DB is hit.
 export async function handleListAudit({ res, ctx, query }) {
     const opRaw = query.get('op');
     let op;
@@ -148,7 +166,10 @@ export async function handleListAudit({ res, ctx, query }) {
     if (crossTenant)
         assertCrossTenantAdmin(ctx, '/v1/audit?tenant= for another tenant');
     const effectiveCtx = crossTenant ? { ...ctx, tenantId: tenantOverride } : ctx;
-    const page = pageOf(await auditList(effectiveCtx, { op, since, limit: limit + 1, after }), limit, (e) => ({ key: e.ts, id: e.id }));
+    const page = pageOf(await auditList(effectiveCtx, { op, since, limit: limit + 1, after }), limit, (e) => ({
+        key: e.ts,
+        id: e.id,
+    }));
     setNextCursorHeader(res, page.nextCursor);
     sendJson(res, 200, page.items);
     return;

package/dist/server/routes/customer-notes.d.ts

@@ -1,7 +1,7 @@
 import type { AuthedRouteRequest } from '../types.js';
-export declare function handleCreateCustomerNote(rr: AuthedRouteRequest): Promise<void>;
-export declare function handleListCustomerNotes(rr: AuthedRouteRequest): Promise<void>;
-export declare function handleSupersedeCustomerNote(rr: AuthedRouteRequest, match: RegExpMatchArray): Promise<void>;
-export declare function handleCloseCustomerNote(rr: AuthedRouteRequest, match: RegExpMatchArray): Promise<void>;
-export declare function handleGetCustomerNote(rr: AuthedRouteRequest, match: RegExpMatchArray): Promise<void>;
+export declare function handleCreateCustomerNote(rr: AuthedRouteRequest<'objects'>): Promise<void>;
+export declare function handleListCustomerNotes(rr: AuthedRouteRequest<'objects'>): Promise<void>;
+export declare function handleSupersedeCustomerNote(rr: AuthedRouteRequest<'objects'>, match: RegExpMatchArray): Promise<void>;
+export declare function handleCloseCustomerNote(rr: AuthedRouteRequest<'objects'>, match: RegExpMatchArray): Promise<void>;
+export declare function handleGetCustomerNote(rr: AuthedRouteRequest<'objects'>, match: RegExpMatchArray): Promise<void>;
 //# sourceMappingURL=customer-notes.d.ts.map

package/dist/server/routes/customer-notes.js

@@ -1,9 +1,9 @@
 // /v1/customer-notes routes.
-import { CUSTOMER_NOTE, MAX_CHANGE_SUMMARY_LEN, MAX_CUSTOMER_LEN } from '../../objects/customer-notes.js';
+import { CUSTOMER_NOTE, MAX_CHANGE_SUMMARY_LEN, MAX_CUSTOMER_LEN, } from '../../objects/customer-notes.js';
 import { sendJson } from '../../util/http-util.js';
 import { parseJsonBody } from '../validation.js';
-import { saveFor } from '../../api/objects.js';
-import { closeRoute, getRoute, listRoute, optionalString, requiredString, supersedeRoute } from './object-routes.js';
+import { saveFor } from '../../api/objects/objects.js';
+import { closeRoute, getRoute, listRoute, optionalString, requiredString, supersedeRoute, } from './object-routes.js';
 const noteRoutes = {
     noun: 'customer note',
     field: 'note',
@@ -16,7 +16,8 @@ const noteRoutes = {
         return (existing, id) => ({ customer: existing.customer, note, changeSummary, supersedesNoteId: id });
     },
 };
-// Routes: customer notes under /v1/customer-notes (create, list, show, supersede, close), mirroring /v1/project-briefs. The store validates and throws;
+// Routes: customer notes under /v1/customer-notes (create, list, show, supersede, close), mirroring /v1/project-briefs.
+// The store validates and throws;
 // the boundary maps validation -> 400, not-found -> 404, not-active -> 409.
 export async function handleCreateCustomerNote(rr) {
     const { ctx } = rr;

package/dist/server/routes/decisions.d.ts

@@ -1,7 +1,7 @@
 import type { AuthedRouteRequest } from '../types.js';
-export declare function handleCreateDecision(rr: AuthedRouteRequest): Promise<void>;
-export declare function handleListDecisions(rr: AuthedRouteRequest): Promise<void>;
-export declare function handleSupersedeDecision(rr: AuthedRouteRequest, match: RegExpMatchArray): Promise<void>;
-export declare function handleCloseDecision(rr: AuthedRouteRequest, match: RegExpMatchArray): Promise<void>;
-export declare function handleGetDecision(rr: AuthedRouteRequest, match: RegExpMatchArray): Promise<void>;
+export declare function handleCreateDecision(rr: AuthedRouteRequest<'objects'>): Promise<void>;
+export declare function handleListDecisions(rr: AuthedRouteRequest<'objects'>): Promise<void>;
+export declare function handleSupersedeDecision(rr: AuthedRouteRequest<'objects'>, match: RegExpMatchArray): Promise<void>;
+export declare function handleCloseDecision(rr: AuthedRouteRequest<'objects'>, match: RegExpMatchArray): Promise<void>;
+export declare function handleGetDecision(rr: AuthedRouteRequest<'objects'>, match: RegExpMatchArray): Promise<void>;
 //# sourceMappingURL=decisions.d.ts.map

package/dist/server/routes/decisions.js

@@ -4,10 +4,17 @@ import { HttpError, sendJson } from '../../util/http-util.js';
 import { NotFoundError } from '../../core/api-errors.js';
 import { isJsonNumber } from '../../util/json.js';
 import { MAX_SHORT_FIELD_LEN, parseJsonBody } from '../validation.js';
-import { saveFor } from '../../api/objects.js';
-import { closeRoute, getRoute, listRoute, optionalString, requiredString } from './object-routes.js';
-const decisionRoutes = { noun: 'decision', field: 'decision', listField: 'decisions', object: DECISION };
+import { saveFor } from '../../api/objects/objects.js';
+import { closeRoute, getRoute, listRoute, optionalString, requiredString, } from './object-routes.js';
+const decisionRoutes = {
+    noun: 'decision',
+    field: 'decision',
+    listField: 'decisions',
+    object: DECISION,
+};
 const TEXT = { max: MAX_SHORT_FIELD_LEN, untrimmed: true };
+// The HTTP surface has no legacy --supersedes <memory-id> constraint, so it supersedes by table id and never weakens a
+// memory mirror.
 function supersededId(body) {
     const raw = body['supersedesDecisionId'];
     if (raw === undefined || raw === null)
@@ -17,8 +24,6 @@ function supersededId(body) {
     }
     return raw;
 }
-// Routes: /v1/decisions (create, list, show, supersede, close), Bearer-authed and tenant-scoped; status is validated against VALID_DECISION_STATES.
-// The HTTP surface has no legacy --supersedes <memory-id> constraint, so it supersedes by table id and never weakens a memory mirror.
 export async function handleCreateDecision(rr) {
     const { req, res, ctx } = rr;
     const body = await parseJsonBody(req, ctx);
@@ -41,7 +46,8 @@ export async function handleCreateDecision(rr) {
 export function handleListDecisions(rr) {
     return listRoute(decisionRoutes, rr);
 }
-// Not on supersedeRoute: this one answers 201 and leaves the missing-row 404 to the store, where the other five answer 200 after their own lookup.
+// Not on supersedeRoute: this one answers 201 and leaves the missing-row 404 to the store, where the other five answer
+// 200 after their own lookup.
 export async function handleSupersedeDecision(rr, match) {
     const oldId = parseInt(match[1], 10);
     const { ctx } = rr;

package/dist/server/routes/incidents.d.ts

@@ -1,7 +1,7 @@
 import type { AuthedRouteRequest } from '../types.js';
-export declare function handleCreateIncident(rr: AuthedRouteRequest): Promise<void>;
-export declare function handleListIncidents(rr: AuthedRouteRequest): Promise<void>;
-export declare function handleResolveIncident(rr: AuthedRouteRequest, match: RegExpMatchArray): Promise<void>;
-export declare function handleCloseIncident(rr: AuthedRouteRequest, match: RegExpMatchArray): Promise<void>;
-export declare function handleGetIncident(rr: AuthedRouteRequest, match: RegExpMatchArray): Promise<void>;
+export declare function handleCreateIncident(rr: AuthedRouteRequest<'objects'>): Promise<void>;
+export declare function handleListIncidents(rr: AuthedRouteRequest<'objects'>): Promise<void>;
+export declare function handleResolveIncident(rr: AuthedRouteRequest<'objects'>, match: RegExpMatchArray): Promise<void>;
+export declare function handleCloseIncident(rr: AuthedRouteRequest<'objects'>, match: RegExpMatchArray): Promise<void>;
+export declare function handleGetIncident(rr: AuthedRouteRequest<'objects'>, match: RegExpMatchArray): Promise<void>;
 //# sourceMappingURL=incidents.d.ts.map

package/dist/server/routes/incidents.js

@@ -4,10 +4,15 @@ import { HttpError, sendJson } from '../../util/http-util.js';
 import { NotFoundError } from '../../core/api-errors.js';
 import { MAX_SHORT_FIELD_LEN, parseJsonBody } from '../validation.js';
 import { isJsonString } from '../../util/json.js';
-import { objectsOf } from '../../api/objects.js';
-import { closeRoute, getRoute, listRoute, optionalString, requiredString } from './object-routes.js';
+import { objectsOf } from '../../api/objects/objects.js';
+import { closeRoute, getRoute, listRoute, optionalString, requiredString, } from './object-routes.js';
 const MAX_LINKED_MEMORY_IDS = 256;
-const incidentRoutes = { noun: 'incident', field: 'incident', listField: 'incidents', object: INCIDENT };
+const incidentRoutes = {
+    noun: 'incident',
+    field: 'incident',
+    listField: 'incidents',
+    object: INCIDENT,
+};
 function linkedMemoryIds(body) {
     const raw = body['linkedMemoryIds'];
     if (raw === undefined || raw === null)
@@ -24,7 +29,8 @@ function linkedMemoryIds(body) {
     }
     return raw;
 }
-// Routes: /v1/incidents (open, list, show, resolve, close), mirroring /v1/decisions; status is validated against VALID_INCIDENT_STATES.
+// Routes: /v1/incidents (open, list, show, resolve, close), mirroring /v1/decisions; status is validated against
+// VALID_INCIDENT_STATES.
 // Lifecycle is open->resolved->closed (no supersede), so linkedMemoryIds replaces supersedesDecisionId on create.
 export async function handleCreateIncident(rr) {
     const { req, res, opts, ctx } = rr;

package/dist/server/routes/memories.d.ts

@@ -1,10 +1,10 @@
 import type { AuthedRouteRequest } from '../types.js';
-export declare function handleCreateMemory({ req, res, ctx }: AuthedRouteRequest): Promise<void>;
-export declare function handleGetGraph({ res, ctx, query }: AuthedRouteRequest): Promise<void>;
-export declare function handleArchiveMemory({ req, res, ctx }: AuthedRouteRequest, archiveMatch: Record<string, string>): Promise<void>;
-export declare function handleSupersedeMemory({ req, res, ctx }: AuthedRouteRequest, supersedeMatch: Record<string, string>): Promise<void>;
-export declare function handlePromoteMemory({ res, ctx }: AuthedRouteRequest, promoteMatch: Record<string, string>): Promise<void>;
-export declare function handleForgetMemory({ res, ctx }: AuthedRouteRequest, idMatch: Record<string, string>): Promise<void>;
-export declare function handleApplyOutcome({ req, res, ctx }: AuthedRouteRequest): Promise<void>;
-export declare function handleSleep({ req, res, ctx }: AuthedRouteRequest): Promise<void>;
+export declare function handleCreateMemory({ req, res, ctx }: AuthedRouteRequest<'entryWrites'>): Promise<void>;
+export declare function handleGetGraph({ res, ctx, query }: AuthedRouteRequest<'graphReads'>): Promise<void>;
+export declare function handleArchiveMemory({ req, res, ctx }: AuthedRouteRequest<'entryWrites'>, archiveMatch: Record<string, string>): Promise<void>;
+export declare function handleSupersedeMemory({ req, res, ctx }: AuthedRouteRequest<'entryWrites'>, supersedeMatch: Record<string, string>): Promise<void>;
+export declare function handlePromoteMemory({ res, ctx }: AuthedRouteRequest<'localFiles'>, promoteMatch: Record<string, string>): Promise<void>;
+export declare function handleForgetMemory({ res, ctx }: AuthedRouteRequest<'entryWrites'>, idMatch: Record<string, string>): Promise<void>;
+export declare function handleApplyOutcome({ req, res, ctx }: AuthedRouteRequest<'entryWrites'>): Promise<void>;
+export declare function handleSleep({ req, res, ctx }: AuthedRouteRequest<'localFiles'>): Promise<void>;
 //# sourceMappingURL=memories.d.ts.map

package/dist/server/routes/memories.js

@@ -1,12 +1,11 @@
 // Memory write routes: create, graph, archive, supersede, promote, forget, outcome, sleep.
-import { graphRows } from '../../api/graph.js';
+import { graphEntityOf, graphRows } from '../../api/objects/graph.js';
 import { archiveRaw, forget, outcome, outcomeForLastRecall, promote, remember, supersede } from '../../api/index.js';
 import { MEMORY_KINDS } from '../../core/memory.js';
 import { graphModelOf } from '../../graph/view.js';
-import { MAX_ENTITY_NAME_LEN } from '../../store/graph-rows.js';
 import { HttpError, sendJson } from '../../util/http-util.js';
 import { sleepInChild } from '../sleep-offload.js';
-import { getCallerProject, getString, getStringArray, isSetMember, parseJsonBody, parseListLimit, validateIdSegment } from '../validation.js';
+import { getCallerProject, getString, getStringArray, isSetMember, parseJsonBody, parseListLimit, validateIdSegment, } from '../validation.js';
 import { isJsonString, isJsonBoolean } from '../../util/json.js';
 const VALID_KINDS = new Set(MEMORY_KINDS);
 // POST /v1/memories
@@ -39,14 +38,9 @@ export async function handleCreateMemory({ req, res, ctx }) {
 }
 // GET /v1/graph?entity=NAME&limit=N — read-only entity/relation graph (tenant-scoped)
 export async function handleGetGraph({ res, ctx, query }) {
-    const entityRaw = query.get('entity');
-    // Cap at the graph entity-name cap (512), not the id-shaped 256, so a valid
-    // long decision/policy name remains focusable over HTTP.
-    if (entityRaw !== null && entityRaw.length > MAX_ENTITY_NAME_LEN) {
-        throw new HttpError(400, `entity exceeds the ${MAX_ENTITY_NAME_LEN}-character cap`);
-    }
+    const entity = graphEntityOf(query.get('entity'));
     const limit = parseListLimit(query.get('limit'));
-    const rows = await graphRows(ctx, { entity: entityRaw ?? undefined, limit });
+    const rows = await graphRows(ctx, { entity, limit });
     sendJson(res, 200, graphModelOf(rows));
     return;
 }
@@ -85,8 +79,10 @@ export async function handleForgetMemory({ res, ctx }, idMatch) {
     sendJson(res, 200, result);
     return;
 }
-// POST /v1/outcome: applies a positive/negative outcome to memory ids; without ids it falls back to the last-recall path (api.outcomeForLastRecall)
-// and returns {applied, ids}, so callers can tell "no recent recall" from "all ids skipped". Each applied id writes one audit_log row (op='outcome').
+// POST /v1/outcome: applies a positive/negative outcome to memory ids; without ids it falls back to the last-recall
+// path (api.outcomeForLastRecall)
+// and returns {applied, ids}, so callers can tell "no recent recall" from "all ids skipped". Each applied id writes one
+// audit_log row (op='outcome').
 export async function handleApplyOutcome({ req, res, ctx }) {
     const body = await parseJsonBody(req, ctx);
     const good = body['good'];
@@ -103,7 +99,8 @@ export async function handleApplyOutcome({ req, res, ctx }) {
         if (!idsRaw.every(isNonEmptyId)) {
             throw new HttpError(400, 'ids must be an array of non-empty strings');
         }
-        // DoS cap on ids.length (each id costs ~3 DB ops): N=1000 keeps per-request work sub-second on SQLite. Auth runs first, so only a caller with a key
+        // DoS cap on ids.length (each id costs ~3 DB ops): N=1000 keeps per-request work sub-second on SQLite. Auth runs
+        // first, so only a caller with a key
         // reaches it.
         if (idsRaw.length > 1000) {
             throw new HttpError(400, 'ids exceeds 1000-id cap');
@@ -115,15 +112,13 @@ export async function handleApplyOutcome({ req, res, ctx }) {
         sendJson(res, 200, { applied });
     }
     else {
-        // The last recall's ids live in hippo.db alone, so a client of another store must send the ids its recall returned.
-        if (ctx.store !== undefined && ctx.store.kind !== 'sqlite')
-            throw new HttpError(501, 'this store keeps no last recall: send the ids your recall returned');
         const result = await outcomeForLastRecall(ctx, good);
         sendJson(res, 200, result);
     }
     return;
 }
-// POST /v1/sleep: host-wide consolidation (consolidate, dedup, audit, share, ambient); api.sleep spans the WHOLE hippoRoot, cross-tenant by design, so the
+// POST /v1/sleep: host-wide consolidation (consolidate, dedup, audit, share, ambient); api.sleep spans the WHOLE
+// hippoRoot, cross-tenant by design, so the
 // row's host-admin-local gate is the trust boundary. Body {dry_run?, no_share?}; returns SleepResult JSON.
 export async function handleSleep({ req, res, ctx }) {
     const body = await parseJsonBody(req, ctx);

package/dist/server/routes/object-routes.d.ts

@@ -16,7 +16,10 @@ export interface ObjectRouteConfig<K extends ObjectKind> {
 }
 export interface VersionedRouteConfig<K extends SavableKind, W> extends ObjectRouteConfig<K> {
     readonly object: SavableDescriptor<K, W>;
-    /** Checks the body, then returns the successor's write; split in two so a bad body answers 400 before a missing row answers 404. */
+    /**
+     * Checks the body, then returns the successor's write; split in two so a bad body answers 400 before a missing row
+     * answers 404.
+     */
     readonly revise: (body: Record<string, JsonValue>) => (existing: ObjectByKind[K], id: number) => W;
 }
 export interface RequiredStringRule {
@@ -28,8 +31,8 @@ export interface RequiredStringRule {
 }
 export declare function requiredString(body: Record<string, JsonValue>, key: string, rule: RequiredStringRule): string;
 export declare function optionalString(body: Record<string, JsonValue>, key: string, max: number): string | undefined;
-export declare function listRoute<K extends ObjectKind>(cfg: ObjectRouteConfig<K>, rr: AuthedRouteRequest): Promise<void>;
-export declare function getRoute<K extends ObjectKind>(cfg: ObjectRouteConfig<K>, rr: AuthedRouteRequest, match: RegExpMatchArray): Promise<void>;
-export declare function closeRoute<K extends ObjectKind>(cfg: ObjectRouteConfig<K>, rr: AuthedRouteRequest, match: RegExpMatchArray): Promise<void>;
-export declare function supersedeRoute<K extends SavableKind, W>(cfg: VersionedRouteConfig<K, W>, rr: AuthedRouteRequest, match: RegExpMatchArray): Promise<void>;
+export declare function listRoute<K extends ObjectKind>(cfg: ObjectRouteConfig<K>, rr: AuthedRouteRequest<'objects'>): Promise<void>;
+export declare function getRoute<K extends ObjectKind>(cfg: ObjectRouteConfig<K>, rr: AuthedRouteRequest<'objects'>, match: RegExpMatchArray): Promise<void>;
+export declare function closeRoute<K extends ObjectKind>(cfg: ObjectRouteConfig<K>, rr: AuthedRouteRequest<'objects'>, match: RegExpMatchArray): Promise<void>;
+export declare function supersedeRoute<K extends SavableKind, W>(cfg: VersionedRouteConfig<K, W>, rr: AuthedRouteRequest<'objects'>, match: RegExpMatchArray): Promise<void>;
 //# sourceMappingURL=object-routes.d.ts.map

package/dist/server/routes/object-routes.js

@@ -1,7 +1,7 @@
 // List, get, close and supersede handlers shared by the typed-object routes; each route file passes one config.
 import { HttpError, sendJson } from '../../util/http-util.js';
 import { isJsonString } from '../../util/json.js';
-import { objectsOf, saveFor } from '../../api/objects.js';
+import { objectsOf, saveFor } from '../../api/objects/objects.js';
 import { closeObject, listObjects, objectById } from '../../objects/lifecycle.js';
 import { byCreatedAt, pageOf, parseCursor } from '../cursor.js';
 import { isSetMember, parseJsonBody, parseListLimit } from '../validation.js';
@@ -56,7 +56,9 @@ export async function getRoute(cfg, rr, match) {
 export async function closeRoute(cfg, rr, match) {
     const id = parseInt(match[1], 10);
     const { ctx } = rr;
-    sendJson(rr.res, 200, { [cfg.field]: await closeObject(objectsOf(ctx), cfg.object, ctx.tenantId, id, ctx.actor.subject) });
+    sendJson(rr.res, 200, {
+        [cfg.field]: await closeObject(objectsOf(ctx), cfg.object, ctx.tenantId, id, ctx.actor.subject),
+    });
 }
 export async function supersedeRoute(cfg, rr, match) {
     const id = parseInt(match[1], 10);

package/dist/server/routes/policies.d.ts

@@ -1,8 +1,8 @@
 import type { AuthedRouteRequest } from '../types.js';
-export declare function handleCreatePolicy(rr: AuthedRouteRequest): Promise<void>;
-export declare function handleListPolicies(rr: AuthedRouteRequest): Promise<void>;
-export declare function handlePoliciesAsOf(rr: AuthedRouteRequest): Promise<void>;
-export declare function handleSupersedePolicy(rr: AuthedRouteRequest, match: RegExpMatchArray): Promise<void>;
-export declare function handleClosePolicy(rr: AuthedRouteRequest, match: RegExpMatchArray): Promise<void>;
-export declare function handleGetPolicy(rr: AuthedRouteRequest, match: RegExpMatchArray): Promise<void>;
+export declare function handleCreatePolicy(rr: AuthedRouteRequest<'objects'>): Promise<void>;
+export declare function handleListPolicies(rr: AuthedRouteRequest<'objects'>): Promise<void>;
+export declare function handlePoliciesAsOf(rr: AuthedRouteRequest<'objects'>): Promise<void>;
+export declare function handleSupersedePolicy(rr: AuthedRouteRequest<'objects'>, match: RegExpMatchArray): Promise<void>;
+export declare function handleClosePolicy(rr: AuthedRouteRequest<'objects'>, match: RegExpMatchArray): Promise<void>;
+export declare function handleGetPolicy(rr: AuthedRouteRequest<'objects'>, match: RegExpMatchArray): Promise<void>;
 //# sourceMappingURL=policies.d.ts.map

package/dist/server/routes/policies.js

@@ -2,9 +2,10 @@
 import { policiesAsOf, POLICY } from '../../objects/policies.js';
 import { HttpError, sendJson } from '../../util/http-util.js';
 import { MAX_SHORT_FIELD_LEN, parseJsonBody } from '../validation.js';
-import { objectsOf, saveFor } from '../../api/objects.js';
+import { objectsOf, saveFor } from '../../api/objects/objects.js';
 import { closeRoute, getRoute, listRoute, optionalString, requiredString, supersedeRoute, } from './object-routes.js';
-// The date fields get a type and length check only: the store parses the date, and the cap bounds a junk string before it reaches the Date parser.
+// The date fields get a type and length check only: the store parses the date, and the cap bounds a junk string before
+// it reaches the Date parser.
 const MAX_DATE_LEN = 64;
 const policyRoutes = {
     noun: 'policy',
@@ -16,10 +17,16 @@ const policyRoutes = {
         const validFrom = optionalString(body, 'validFrom', MAX_DATE_LEN);
         const validTo = optionalString(body, 'validTo', MAX_DATE_LEN);
         const changeSummary = optionalString(body, 'changeSummary', MAX_SHORT_FIELD_LEN);
-        return (existing, id) => ({ policyName: existing.policyName, policyText, validFrom, validTo, changeSummary, supersedesPolicyId: id });
+        return (existing, id) => ({
+            policyName: existing.policyName,
+            policyText,
+            validFrom,
+            validTo,
+            changeSummary,
+            supersedesPolicyId: id,
+        });
     },
 };
-// The as-of route is registered BEFORE /:id so the literal 'asof' is matched first; date errors surface as 400.
 export async function handleCreatePolicy(rr) {
     const { ctx } = rr;
     const body = await parseJsonBody(rr.req, ctx);

package/dist/server/routes/predictions.d.ts

@@ -1,7 +1,7 @@
 import type { AuthedRouteRequest } from '../types.js';
-export declare function handleCreatePrediction({ req, res, ctx, opts }: AuthedRouteRequest): Promise<void>;
-export declare function handleListPredictions({ res, ctx, query }: AuthedRouteRequest): Promise<void>;
-export declare function handlePredictionStats({ res, ctx, query }: AuthedRouteRequest): Promise<void>;
-export declare function handleGetPrediction({ res, ctx }: AuthedRouteRequest, predictionByIdMatch: RegExpMatchArray): Promise<void>;
-export declare function handleClosePrediction({ req, res, ctx }: AuthedRouteRequest, predictionCloseMatch: RegExpMatchArray): Promise<void>;
+export declare function handleCreatePrediction({ req, res, ctx, opts }: AuthedRouteRequest<'predictions'>): Promise<void>;
+export declare function handleListPredictions({ res, ctx, query }: AuthedRouteRequest<'predictions'>): Promise<void>;
+export declare function handlePredictionStats({ res, ctx, query }: AuthedRouteRequest<'predictions'>): Promise<void>;
+export declare function handleGetPrediction({ res, ctx }: AuthedRouteRequest<'predictions'>, predictionByIdMatch: RegExpMatchArray): Promise<void>;
+export declare function handleClosePrediction({ req, res, ctx }: AuthedRouteRequest<'predictions'>, predictionCloseMatch: RegExpMatchArray): Promise<void>;
 //# sourceMappingURL=predictions.d.ts.map

package/dist/server/routes/predictions.js

@@ -1,5 +1,5 @@
 // /v1/predictions routes.
-import { closePrediction, listPredictions, predictionBaserate, predictionById, savePrediction } from '../../api/predictions.js';
+import { closePrediction, listPredictions, predictionBaserate, predictionById, savePrediction, } from '../../api/objects/predictions.js';
 import { loadConfig } from '../../core/config.js';
 import { predictionMirror } from '../../store/predictions.js';
 import { VALID_CLOSURE_STATES } from '../../core/prediction.js';
@@ -8,7 +8,8 @@ import { MAX_ID_LEN } from '../../util/limits.js';
 import { byCreatedAt, pageOf, parseCursor } from '../cursor.js';
 import { isSetMember, MAX_SHORT_FIELD_LEN, parseJsonBody, parseListLimit } from '../validation.js';
 import { isJsonString, isJsonNumber } from '../../util/json.js';
-// Routes: /v1/predictions (create, list, show, close), Bearer-authed and tenant-scoped; closure_state is validated against VALID_CLOSURE_STATES.
+// Routes: /v1/predictions (create, list, show, close), Bearer-authed and tenant-scoped; closure_state is validated
+// against VALID_CLOSURE_STATES.
 // DoS caps: claim MAX_SHORT_FIELD_LEN chars, closureNote 2048.
 export async function handleCreatePrediction({ req, res, ctx, opts }) {
     const body = await parseJsonBody(req, ctx);
@@ -52,7 +53,10 @@ export async function handleCreatePrediction({ req, res, ctx, opts }) {
     const prediction = await savePrediction(ctx, { ...claimed, mirror });
     sendJson(res, 201, { prediction });
 }
-/** Which rows a list reads; a status other than all or open needs a class, as no store reads one closed state across classes. */
+/**
+ * Which rows a list reads; a status other than all or open needs a class, as no store reads one closed state across
+ * classes.
+ */
 function listFilter(classTag, status) {
     if (status === 'all')
         return { classTag };
@@ -75,7 +79,8 @@ export async function handleListPredictions({ res, ctx, query }) {
     const page = pageOf(predictions, limit, byCreatedAt);
     sendJson(res, 200, { predictions: page.items, next_cursor: page.nextCursor });
 }
-// Reference-class / planning-fallacy detector; registered BEFORE /v1/predictions/:id so dispatch order cannot matter ('stats' is not a number, but routing
+// Reference-class / planning-fallacy detector; registered BEFORE /v1/predictions/:id so dispatch order cannot matter
+// ('stats' is not a number, but routing
 // it first is safer).
 export async function handlePredictionStats({ res, ctx, query }) {
     const classTag = query.get('class');

package/dist/server/routes/processes.d.ts

@@ -1,7 +1,7 @@
 import type { AuthedRouteRequest } from '../types.js';
-export declare function handleCreateProcess(rr: AuthedRouteRequest): Promise<void>;
-export declare function handleListProcesses(rr: AuthedRouteRequest): Promise<void>;
-export declare function handleSupersedeProcess(rr: AuthedRouteRequest, match: RegExpMatchArray): Promise<void>;
-export declare function handleCloseProcess(rr: AuthedRouteRequest, match: RegExpMatchArray): Promise<void>;
-export declare function handleGetProcess(rr: AuthedRouteRequest, match: RegExpMatchArray): Promise<void>;
+export declare function handleCreateProcess(rr: AuthedRouteRequest<'objects'>): Promise<void>;
+export declare function handleListProcesses(rr: AuthedRouteRequest<'objects'>): Promise<void>;
+export declare function handleSupersedeProcess(rr: AuthedRouteRequest<'objects'>, match: RegExpMatchArray): Promise<void>;
+export declare function handleCloseProcess(rr: AuthedRouteRequest<'objects'>, match: RegExpMatchArray): Promise<void>;
+export declare function handleGetProcess(rr: AuthedRouteRequest<'objects'>, match: RegExpMatchArray): Promise<void>;
 //# sourceMappingURL=processes.d.ts.map

package/dist/server/routes/processes.js

@@ -3,9 +3,10 @@ import { MAX_PROCESS_STEP_LEN, MAX_PROCESS_STEPS, PROCESS } from '../../objects/
 import { HttpError, sendJson } from '../../util/http-util.js';
 import { MAX_SHORT_FIELD_LEN, parseJsonBody } from '../validation.js';
 import { isJsonString } from '../../util/json.js';
-import { saveFor } from '../../api/objects.js';
-import { closeRoute, getRoute, listRoute, optionalString, requiredString, supersedeRoute } from './object-routes.js';
-// HTTP-boundary validation for an untrusted process `steps` body; saveProcess re-validates and trims, this is the fail-fast 400 gate.
+import { saveFor } from '../../api/objects/objects.js';
+import { closeRoute, getRoute, listRoute, optionalString, requiredString, supersedeRoute, } from './object-routes.js';
+// HTTP-boundary validation for an untrusted process `steps` body; saveProcess re-validates and trims, this is the
+// fail-fast 400 gate.
 function validateProcessStepsBody(raw) {
     if (raw === undefined || raw === null)
         return [];
@@ -41,11 +42,19 @@ const processRoutes = {
         }
         const changeSummary = optionalString(body, 'changeSummary', MAX_SHORT_FIELD_LEN);
         const description = optionalString(body, 'description', MAX_SHORT_FIELD_LEN);
-        return (existing, id) => ({ processName: existing.processName, steps, description, changeSummary, supersedesProcessId: id });
+        return (existing, id) => ({
+            processName: existing.processName,
+            steps,
+            description,
+            changeSummary,
+            supersedesProcessId: id,
+        });
     },
 };
-// Routes: /v1/processes (create, list, show, supersede, close), mirroring /v1/decisions; supersede creates a new version that reuses the predecessor's name.
-// DoS caps: processName/description/changeSummary MAX_SHORT_FIELD_LEN, steps MAX_PROCESS_STEPS x MAX_PROCESS_STEP_LEN (validateProcessStepsBody).
+// Routes: /v1/processes (create, list, show, supersede, close), mirroring /v1/decisions; supersede creates a new
+// version that reuses the predecessor's name.
+// DoS caps: processName/description/changeSummary MAX_SHORT_FIELD_LEN, steps MAX_PROCESS_STEPS x MAX_PROCESS_STEP_LEN
+// (validateProcessStepsBody).
 export async function handleCreateProcess(rr) {
     const { ctx } = rr;
     const body = await parseJsonBody(rr.req, ctx);

package/dist/server/routes/project-briefs.d.ts

@@ -1,8 +1,8 @@
 import type { AuthedRouteRequest } from '../types.js';
-export declare function handleCreateProjectBrief(rr: AuthedRouteRequest): Promise<void>;
-export declare function handleListProjectBriefs(rr: AuthedRouteRequest): Promise<void>;
-export declare function handleRefreshProjectBrief(rr: AuthedRouteRequest): Promise<void>;
-export declare function handleSupersedeProjectBrief(rr: AuthedRouteRequest, match: RegExpMatchArray): Promise<void>;
-export declare function handleCloseProjectBrief(rr: AuthedRouteRequest, match: RegExpMatchArray): Promise<void>;
-export declare function handleGetProjectBrief(rr: AuthedRouteRequest, match: RegExpMatchArray): Promise<void>;
+export declare function handleCreateProjectBrief(rr: AuthedRouteRequest<'objects'>): Promise<void>;
+export declare function handleListProjectBriefs(rr: AuthedRouteRequest<'objects'>): Promise<void>;
+export declare function handleRefreshProjectBrief(rr: AuthedRouteRequest<'objects'>): Promise<void>;
+export declare function handleSupersedeProjectBrief(rr: AuthedRouteRequest<'objects'>, match: RegExpMatchArray): Promise<void>;
+export declare function handleCloseProjectBrief(rr: AuthedRouteRequest<'objects'>, match: RegExpMatchArray): Promise<void>;
+export declare function handleGetProjectBrief(rr: AuthedRouteRequest<'objects'>, match: RegExpMatchArray): Promise<void>;
 //# sourceMappingURL=project-briefs.d.ts.map