hippo-memory 1.61.0 → 1.63.0

package/dist/secret-detect.js

@@ -1,6 +1,5 @@
 /**
- * Secret detection for memory content (v39 memory scope isolation, S4;
- * docs/plans/2026-07-01-memory-scope-isolation.md).
+ * Secret detection for memory content (memory scope isolation).
  *
  * Conservative, provider-bounded patterns only - a bare `sk-` in prose must
  * NOT flag. Detection gates two surfaces:
@@ -11,7 +10,7 @@
  *    project origin. Explicit recall is unaffected - recalling a secret is
  *    a deliberate act.
  *
- * This is deliberately a thin slice of the A4 lifecycle-compliance item
+ * This is deliberately a thin slice of lifecycle compliance
  * (no PII detection). Write-time scrubbing covers only text no person
  * typed into hippo; see `vetSecrets`.
  *
@@ -48,11 +47,8 @@ const SECRET_PATTERNS = [
     // Generic assignment: api_key=..., password: ..., token = "..." where the
     // value actually LOOKS like a credential: 12+ chars drawn only from
     // token-safe characters AND containing at least one digit. Without both
-    // constraints this pattern flags ordinary code snippets and prose -
-    // `token = estimateTokens(entry.content)` and "the secret: incremental-
-    // rollout worked well" were verified false positives that would silently
-    // hide real code-lesson memories from ambient context (post-merge
-    // adversarial review, 2026-07-02).
+    // constraints this pattern flags ordinary code snippets and prose
+    // (`token = estimateTokens(...)`), silently hiding code-lesson memories from ambient context.
     { name: 'secret-assignment', re: /\b(?:api[_-]?key|secret|token|password)\s*[:=]\s*['"]?(?=[A-Za-z0-9_\-+/]*\d)[A-Za-z0-9_\-+/=]{12,}/i },
 ];
 const KEYISH_CONTEXT_RE = /key|token|secret|credential|bearer|auth|password/i;
@@ -86,8 +82,8 @@ export function detectSecret(entry) {
  * Replace secret-shaped substrings in free text with a redaction marker.
  * Reuses the same `SECRET_PATTERNS` / co-occurrence guard as `detectSecret`
  * (which only flags whole-entry content) so callers that must persist raw
- * text that never passes through the normal capture content gate — e.g. the
- * CS1 pre-compact snapshot fields — can scrub it in place instead.
+ * text that never passes through the normal capture content gate (e.g. the
+ * pre-compact snapshot fields) can scrub it in place instead.
  */
 export function redactSecrets(text) {
     return redactText(text, false);

package/dist/server/auth.js

@@ -3,9 +3,9 @@ import { envRequireAuth } from '../env.js';
 import { resolveTenantId } from '../tenant.js';
 import { log } from '../log.js';
 import { API_KEY_PREFIX, verifyApiKeyCached } from '../auth.js';
-import { HttpError, isCrossSite, isHeaderString, LOOPBACK_HOST_HEADER } from '../http-util.js';
+import { HttpError, isCrossSite, isHeaderString, LOOPBACK_HOST_HEADER, MAX_ID_LEN } from '../http-util.js';
 import { requestIds } from './request.js';
-import { isJsonString } from './validation.js';
+import { isJsonString } from '../json.js';
 /**
  * Recognise loopback remote addresses. Node reports IPv6-mapped IPv4 as
  * '::ffff:127.0.0.1' on dual-stack sockets, so we accept that alongside
@@ -86,9 +86,9 @@ function sanitiseResolved(r) {
         return null;
     // Core reserves `__`-prefixed tenants (`__host__`, `__unroutable__`).
     const tenant = tenantId.trim();
-    if (tenant.startsWith('__') || tenant.length > 256 || hasControlChar(tenant))
+    if (tenant.startsWith('__') || tenant.length > MAX_ID_LEN || hasControlChar(tenant))
         return null;
-    if (!isJsonString(subject) || subject.length < 1 || subject.length > 256)
+    if (!isJsonString(subject) || subject.length < 1 || subject.length > MAX_ID_LEN)
         return null;
     // Padding would let "system " pass the reserved-name check yet read as `system` in an audit log.
     if (hasControlChar(subject) || subject !== subject.trim())
@@ -174,7 +174,7 @@ export async function buildContextWithAuth(req, opts) {
         throw new HttpError(401, 'auth required');
     }
     assertLocalCaller(req);
-    // v1.12.0: loopback fallback is process-local, treat as admin.
+    // Loopback fallback is process-local, treat as admin.
     return {
         hippoRoot: opts.hippoRoot,
         tenantId: resolveTenantId({}),

package/dist/server/client-ip.js

@@ -73,7 +73,7 @@ function isTrustedProxy(list, ip) {
     return family !== 0 && list.check(bare, family === 6 ? 'ipv6' : 'ipv4');
 }
 export function enforceRateLimit(req, path, limiter) {
-    // E3: per-IP rate limit on /v1/* and /mcp* to bound api-key-id enumeration. /health
+    // Per-IP rate limit on /v1/* and /mcp* to bound api-key-id enumeration. /health
     // (a liveness probe) and other paths are never throttled. A 429 thrown
     // here lands in the createServer catch like any other HttpError.
     //

package/dist/server/cursor.js

@@ -1,5 +1,6 @@
 import { HttpError } from '../http-util.js';
-import { isJsonNumber, isJsonString } from './validation.js';
+import { isJsonNumber } from './validation.js';
+import { isJsonString } from '../json.js';
 /** Bare-array routes cannot grow a body field without breaking clients, so their next cursor rides this header. */
 export const NEXT_CURSOR_HEADER = 'X-Next-Cursor';
 const MAX_CURSOR_CHARS = 1024;

package/dist/server/mcp-http.js

@@ -6,7 +6,7 @@ import { HttpError, isJsonObjectRecord, readBody, sendJson } from '../http-util.
 import { buildContextWithAuth, heartbeatVerdict, readAuthHeader, requireAuth } from './auth.js';
 import { clientIpForRateLimit } from './client-ip.js';
 import { requestIds } from './request.js';
-import { isJsonString } from './validation.js';
+import { isJsonString } from '../json.js';
 /**
  * Build a per-client key for MCP state isolation under HTTP-MCP. Used by
  * mcp/server.ts to scope `lastRecalledIds` to the calling client so two
@@ -26,7 +26,7 @@ function buildMcpClientKey(req) {
     const addr = req.socket.remoteAddress ?? 'unknown';
     return `http:${tokenHash}:${addr}`;
 }
-// ── MCP-over-HTTP/SSE transport (Task 11) ──
+// ── MCP-over-HTTP/SSE transport ──
 //
 // Two routes implement an MCP HTTP transport alongside the stdio one. Both
 // dispatch to the same `handleMcpRequest` as the stdio loop in src/mcp/server.ts.
@@ -71,7 +71,7 @@ export async function handleMcpPost(req, res, opts) {
         mcpRes = await handleMcpRequest(rpcReq, {
             hippoRoot: ctx.hippoRoot,
             tenantId: ctx.tenantId,
-            // v1.12.0: McpContext.actor stays string; extract subject at the boundary.
+            // 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,
@@ -131,7 +131,7 @@ export async function handleMcpStream(req, res, opts, streamSlots) {
     // Initial ping so smoke tests can confirm the stream is live without
     // waiting for the first keepalive interval.
     res.write(': ping\n\n');
-    // v0.39 SSE hardening:
+    // SSE hardening:
     //   - Heartbeat re-validates the bearer (default 60s). If the key was
     //     revoked or rotated, close the stream with reason='auth_revoked'.
     //   - MCP_SSE_MAX_AGE_SEC (default 3600) caps stream lifetime; close

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, so it stays below the default level and skips the stack. */
+/** 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. */
 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): {
@@ -22,11 +22,8 @@ export declare const requestIds: WeakMap<IncomingMessage, string>;
  * them — otherwise `%2F` becomes `/`, path-split runs, and the route either
  * silently 404s or matches the wrong template.
  *
- * codex round 3 P2: only scan the PATHNAME portion of the raw URL, not the
- * query string. Pre-fix, `?q=https%3A%2F%2Fexample.com` would 400 because
- * the regex matched `%2F` anywhere in `req.url`. Recall queries containing
- * URLs would have been rejected as bypass attempts. Splitting on the first
- * `?` confines the check to the path.
+ * Only the PATHNAME is scanned (split on the first `?`), so recall queries
+ * containing URLs like `?q=https%3A%2F%2Fexample.com` are not rejected.
  */
 export declare function rejectEncodedSlash(rawUrl: string): void;
 export {};

package/dist/server/request.js

@@ -9,11 +9,13 @@ 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, so it stays below the default level and skips the stack. */
+/** 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. */
 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 (status >= 500)
+    if (isSqliteBusy(err))
+        log.warn(line, { requestId, status });
+    else if (status >= 500)
         log.error(line, { requestId, status, ...errorFields(err) });
     else
         log.info(line, { requestId, status });
@@ -87,11 +89,8 @@ export const requestIds = new WeakMap();
  * them — otherwise `%2F` becomes `/`, path-split runs, and the route either
  * silently 404s or matches the wrong template.
  *
- * codex round 3 P2: only scan the PATHNAME portion of the raw URL, not the
- * query string. Pre-fix, `?q=https%3A%2F%2Fexample.com` would 400 because
- * the regex matched `%2F` anywhere in `req.url`. Recall queries containing
- * URLs would have been rejected as bypass attempts. Splitting on the first
- * `?` confines the check to the path.
+ * Only the PATHNAME is scanned (split on the first `?`), so recall queries
+ * containing URLs like `?q=https%3A%2F%2Fexample.com` are not rejected.
  */
 export function rejectEncodedSlash(rawUrl) {
     const queryIdx = rawUrl.indexOf('?');

package/dist/server/routes/admin.js

@@ -4,7 +4,8 @@ import { auditList, authCreate, authListRows, authRevoke, quarantineApprove, qua
 import { HttpError, sendJson } from '../../http-util.js';
 import { assertCrossTenantAdmin, buildContextWithAuth } from '../auth.js';
 import { pageOf, parseCursor, setNextCursorHeader } from '../cursor.js';
-import { isJsonString, isSetMember, parseJsonBody, parseListLimit, validateIdSegment } from '../validation.js';
+import { isSetMember, parseJsonBody, parseListLimit, validateIdSegment } from '../validation.js';
+import { isJsonString } from '../../json.js';
 const VALID_AUDIT_OPS = new Set(AUDIT_OPS);
 // 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
@@ -13,7 +14,7 @@ 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 — mint a new API key. Plaintext lands in the response
-// body (Task 8): the HTTP layer hands it to the client; the user-facing
+// 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 }) {
     const ctx = await buildContextWithAuth(req, opts);
@@ -22,7 +23,7 @@ export async function handleCreateAuthKey({ req, res, opts }) {
     if (labelRaw !== undefined && !isJsonString(labelRaw)) {
         throw new HttpError(400, 'label must be a string');
     }
-    // v1.12.3: optional body.role mirrors the --role CLI flag. Validated
+    // Optional body.role mirrors the --role CLI flag. Validated
     // strictly — anything other than 'admin'|'member' is a 400 (no silent
     // fallback to admin). authCreate refuses a member caller with a 403.
     const roleRaw = body['role'];
@@ -76,7 +77,7 @@ export async function handleRevokeAuthKey({ req, res, opts }, keyMatch) {
     sendJson(res, 200, result);
     return;
 }
-// GET /v1/quarantine?status=&limit=&cursor=: CD5 review queue. quarantineList carries no role gate itself, so it's checked here.
+// GET /v1/quarantine?status=&limit=&cursor=: quarantine review queue. quarantineList carries no role gate itself, so it's checked here.
 export async function handleListQuarantine({ req, res, opts, query }) {
     const ctx = await buildContextWithAuth(req, opts);
     if (ctx.actor.role !== 'admin') {

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

@@ -1,10 +1,11 @@
 // /v1/customer-notes routes.
-import { closeCustomerNote, loadCustomerNoteById, loadCustomerNotes, saveCustomerNote, VALID_NOTE_STATES } from '../../customer-notes.js';
+import { closeCustomerNote, loadCustomerNoteById, loadCustomerNotes, MAX_CUSTOMER_LEN, saveCustomerNote, VALID_NOTE_STATES } from '../../customer-notes.js';
 import { HttpError, sendJson } from '../../http-util.js';
 import { buildContextWithAuth } from '../auth.js';
 import { byCreatedAt, pageOf, parseCursor } from '../cursor.js';
-import { isJsonString, isSetMember, parseJsonBody, parseListLimit } from '../validation.js';
-// ── E2 customer_note routes ──
+import { isSetMember, parseJsonBody, parseListLimit } from '../validation.js';
+import { isJsonString } from '../../json.js';
+// ── customer_note routes ──
 //
 // 5 routes (no assembler/refresh): POST /v1/customer-notes (new; body customer +
 // note), GET /v1/customer-notes (list; status + customer filter; shared
@@ -19,8 +20,8 @@ export async function handleCreateCustomerNote({ req, res, opts }) {
     if (!isJsonString(customer) || customer.trim().length === 0) {
         throw new HttpError(400, 'customer is required (non-empty string)');
     }
-    if (customer.length > 256) {
-        throw new HttpError(400, 'customer exceeds 256-character cap');
+    if (customer.length > MAX_CUSTOMER_LEN) {
+        throw new HttpError(400, `customer exceeds ${MAX_CUSTOMER_LEN}-character cap`);
     }
     const note = body['note'];
     if (!isJsonString(note) || note.trim().length === 0) {

package/dist/server/routes/decisions.js

@@ -4,15 +4,16 @@ import { HttpError, sendJson } from '../../http-util.js';
 import { NotFoundError } from '../../api-errors.js';
 import { buildContextWithAuth } from '../auth.js';
 import { byCreatedAt, pageOf, parseCursor } from '../cursor.js';
-import { isJsonNumber, isJsonString, isSetMember, parseJsonBody, parseListLimit } from '../validation.js';
-// ── decisions (E2 first-class object) ──
+import { isJsonNumber, isSetMember, parseJsonBody, parseListLimit } from '../validation.js';
+import { isJsonString } from '../../json.js';
+// ── decisions (first-class object) ──
 //
 // 5 routes: POST /v1/decisions (create, optional supersedesDecisionId),
 // GET /v1/decisions (list, status filter), GET /v1/decisions/:id (show),
 // POST /v1/decisions/:id/supersede (create a successor + supersede :id),
 // POST /v1/decisions/:id/close (retire). Bearer-authed + tenant-scoped via
 // buildContextWithAuth. status validated against VALID_DECISION_STATES.
-// DoS caps: text 4096, context 4096 (v1.11.4 pattern). The HTTP surface is
+// DoS caps: text 4096, context 4096. The HTTP surface is
 // new (no legacy --supersedes <memory-id> constraint), so it supersedes by
 // table id and never weakens a memory mirror.
 export async function handleCreateDecision({ req, res, opts }) {

package/dist/server/routes/incidents.js

@@ -4,8 +4,10 @@ import { HttpError, sendJson } from '../../http-util.js';
 import { NotFoundError } from '../../api-errors.js';
 import { buildContextWithAuth } from '../auth.js';
 import { byCreatedAt, pageOf, parseCursor } from '../cursor.js';
-import { isJsonString, isSetMember, parseJsonBody, parseListLimit } from '../validation.js';
-// ── incidents (E2 first-class object) ──
+import { isSetMember, parseJsonBody, parseListLimit } from '../validation.js';
+import { isJsonString } from '../../json.js';
+const MAX_LINKED_MEMORY_IDS = 256;
+// ── incidents (first-class object) ──
 //
 // 5 routes: POST /v1/incidents (open; body text + context + linkedMemoryIds[]),
 // GET /v1/incidents (list, status filter), GET /v1/incidents/:id (show),
@@ -13,7 +15,7 @@ import { isJsonString, isSetMember, parseJsonBody, parseListLimit } from '../val
 // POST /v1/incidents/:id/close (open|resolved -> closed). Bearer-authed +
 // tenant-scoped via buildContextWithAuth. status validated against
 // VALID_INCIDENT_STATES. DoS caps: text 4096, context 4096, resolutionText
-// 4096 (v1.11.4 pattern). Mirrors /v1/decisions; lifecycle is
+// 4096. Mirrors /v1/decisions; lifecycle is
 // open->resolved->closed (no supersede), so linkedMemoryIds replaces
 // supersedesDecisionId on create.
 export async function handleCreateIncident({ req, res, opts }) {
@@ -43,8 +45,8 @@ export async function handleCreateIncident({ req, res, opts }) {
         if (!Array.isArray(linkedRaw)) {
             throw new HttpError(400, 'linkedMemoryIds must be an array of memory ids');
         }
-        if (linkedRaw.length > 256) {
-            throw new HttpError(400, 'linkedMemoryIds exceeds 256-item cap');
+        if (linkedRaw.length > MAX_LINKED_MEMORY_IDS) {
+            throw new HttpError(400, `linkedMemoryIds exceeds ${MAX_LINKED_MEMORY_IDS}-item cap`);
         }
         const isValidMemoryId = (item) => isJsonString(item) && item.length > 0 && item.length <= 4096;
         if (!linkedRaw.every(isValidMemoryId)) {

package/dist/server/routes/memories.js

@@ -4,7 +4,8 @@ import { buildGraphModel } from '../../graph-view.js';
 import { MAX_ENTITY_NAME_LEN } from '../../graph/types.js';
 import { HttpError, sendJson } from '../../http-util.js';
 import { assertCrossTenantAdmin, buildContextWithAuth, isLoopback } from '../auth.js';
-import { getString, getStringArray, isJsonBoolean, isJsonString, isSetMember, parseJsonBody, parseListLimit, validateIdSegment } from '../validation.js';
+import { getString, getStringArray, isJsonBoolean, isSetMember, parseJsonBody, parseListLimit, validateIdSegment } from '../validation.js';
+import { isJsonString } from '../../json.js';
 const VALID_KINDS = new Set([
     'raw',
     'distilled',
@@ -38,7 +39,7 @@ export async function handleCreateMemory({ req, res, opts }) {
 export async function handleGetGraph({ req, res, opts, 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 (codex P2).
+    // 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`);
     }
@@ -113,7 +114,7 @@ export async function handleApplyOutcome({ req, res, opts }) {
         if (!idsRaw.every(isNonEmptyId)) {
             throw new HttpError(400, 'ids must be an array of non-empty strings');
         }
-        // v1.11.5: DoS cap on ids.length. Each id triggers ~3 DB ops (readEntry +
+        // DoS cap on ids.length. Each id triggers ~3 DB ops (readEntry +
         // writeEntry + appendAuditEvent). N=1000 keeps per-request work bounded
         // to sub-second wall time on SQLite hot path. Cap BEFORE buildContextWithAuth
         // so attack traffic doesn't pay the api-key lookup cost.
@@ -141,8 +142,7 @@ export async function handleApplyOutcome({ req, res, opts }) {
 // Tenant scope (Episode A follow-up tracked in TODOS.md): api.sleep operates
 // on the WHOLE hippoRoot (cross-tenant by design, matching CLI cmdSleep).
 // The loopback-only guard is the trust boundary today. Future non-loopback
-// serving must also zero the cross-tenant counters for other tenants
-// (D1 in docs/decisions/2026-05-24-blocked-items.md).
+// serving must also zero the cross-tenant counters for other tenants.
 export async function handleSleep({ req, res, opts }) {
     // Defensive per-request loopback guard. Uses the canonical isLoopback()
     // helper above so any future extension (additional mapped/IPv6 forms,
@@ -151,7 +151,7 @@ export async function handleSleep({ req, res, opts }) {
     if (!isLoopback(req.socket.remoteAddress)) {
         throw new HttpError(403, '/v1/sleep is loopback-only (host-wide consolidation; see CHANGELOG v1.11.4)');
     }
-    // v1.12.0 A5 v2 sub-1: admin-role gate. Forward-defensive — exists today
+    // Admin-role gate. Forward-defensive: exists today
     // under loopback-only enforcement (loopback fallback is admin by default;
     // any Bearer-authed caller now carries an explicit role from the api_keys
     // row). When non-loopback serving lands, this gate is the actual auth
@@ -168,7 +168,7 @@ export async function handleSleep({ req, res, opts }) {
     if (noShareRaw !== undefined && !isJsonBoolean(noShareRaw)) {
         throw new HttpError(400, 'no_share must be a boolean');
     }
-    // v1.12.0: sleepCtx already built above for the admin-role gate; reuse.
+    // sleepCtx already built above for the admin-role gate; reuse.
     const result = await sleep(sleepCtx, {
         dryRun: dryRunRaw === true,
         noShare: noShareRaw === true,

package/dist/server/routes/policies.js

@@ -3,7 +3,8 @@ import { closePolicy, loadPolicies, loadPoliciesAsOf, loadPolicyById, savePolicy
 import { HttpError, sendJson } from '../../http-util.js';
 import { buildContextWithAuth } from '../auth.js';
 import { byCreatedAt, pageOf, parseCursor } from '../cursor.js';
-import { isJsonString, isSetMember, parseJsonBody, parseListLimit } from '../validation.js';
+import { isSetMember, parseJsonBody, parseListLimit } from '../validation.js';
+import { isJsonString } from '../../json.js';
 // HTTP-boundary check for an optional policy date field (validFrom/validTo).
 // Type + length only; savePolicy/loadPoliciesAsOf normalize + format-validate the
 // value (an unparseable date throws there -> mapped to 400). 64-char cap bounds a
@@ -19,7 +20,7 @@ function optionalDateField(raw, label) {
     }
     return raw;
 }
-// ── policies (E2 first-class object, bi-temporal-first) ──
+// ── policies (first-class object, bi-temporal-first) ──
 //
 // 6 routes: POST /v1/policies (new; processName-style body policyName +
 // policyText + validFrom? + validTo?), GET /v1/policies (list, status filter),

package/dist/server/routes/predictions.js

@@ -1,17 +1,17 @@
 // /v1/predictions routes.
-import { closePrediction, computePredictionBaserate, loadOpenPredictions, loadPredictionById, loadPredictionsByClass, savePrediction, VALID_CLOSURE_STATES } from '../../predictions/store.js';
-import { HttpError, sendJson } from '../../http-util.js';
+import { closePrediction, computePredictionBaserate, loadAllPredictions, loadOpenPredictions, loadPredictionById, loadPredictionsByClass, savePrediction, VALID_CLOSURE_STATES } from '../../predictions/store.js';
+import { HttpError, MAX_ID_LEN, sendJson } from '../../http-util.js';
 import { buildContextWithAuth } from '../auth.js';
 import { byCreatedAt, pageOf, parseCursor } from '../cursor.js';
-import { isJsonNumber, isJsonString, isSetMember, parseJsonBody, parseListLimit } from '../validation.js';
-// ── E2 prediction first-class object (v0.31) ──
-// docs/plans/2026-05-26-e2-prediction-object.md
+import { isJsonNumber, isSetMember, parseJsonBody, parseListLimit } from '../validation.js';
+import { isJsonString } from '../../json.js';
+// ── prediction first-class object ──
 //
 // 4 routes: POST /v1/predictions (create), GET /v1/predictions (list),
 // GET /v1/predictions/:id (show), POST /v1/predictions/:id/close (close).
 // All Bearer-authed + tenant-scoped via buildContextWithAuth. closure_state
 // validated against VALID_CLOSURE_STATES (3 states). DoS caps on claim
-// (4096 chars) + closureNote (2048 chars) per v1.11.4 pattern.
+// (4096 chars) + closureNote (2048 chars).
 export async function handleCreatePrediction({ req, res, opts }) {
     const ctx = await buildContextWithAuth(req, opts);
     const body = await parseJsonBody(req, ctx);
@@ -68,12 +68,9 @@ export async function handleListPredictions({ req, res, opts, query }) {
     const ctx = await buildContextWithAuth(req, opts);
     let predictions;
     if (status === 'all') {
-        if (classTag) {
-            predictions = loadPredictionsByClass(opts.hippoRoot, ctx.tenantId, classTag, { limit: limit + 1, after });
-        }
-        else {
-            predictions = loadOpenPredictions(opts.hippoRoot, ctx.tenantId, { limit: limit + 1, after });
-        }
+        predictions = classTag
+            ? loadPredictionsByClass(opts.hippoRoot, ctx.tenantId, classTag, { limit: limit + 1, after })
+            : loadAllPredictions(opts.hippoRoot, ctx.tenantId, { limit: limit + 1, after });
     }
     else if (status === 'open') {
         predictions = loadOpenPredictions(opts.hippoRoot, ctx.tenantId, {
@@ -99,7 +96,7 @@ export async function handleListPredictions({ req, res, opts, query }) {
     sendJson(res, 200, { predictions: page.items, next_cursor: page.nextCursor });
     return;
 }
-// J3 reference-class / planning-fallacy detector (v0.31).
+// Reference-class / planning-fallacy detector.
 // Order matters: this must match BEFORE /v1/predictions/:id since 'stats'
 // is not a number — the :id regex requires \d+ so they don't conflict,
 // but routing this first avoids the dispatch order risk.
@@ -108,8 +105,8 @@ export async function handlePredictionStats({ req, res, opts, query }) {
     if (!classTag || classTag.length === 0) {
         throw new HttpError(400, 'class param is required');
     }
-    if (classTag.length > 256) {
-        throw new HttpError(400, 'class exceeds 256-character cap');
+    if (classTag.length > MAX_ID_LEN) {
+        throw new HttpError(400, `class exceeds ${MAX_ID_LEN}-character cap`);
     }
     const ctx = await buildContextWithAuth(req, opts);
     const baserate = computePredictionBaserate(opts.hippoRoot, ctx.tenantId, classTag, ctx.actor.subject);

package/dist/server/routes/processes.js

@@ -3,7 +3,8 @@ import { closeProcess, loadProcessById, loadProcesses, saveProcess, VALID_PROCES
 import { HttpError, sendJson } from '../../http-util.js';
 import { buildContextWithAuth } from '../auth.js';
 import { byCreatedAt, pageOf, parseCursor } from '../cursor.js';
-import { isJsonString, isSetMember, parseJsonBody, parseListLimit } from '../validation.js';
+import { isSetMember, parseJsonBody, parseListLimit } from '../validation.js';
+import { isJsonString } from '../../json.js';
 // HTTP-boundary validation for a process `steps` body (untrusted). Returns the
 // step strings (saveProcess re-validates + trims, this is the fail-fast 400
 // gate). Caps mirror src/processes.ts MAX_PROCESS_STEPS / MAX_PROCESS_STEP_LEN.
@@ -30,7 +31,7 @@ function validateProcessStepsBody(raw) {
     // SAFETY: every item in raw was confirmed to be a string in the loop above.
     return raw;
 }
-// ── processes (E2 first-class object) ──
+// ── processes (first-class object) ──
 //
 // 5 routes: POST /v1/processes (new; body processName + steps[] + description),
 // GET /v1/processes (list, status filter), GET /v1/processes/:id (show),

package/dist/server/routes/project-briefs.js

@@ -1,10 +1,11 @@
 // /v1/project-briefs routes.
-import { assembleBriefFromReceipts, closeProjectBrief, loadProjectBriefById, loadProjectBriefs, refreshBrief, saveProjectBrief, VALID_BRIEF_STATES } from '../../project-briefs.js';
+import { assembleBriefFromReceipts, closeProjectBrief, loadProjectBriefById, loadProjectBriefs, MAX_REPO_LEN, refreshBrief, saveProjectBrief, VALID_BRIEF_STATES } from '../../project-briefs.js';
 import { HttpError, sendJson } from '../../http-util.js';
 import { buildContextWithAuth } from '../auth.js';
 import { byCreatedAt, pageOf, parseCursor } from '../cursor.js';
-import { isJsonString, isSetMember, parseJsonBody, parseListLimit } from '../validation.js';
-// ── E2 project_brief routes ──
+import { isSetMember, parseJsonBody, parseListLimit } from '../validation.js';
+import { isJsonString } from '../../json.js';
+// ── project_brief routes ──
 //
 // 6 routes: POST /v1/project-briefs (new; body repo + summary), GET
 // /v1/project-briefs (list; status + repo filter; shared parseListLimit), POST
@@ -21,8 +22,8 @@ export async function handleCreateProjectBrief({ req, res, opts }) {
     if (!isJsonString(repo) || repo.trim().length === 0) {
         throw new HttpError(400, 'repo is required (non-empty string)');
     }
-    if (repo.length > 256) {
-        throw new HttpError(400, 'repo exceeds 256-character cap');
+    if (repo.length > MAX_REPO_LEN) {
+        throw new HttpError(400, `repo exceeds ${MAX_REPO_LEN}-character cap`);
     }
     const summary = body['summary'];
     if (!isJsonString(summary) || summary.trim().length === 0) {
@@ -68,8 +69,8 @@ export async function handleRefreshProjectBrief({ req, res, opts }) {
     if (!isJsonString(repo) || repo.trim().length === 0) {
         throw new HttpError(400, 'repo is required (non-empty string)');
     }
-    if (repo.length > 256) {
-        throw new HttpError(400, 'repo exceeds 256-character cap');
+    if (repo.length > MAX_REPO_LEN) {
+        throw new HttpError(400, `repo exceeds ${MAX_REPO_LEN}-character cap`);
     }
     const dryRun = body['dryRun'] === true;
     if (dryRun) {