hippo-memory 2.0.0 → 2.1.0

package/dist/api/{remember-local.js → memories/remember-local.js}

@@ -1,21 +1,24 @@
-// The local remember pipeline for a caller in this process (`hippo remember`, `hippo watch`): schema fit, the salience gate, the
-// write, the read-back, the `remembered` counter and the embedding kick-off, in that order. Fact extraction is a second step,
-// which the caller runs after it has reported the write. Nothing here prints; the caller reports from what comes back.
-import { loadConfig } from '../core/config.js';
-import { computeSalience } from '../core/salience.js';
-import { loadNewestEntries, schemaFitInStore } from '../store/candidates.js';
-import { embedMemory } from '../search/embed-memories.js';
-import { loadAllEntries, readEntry } from '../store/entry-reads.js';
-import { updateStats } from '../store/index-and-stats.js';
-import { errorMessage, log } from '../util/log.js';
+// The local remember pipeline for a caller in this process (`hippo remember`, `hippo watch`): schema fit, the salience
+// gate, the write, the read-back, the `remembered` counter and the embedding kick-off, in that order. Fact extraction
+// is a second step, which the caller runs after it has reported the write. Nothing here prints; the caller reports from
+// what comes back.
+import { configOf } from '../config-of.js';
+import { computeSalience } from '../../core/salience.js';
+import { loadNewestEntries, schemaFitInStore } from '../../store/candidates.js';
+import { embedMemory } from '../../search/embed-memories.js';
+import { loadAllEntries, readEntry } from '../../store/entry-reads.js';
+import { updateStats } from '../../store/index-and-stats.js';
+import { errorMessage, log } from '../../util/log.js';
 import { remember } from './remember.js';
 const WEAK_HALF_LIFE_FACTOR = 0.5;
-/** The gate's verdict on one write, or null where it does not judge: the store has it off, or the write is pinned or forced. */
+/** The gate's verdict on one write, or null where it does not
+ * judge: the store has it off, or the write is pinned or forced. */
 function salienceVerdict(ctx, input) {
-    const { salience } = loadConfig(ctx.hippoRoot);
+    const { salience } = configOf(ctx);
     if (!salience.enabled || input.pinned || input.force)
         return null;
-    // computeSalience compares against the last `recentWindow` rows only; below 1 its slice takes every row, so that case still loads them all.
+    // computeSalience compares against the last `recentWindow` rows only; below 1 its slice takes every row, so that case
+    // still loads them all.
     const window = Math.trunc(salience.recentWindow);
     const recent = Number.isSafeInteger(window) && window >= 1
         ? loadNewestEntries(ctx.hippoRoot, ctx.tenantId, window)
@@ -27,14 +30,16 @@ function salienceVerdict(ctx, input) {
         maxRepeatErrors: salience.maxRepeatErrors,
     });
 }
-/** The row `remember` just wrote, as the store holds it: the report, the embedding and the extraction all work on that. */
+/** The row `remember` just wrote, as the store holds it: the
+ * report, the embedding and the extraction all work on that. */
 function storedEntry(ctx, id) {
     const entry = readEntry(ctx.hippoRoot, id, ctx.tenantId);
     if (!entry)
         throw new Error(`memory ${id} was written but cannot be read back`);
     return entry;
 }
-/** Best-effort and slow (a model load or a network call), so the caller is not held for it; a row left out of the index is logged. */
+/** Best-effort and slow (a model load or a network call), so the
+ * caller is not held for it; a row left out of the index is logged. */
 function indexInBackground(hippoRoot, entry) {
     return embedMemory(hippoRoot, entry).then((outcome) => {
         if (outcome === 'failed') {
@@ -43,7 +48,8 @@ function indexInBackground(hippoRoot, entry) {
         return outcome;
     });
 }
-/** One local write on hippo.db: gate, write, read-back, counter, then the embedding, started and never awaited. A refused value throws as `remember` does. */
+/** One local write on hippo.db: gate, write, read-back, counter, then the embedding, started and never awaited. A
+ * refused value throws as `remember` does. */
 export async function rememberLocally(ctx, input) {
     const schemaFit = schemaFitInStore(ctx.hippoRoot, ctx.tenantId, input.content, input.fitTags ?? input.tags);
     const verdict = salienceVerdict(ctx, input);
@@ -71,9 +77,10 @@ export async function rememberLocally(ctx, input) {
     const embedding = indexInBackground(ctx.hippoRoot, entry);
     return startedWeak ? { status: 'stored', entry, embedding, startedWeak } : { status: 'stored', entry, embedding };
 }
-/** Extracts facts from a row just stored and stores them beside it. Best-effort: a failure is named in the result, never thrown. */
+/** Extracts facts from a row just stored and stores them beside it.
+ * Best-effort: a failure is named in the result, never thrown. */
 export async function extractRememberedFacts(ctx, entry, request) {
-    const { extraction } = loadConfig(ctx.hippoRoot);
+    const { extraction } = configOf(ctx);
     if (!request.requested && extraction.enabled !== true)
         return { status: 'off' };
     const { apiKey, fetcher } = request;
@@ -83,8 +90,15 @@ export async function extractRememberedFacts(ctx, entry, request) {
     let facts = 0;
     try {
         // Loaded on demand, so a write that extracts nothing does not pay for the module.
-        const { extractFacts, storeExtractedFacts } = await import('../learn/extract.js');
-        const found = await extractFacts(entry.content, { apiKey, model: extraction.model, fetcher, onError: (msg) => { failures.push(msg); } });
+        const { extractFacts, storeExtractedFacts } = await import('../../learn/extract.js');
+        const found = await extractFacts(entry.content, {
+            apiKey,
+            model: extraction.model,
+            fetcher,
+            onError: (msg) => {
+                failures.push(msg);
+            },
+        });
         if (found.length > 0) {
             storeExtractedFacts(ctx.hippoRoot, entry, found);
             facts = found.length;

package/dist/api/{remember.d.ts → memories/remember.d.ts}

@@ -1,6 +1,6 @@
-import type { ConnectorEvent } from '../store/port.js';
-import { type ConfidenceLevel, type Layer, type MemoryKind, type TraceOutcome } from '../core/memory.js';
-import type { Context } from './types.js';
+import type { ConnectorEvent } from '../../store/port.js';
+import { type ConfidenceLevel, type Layer, type MemoryKind, type TraceOutcome } from '../../core/memory.js';
+import type { ContextWith } from '../types.js';
 /** Row fields the caller's own process decides, as the CLI does from its flags and its salience gate. */
 export interface RememberLocal {
     layer?: Layer;
@@ -10,7 +10,8 @@ export interface RememberLocal {
     schemaFit?: number;
     traceOutcome?: TraceOutcome;
     sourceSessionId?: string | null;
-    /** A salience gate's start-weak verdict: the row starts at `strength`, and its half-life is multiplied by `halfLifeFactor`, never below one day. */
+    /** A salience gate's start-weak verdict: the row starts at `strength`, and its half-life is multiplied by
+     * `halfLifeFactor`, never below one day. */
     weaken?: {
         readonly strength: number;
         readonly halfLifeFactor: number;
@@ -23,19 +24,22 @@ export interface RememberOpts {
     owner?: string;
     artifactRef?: string;
     tags?: string[];
-    /** The connector event this write answers. The store logs it in the memory's own transaction; an event logged before stores nothing and
-     * answers `duplicate`. */
+    /** The connector event this write answers. The store logs it in the memory's own transaction; an event logged before
+     * stores nothing and answers `duplicate`. */
     event?: ConnectorEvent;
     /** Connector-ingested content an agent doesn't control; gates detectInstruction. CLI/HTTP/MCP never set this. */
     untrusted?: boolean;
-    /** The caller's project: its name becomes the row's origin. Without it the store's fallback applies (NULL on a shared store). */
+    /** The caller's project: its name becomes the row's origin. Without
+     * it the store's fallback applies (NULL on a shared store). */
     project?: {
         readonly name: string;
         readonly aliases?: readonly string[];
     };
-    /** Store it in the caller's own personal scope, readable by its owner alone in every project; needs an owner on the actor and no `scope`. */
+    /** Store it in the caller's own personal scope, readable by its owner alone in every project; needs an owner on the
+     * actor and no `scope`. */
     personal?: boolean;
-    /** Never set from a request body: a route or tool that copied it would let a client pin a row or pick its layer and source. */
+    /** Never set from a request body: a route or tool that copied it
+     * would let a client pin a row or pick its layer and source. */
     local?: RememberLocal;
 }
 export interface RememberResult {
@@ -51,12 +55,14 @@ export interface RememberResult {
     };
     /** Set only when the content held secret material: untrusted text had it redacted, typed text was stored as sent. */
     warnings?: string[];
-    /** Set only when the write's event was logged before: nothing was stored, so `id` names no row; `memoryId` is the id the first write logged. */
+    /** Set only when the write's event was logged before: nothing was stored, so `id` names no row; `memoryId` is the id
+     * the first write logged. */
     duplicate?: {
         memoryId: string | null;
     };
 }
-/** Store one memory: the store's entryWrites group writes the row and its one remember audit row, under the caller's subject.
- *  A write that carries a connector event or untrusted content goes through connectorWrites, which commits its companion rows with it. */
-export declare function remember(ctx: Context, opts: RememberOpts): Promise<RememberResult>;
+/** Store one memory: the store's entryWrites group writes the row and its one remember audit row, under the caller's
+ * subject. A write that carries a connector event or untrusted content goes through connectorWrites, which commits its
+ * companion rows with it. */
+export declare function remember(ctx: ContextWith<'entryWrites'>, opts: RememberOpts): Promise<RememberResult>;
 //# sourceMappingURL=remember.d.ts.map

package/dist/api/{remember.js → memories/remember.js}

@@ -1,16 +1,16 @@
 // Write path: remember stores one memory after secret vetting and, for untrusted content, the instruction check.
-import { stampOriginProject } from '../store/entry-row.js';
-import { detectInstruction } from './instruction-detect.js';
-import { quarantineScopeFor } from '../trust/quarantine.js';
-import { createMemory } from '../core/memory.js';
-import { loadConfig } from '../core/config.js';
-import { vetSecrets } from '../util/secret-detect.js';
-import { assertCallerProject } from '../core/project-identity.js';
-import { BadRequestError } from '../core/api-errors.js';
-import { assertClientScope, personalScopeOf } from '../core/recall-scope.js';
-import { requireGroup } from '../store/index.js';
-import { storeFor } from '../store/sqlite/store.js';
-/** The scope a write lands in: the caller's own personal scope when asked for, else the client's, which may not be a personal one. */
+import { stampOriginProject } from '../../store/entry-row.js';
+import { detectInstruction } from '../instruction-detect.js';
+import { quarantineScopeFor } from '../../trust/quarantine.js';
+import { createMemory, } from '../../core/memory.js';
+import { configOf } from '../config-of.js';
+import { vetSecrets } from '../../util/secret-detect.js';
+import { assertCallerProject } from '../../core/project-identity.js';
+import { BadRequestError } from '../../core/api-errors.js';
+import { assertClientScope, personalScopeOf } from '../../core/recall-scope.js';
+import { narrowStore } from '../../store/index.js';
+/** The scope a write lands in: the caller's own personal scope when
+ * asked for, else the client's, which may not be a personal one. */
 function rememberScope(ctx, opts) {
     if (!opts.personal) {
         assertClientScope(opts.scope);
@@ -39,29 +39,40 @@ function prepareRemember(ctx, opts) {
         pinned: local.pinned,
         confidence: local.confidence,
         source: local.source,
-        schema_fit: local.schemaFit,
-        trace_outcome: local.traceOutcome,
-        source_session_id: local.sourceSessionId,
+        schemaFit: local.schemaFit,
+        traceOutcome: local.traceOutcome,
+        sourceSessionId: local.sourceSessionId,
         kind: opts.kind ?? 'distilled',
         scope: detection.flagged ? quarantineScopeFor(requestedScope) : requestedScope,
         owner: opts.owner ?? null,
-        artifact_ref: opts.artifactRef ?? null,
+        artifactRef: opts.artifactRef ?? null,
         tags: opts.tags,
         tenantId: ctx.tenantId,
-        baseHalfLifeDays: loadConfig(ctx.hippoRoot).defaultHalfLifeDays,
+        baseHalfLifeDays: configOf(ctx).defaultHalfLifeDays,
     });
     const entry = local.weaken ? weakened(created, local.weaken) : created;
-    // Aliases only widen what a reader matches; a row has one origin. A personal row's '' follows its owner into every project.
+    // Aliases only widen what a reader matches; a row has one origin.
+    // A personal row's '' follows its owner into every project.
     const origin = opts.personal ? '' : opts.project?.name;
     const stamped = origin !== undefined ? { ...entry, origin_project: origin } : entry;
     return { entry: stamped, requestedScope, detection, warnings: vetted.warnings };
 }
 function weakened(entry, weaken) {
-    return { ...entry, strength: weaken.strength, half_life_days: Math.max(1, entry.half_life_days * weaken.halfLifeFactor) };
+    return {
+        ...entry,
+        strength: weaken.strength,
+        half_life_days: Math.max(1, entry.half_life_days * weaken.halfLifeFactor),
+    };
 }
 function rememberResult(ctx, prepared, written) {
     const { entry, detection, warnings } = prepared;
-    const result = { id: entry.id, kind: entry.kind, tenantId: ctx.tenantId, halfLifeDays: entry.half_life_days, tags: [...entry.tags] };
+    const result = {
+        id: entry.id,
+        kind: entry.kind,
+        tenantId: ctx.tenantId,
+        halfLifeDays: entry.half_life_days,
+        tags: [...entry.tags],
+    };
     if (detection.flagged)
         result.quarantined = { reason: detection.reason ?? 'unknown' };
     if (warnings.length > 0)
@@ -74,11 +85,12 @@ function rememberResult(ctx, prepared, written) {
 function quarantineOf({ requestedScope, detection }) {
     return detection.flagged ? { originalScope: requestedScope, reason: detection.reason ?? 'unknown' } : undefined;
 }
-/** Store one memory: the store's entryWrites group writes the row and its one remember audit row, under the caller's subject.
- *  A write that carries a connector event or untrusted content goes through connectorWrites, which commits its companion rows with it. */
+/** Store one memory: the store's entryWrites group writes the row and its one remember audit row, under the caller's
+ * subject. A write that carries a connector event or untrusted content goes through connectorWrites, which commits its
+ * companion rows with it. */
 export async function remember(ctx, opts) {
-    const store = storeFor(ctx);
-    const entryWrites = requireGroup(store, 'entryWrites');
+    const store = ctx.store;
+    const entryWrites = store.entryWrites;
     const prepared = prepareRemember(ctx, opts);
     // A store writes origin_project as given, so the served folder's fallback is stamped here.
     const write = { entry: stampOriginProject(ctx.hippoRoot, prepared.entry), actor: ctx.actor.subject };
@@ -86,8 +98,12 @@ export async function remember(ctx, opts) {
         await entryWrites.writeEntry(write);
         return rememberResult(ctx, prepared);
     }
-    const connectorWrites = requireGroup(store, 'connectorWrites');
-    const written = await connectorWrites.writeConnectorEntry({ ...write, event: opts.event, quarantine: quarantineOf(prepared) });
+    const connectorWrites = narrowStore(store, 'connectorWrites').connectorWrites;
+    const written = await connectorWrites.writeConnectorEntry({
+        ...write,
+        event: opts.event,
+        quarantine: quarantineOf(prepared),
+    });
     return rememberResult(ctx, prepared, written);
 }
 //# sourceMappingURL=remember.js.map

package/dist/api/objects/cards.d.ts

@@ -0,0 +1,39 @@
+import type { Card, CardComment, CardRun, CardStatus } from '../../core/card.js';
+import type { HandoffOutcome } from '../../core/handoff.js';
+import type { CardDetail } from '../../store/card-detail.js';
+import type { CardCreate } from '../../store/index.js';
+import type { ContextWith } from '../types.js';
+type Ctx = ContextWith<'cards'>;
+/** Create a card in the caller's tenant. Throws on an empty title or an unknown dependency. */
+export declare function cardCreate(ctx: Ctx, input: CardCreate): Promise<Card>;
+/** One card by id, or null when the caller's tenant has none. */
+export declare function cardLoad(ctx: Ctx, id: string): Promise<Card | null>;
+/** The card with its dependencies, runs, comments and latest handoff, or null when unknown. */
+export declare function cardDetail(ctx: Ctx, id: string): Promise<CardDetail | null>;
+/** The caller's cards, newest-updated first, optionally filtered to one status. */
+export declare function cardList(ctx: Ctx, opts?: {
+    status?: CardStatus;
+}): Promise<Card[]>;
+/** Every run of a card, newest first. */
+export declare function cardRuns(ctx: Ctx, id: string): Promise<CardRun[]>;
+/** Claim a ready or blocked card for a runtime; null when it cannot be claimed. */
+export declare function cardClaim(ctx: Ctx, id: string, runtime: string, sessionId?: string): Promise<(Card & {
+    runId: number;
+}) | null>;
+/** Extend a live run's lease; null when the run is not live. */
+export declare function cardHeartbeat(ctx: Ctx, id: string, runId: number): Promise<Card | null>;
+/** Block a running card with a reason; null when it is not running. */
+export declare function cardBlock(ctx: Ctx, id: string, reason: string, runId?: number): Promise<Card | null>;
+/** Move a running card to review; null when it is not running. */
+export declare function cardReview(ctx: Ctx, id: string, runId?: number): Promise<Card | null>;
+/** Complete a card in review and promote the children it unblocks; null when not in review. */
+export declare function cardComplete(ctx: Ctx, id: string, outcome: HandoffOutcome, runId?: number): Promise<{
+    card: Card;
+    promotedChildren: string[];
+} | null>;
+/** Return every card with an expired lease to ready; yields the reclaimed ids. */
+export declare function cardReclaimExpired(ctx: Ctx): Promise<string[]>;
+/** Add a comment to a card. Throws on an empty body. */
+export declare function cardComment(ctx: Ctx, cardId: string, author: string, body: string): Promise<CardComment>;
+export {};
+//# sourceMappingURL=cards.d.ts.map

package/dist/api/{cards.js → objects/cards.js}

@@ -1,52 +1,50 @@
 // The agent work board: create, claim, review and complete cards, scoped to the caller's tenant.
-import { addCardComment, blockCard, claimCard, completeCard, createCard, heartbeatCard, listCards, loadCard, loadCardRuns, reclaimExpiredCards, reviewCard, } from '../store/cards.js';
-import { loadCardDetail } from '../store/card-detail.js';
 /** Create a card in the caller's tenant. Throws on an empty title or an unknown dependency. */
 export function cardCreate(ctx, input) {
-    return createCard(ctx.hippoRoot, ctx.tenantId, input);
+    return ctx.store.cards.create(ctx.tenantId, input);
 }
 /** One card by id, or null when the caller's tenant has none. */
 export function cardLoad(ctx, id) {
-    return loadCard(ctx.hippoRoot, ctx.tenantId, id);
+    return ctx.store.cards.load(ctx.tenantId, id);
 }
 /** The card with its dependencies, runs, comments and latest handoff, or null when unknown. */
 export function cardDetail(ctx, id) {
-    return loadCardDetail(ctx.hippoRoot, ctx.tenantId, id);
+    return ctx.store.cards.detail(ctx.tenantId, id);
 }
 /** The caller's cards, newest-updated first, optionally filtered to one status. */
 export function cardList(ctx, opts = {}) {
-    return listCards(ctx.hippoRoot, ctx.tenantId, opts);
+    return ctx.store.cards.list(ctx.tenantId, opts);
 }
 /** Every run of a card, newest first. */
 export function cardRuns(ctx, id) {
-    return loadCardRuns(ctx.hippoRoot, ctx.tenantId, id);
+    return ctx.store.cards.runs(ctx.tenantId, id);
 }
 /** Claim a ready or blocked card for a runtime; null when it cannot be claimed. */
 export function cardClaim(ctx, id, runtime, sessionId) {
-    return claimCard(ctx.hippoRoot, ctx.tenantId, id, runtime, sessionId);
+    return ctx.store.cards.claim(ctx.tenantId, id, runtime, sessionId);
 }
 /** Extend a live run's lease; null when the run is not live. */
 export function cardHeartbeat(ctx, id, runId) {
-    return heartbeatCard(ctx.hippoRoot, ctx.tenantId, id, runId);
+    return ctx.store.cards.heartbeat(ctx.tenantId, id, runId);
 }
 /** Block a running card with a reason; null when it is not running. */
 export function cardBlock(ctx, id, reason, runId) {
-    return blockCard(ctx.hippoRoot, ctx.tenantId, id, reason, runId);
+    return ctx.store.cards.block(ctx.tenantId, id, reason, runId);
 }
 /** Move a running card to review; null when it is not running. */
 export function cardReview(ctx, id, runId) {
-    return reviewCard(ctx.hippoRoot, ctx.tenantId, id, runId);
+    return ctx.store.cards.review(ctx.tenantId, id, runId);
 }
 /** Complete a card in review and promote the children it unblocks; null when not in review. */
 export function cardComplete(ctx, id, outcome, runId) {
-    return completeCard(ctx.hippoRoot, ctx.tenantId, id, outcome, runId);
+    return ctx.store.cards.complete(ctx.tenantId, id, outcome, runId);
 }
 /** Return every card with an expired lease to ready; yields the reclaimed ids. */
 export function cardReclaimExpired(ctx) {
-    return reclaimExpiredCards(ctx.hippoRoot, ctx.tenantId);
+    return ctx.store.cards.reclaimExpired(ctx.tenantId);
 }
 /** Add a comment to a card. Throws on an empty body. */
 export function cardComment(ctx, cardId, author, body) {
-    return addCardComment(ctx.hippoRoot, ctx.tenantId, cardId, author, body);
+    return ctx.store.cards.comment(ctx.tenantId, cardId, author, body);
 }
 //# sourceMappingURL=cards.js.map

package/dist/api/{drill-down.d.ts → objects/drill-down.d.ts}

@@ -1,12 +1,13 @@
-import type { CallerProject } from './prompt-hook.js';
-import type { Context } from './types.js';
+import type { CallerProject } from '../prompt-hook.js';
+import type { ContextWith } from '../types.js';
 export interface DrillDownOpts {
     /** Cap on number of children returned. Default 50. */
     limit?: number;
-    /** Token budget: children append in created order until the next would exceed it (cost: printed line under `cost`, else ceil(content.length / 4)).
-     * For depth > 1 the budget is global and cumulative, not per level. */
+    /** Token budget: children append in created order until the next would exceed it (cost: printed line under `cost`,
+     * else ceil(content.length / 4)). For depth > 1 the budget is global and cumulative, not per level. */
     budget?: number;
-    /** Levels to walk down (default 1 = direct children); capped at 10 internally. BFS dedups with a visited Set, defensive against shared-child anomalies. */
+    /** Levels to walk down (default 1 = direct children); capped at 10 internally. BFS dedups with a visited Set,
+     * defensive against shared-child anomalies. */
     depth?: number;
     cost?: DrillDownCost;
     project?: CallerProject;
@@ -35,13 +36,14 @@ export interface DrillDownResult {
     totalChildren: number;
     truncated: boolean;
 }
-/** `not_found` covers missing, wrong-tenant AND scope-blocked, because distinguishing scope_blocked leaked private-row existence to no-scope callers.
- *  `not_drillable`: the id is a leaf row (level 0/1), which the caller can act on. */
+/** `not_found` covers missing, wrong-tenant AND scope-blocked, because distinguishing scope_blocked leaked private-row
+ * existence to no-scope callers. `not_drillable`: the id is a leaf row (level 0/1), which the caller can act on. */
 export interface DrillDownFailure {
     failure: 'not_found' | 'not_drillable';
 }
 export type DrillDownOutcome = DrillDownResult | DrillDownFailure;
-/** One step down the DAG from a level-2+ summary to its direct children (the way back from `recall(... summarizeOverflow: true)` substitutions). Only
- * `ctx.tenantId` summaries are reachable; children get recall's scope filter. Returns `DrillDownResult` or `{failure}`; HTTP maps `not_drillable` to 422. */
-export declare function drillDown(ctx: Context, summaryId: string, opts?: DrillDownOpts): Promise<DrillDownOutcome>;
+/** One step down the DAG from a level-2+ summary to its direct children (the way back from `recall(...
+ * summarizeOverflow: true)` substitutions). Only `ctx.tenantId` summaries are reachable; children get recall's scope
+ * filter. Returns `DrillDownResult` or `{failure}`; HTTP maps `not_drillable` to 422. */
+export declare function drillDown(ctx: ContextWith<'dagReads'>, summaryId: string, opts?: DrillDownOpts): Promise<DrillDownOutcome>;
 //# sourceMappingURL=drill-down.d.ts.map

package/dist/api/{drill-down.js → objects/drill-down.js}

@@ -1,12 +1,11 @@
 // DAG drill-down from a summary to its children.
-import { requireGroup } from '../store/index.js';
-import { storeFor } from '../store/sqlite/store.js';
-import { estimateTokens } from '../util/token-text.js';
-import { passesScopeFilterForRecall, personalScopeOf } from '../core/recall-scope.js';
-import { classifyOriginProject } from '../core/project-identity.js';
+import { estimateTokens } from '../../util/token-text.js';
+import { passesScopeFilterForRecall, personalScopeOf } from '../../core/recall-scope.js';
+import { classifyOriginProject } from '../../core/project-identity.js';
 const DEFAULT_DRILL_DOWN_LIMIT = 50;
-/** One step down the DAG from a level-2+ summary to its direct children (the way back from `recall(... summarizeOverflow: true)` substitutions). Only
- * `ctx.tenantId` summaries are reachable; children get recall's scope filter. Returns `DrillDownResult` or `{failure}`; HTTP maps `not_drillable` to 422. */
+/** One step down the DAG from a level-2+ summary to its direct children (the way back from `recall(...
+ * summarizeOverflow: true)` substitutions). Only `ctx.tenantId` summaries are reachable; children get recall's scope
+ * filter. Returns `DrillDownResult` or `{failure}`; HTTP maps `not_drillable` to 422. */
 export async function drillDown(ctx, summaryId, opts = {}) {
     const limit = opts.limit ?? DEFAULT_DRILL_DOWN_LIMIT;
     // v0.30 / E5: depth defaults 1 (backward compat); hard cap 10 levels
@@ -16,7 +15,7 @@ export async function drillDown(ctx, summaryId, opts = {}) {
     const readable = (row) => passesScopeFilterForRecall(row.scope ?? null, undefined, own)
         && (!opts.project || classifyOriginProject(row.origin_project, opts.project) !== 'cross-project');
     const pastLimit = Math.floor(limit) + 1;
-    const walked = await requireGroup(storeFor(ctx), 'dagReads').summaryWithDescendants(ctx.tenantId, summaryId, {
+    const walked = await ctx.store.dagReads.summaryWithDescendants(ctx.tenantId, summaryId, {
         depth,
         // A leaf answers not_drillable, so nothing under it is read.
         admit: (row) => readable(row) && (row.id !== summaryId || isDrillable(row)),

package/dist/api/objects/goals.d.ts

@@ -0,0 +1,18 @@
+import type { CompleteGoalOpts, Goal, PushGoalOpts } from '../../store/goals.js';
+import { type ContextWith } from '../types.js';
+/** What a new goal carries; its tenant is always the caller's. */
+export type GoalPushOpts = Omit<PushGoalOpts, 'tenantId'>;
+/** Push a goal onto `sessionId`'s stack in the caller's tenant. */
+export declare function goalPush(ctx: ContextWith<'goals'>, opts: GoalPushOpts): Promise<Goal>;
+/** The caller's goals for `sessionId`: active ones, or every status when `all` is set. */
+export declare function goalList(ctx: ContextWith<'goals'>, opts: {
+    sessionId: string;
+    all: boolean;
+}): Promise<Goal[]>;
+/** Complete a goal by id; a no-op for an unknown or already completed goal. Host admin only. */
+export declare function goalComplete(ctx: ContextWith<'goals'>, goalId: string, opts: CompleteGoalOpts): Promise<void>;
+/** Suspend an active goal by id. Host admin only. */
+export declare function goalSuspend(ctx: ContextWith<'goals'>, goalId: string): Promise<void>;
+/** Resume a suspended goal by id, suspending the oldest active one past the depth cap. Host admin only. */
+export declare function goalResume(ctx: ContextWith<'goals'>, goalId: string): Promise<void>;
+//# sourceMappingURL=goals.d.ts.map

package/dist/api/{goals.js → objects/goals.js}

@@ -1,29 +1,29 @@
 // The per-session goal stack that recall boosts: push, list, complete, suspend and resume.
-import { completeGoal, getActiveGoals, getSessionGoals, pushGoal, resumeGoal, suspendGoal, } from '../store/goals.js';
-import { requireHostAdmin } from './types.js';
+import { requireHostAdmin } from '../types.js';
 /** Push a goal onto `sessionId`'s stack in the caller's tenant. */
 export function goalPush(ctx, opts) {
-    return pushGoal(ctx.hippoRoot, { ...opts, tenantId: ctx.tenantId });
+    return ctx.store.goals.push(ctx.tenantId, opts);
 }
 /** The caller's goals for `sessionId`: active ones, or every status when `all` is set. */
-export function goalList(ctx, opts) {
-    const scope = { sessionId: opts.sessionId, tenantId: ctx.tenantId };
-    return opts.all ? getSessionGoals(ctx.hippoRoot, scope) : getActiveGoals(ctx.hippoRoot, scope);
+export async function goalList(ctx, opts) {
+    if (opts.all)
+        return ctx.store.goals.sessionGoals(ctx.tenantId, opts.sessionId);
+    return (await ctx.store.activeGoals({ sessionId: opts.sessionId, tenantId: ctx.tenantId })).goals;
 }
 /** Complete a goal by id; a no-op for an unknown or already completed goal. Host admin only. */
-export function goalComplete(ctx, goalId, opts) {
+export async function goalComplete(ctx, goalId, opts) {
     // Goal ids are not tenant-scoped in the store, so acting on one by id reaches past the caller's tenant.
     requireHostAdmin(ctx, 'Completing a goal by id');
-    completeGoal(ctx.hippoRoot, goalId, opts);
+    await ctx.store.goals.complete(ctx.tenantId, goalId, opts);
 }
 /** Suspend an active goal by id. Host admin only. */
-export function goalSuspend(ctx, goalId) {
+export async function goalSuspend(ctx, goalId) {
     requireHostAdmin(ctx, 'Suspending a goal by id');
-    suspendGoal(ctx.hippoRoot, goalId);
+    await ctx.store.goals.suspend(ctx.tenantId, goalId);
 }
 /** Resume a suspended goal by id, suspending the oldest active one past the depth cap. Host admin only. */
-export function goalResume(ctx, goalId) {
+export async function goalResume(ctx, goalId) {
     requireHostAdmin(ctx, 'Resuming a goal by id');
-    resumeGoal(ctx.hippoRoot, goalId);
+    await ctx.store.goals.resume(ctx.tenantId, goalId);
 }
 //# sourceMappingURL=goals.js.map

package/dist/api/objects/graph.d.ts

@@ -0,0 +1,11 @@
+import type { GraphRows } from '../../store/port.js';
+import type { ContextWith } from '../types.js';
+/** The entity a graph read focuses on. Capped at the 512 entity-name cap, not the id-shaped 256, so a long decision or
+ * policy name stays focusable. */
+export declare function graphEntityOf(raw: string | null): string | undefined;
+/** The entity/relation rows behind GET /v1/graph, as the caller's role, scopes and owner may see them. */
+export declare function graphRows(ctx: ContextWith<'graphReads'>, query: {
+    entity?: string;
+    limit: number;
+}): Promise<GraphRows>;
+//# sourceMappingURL=graph.d.ts.map

package/dist/api/objects/graph.js

@@ -0,0 +1,16 @@
+import { BadRequestError } from '../../core/api-errors.js';
+import { MAX_ENTITY_NAME_LEN } from '../../store/graph-rows.js';
+/** The entity a graph read focuses on. Capped at the 512 entity-name cap, not the id-shaped 256, so a long decision or
+ * policy name stays focusable. */
+export function graphEntityOf(raw) {
+    if (raw !== null && raw.length > MAX_ENTITY_NAME_LEN) {
+        throw new BadRequestError(`entity exceeds the ${MAX_ENTITY_NAME_LEN}-character cap`);
+    }
+    return raw ?? undefined;
+}
+/** The entity/relation rows behind GET /v1/graph, as the caller's role, scopes and owner may see them. */
+export async function graphRows(ctx, query) {
+    const { role, scopes, owner } = ctx.actor;
+    return ctx.store.graphReads.graphRows(ctx.tenantId, { ...query, reader: { role, scopes, owner } });
+}
+//# sourceMappingURL=graph.js.map

package/dist/api/objects/objects.d.ts

@@ -0,0 +1,9 @@
+import type { SavableDescriptor } from '../../objects/descriptor.js';
+import type { ObjectByKind, SavableKind } from '../../core/object-types.js';
+import type { Objects } from '../../store/port.js';
+import type { ContextWith } from '../types.js';
+/** The request store's object group; the dispatcher has already answered 501 for a store without it. */
+export declare function objectsOf(ctx: ContextWith<'objects'>): Objects;
+/** Saves through the request's store as the authenticated caller. */
+export declare function saveFor<K extends SavableKind, W>(ctx: ContextWith<'objects'>, d: SavableDescriptor<K, W>, write: W): Promise<ObjectByKind[K]>;
+//# sourceMappingURL=objects.d.ts.map

package/dist/api/{objects.js → objects/objects.js}

@@ -1,9 +1,7 @@
-import { saveObject } from '../objects/lifecycle.js';
-import { requireGroup } from '../store/index.js';
-import { storeFor } from '../store/sqlite/store.js';
+import { saveObject } from '../../objects/lifecycle.js';
 /** The request store's object group; the dispatcher has already answered 501 for a store without it. */
 export function objectsOf(ctx) {
-    return requireGroup(storeFor(ctx), 'objects');
+    return ctx.store.objects;
 }
 /** Saves through the request's store as the authenticated caller. */
 export function saveFor(ctx, d, write) {

package/dist/api/objects/predictions.d.ts

@@ -0,0 +1,11 @@
+import { type Prediction, type PredictionBaserate, type SavePredictionOpts } from '../../store/predictions.js';
+import type { PredictionClose, PredictionSave, Predictions } from '../../store/port.js';
+import type { ContextWith } from '../types.js';
+export declare function savePrediction(ctx: ContextWith<'predictions'>, input: PredictionSave): Promise<Prediction>;
+/** A claim saved with its recall mirror, built under the store root's half-life as the HTTP create route builds it. */
+export declare function recordPrediction(ctx: ContextWith<'predictions'>, claim: SavePredictionOpts): Promise<Prediction>;
+export declare function listPredictions(ctx: ContextWith<'predictions'>, query: Parameters<Predictions['listPredictions']>[1]): Promise<Prediction[]>;
+export declare function predictionBaserate(ctx: ContextWith<'predictions'>, classTag: string): Promise<PredictionBaserate>;
+export declare function predictionById(ctx: ContextWith<'predictions'>, id: number): Promise<Prediction | null>;
+export declare function closePrediction(ctx: ContextWith<'predictions'>, id: number, close: PredictionClose): Promise<Prediction>;
+//# sourceMappingURL=predictions.d.ts.map

package/dist/api/{predictions.js → objects/predictions.js}

@@ -1,14 +1,15 @@
-import { predictionMirror } from '../store/predictions.js';
-import { loadConfig } from '../core/config.js';
-import { requireGroup } from '../store/index.js';
-import { storeFor } from '../store/sqlite/store.js';
-const predictionsOf = (ctx) => requireGroup(storeFor(ctx), 'predictions');
+import { predictionMirror, } from '../../store/predictions.js';
+import { configOf } from '../config-of.js';
+const predictionsOf = (ctx) => ctx.store.predictions;
 export async function savePrediction(ctx, input) {
     return predictionsOf(ctx).savePrediction(ctx.tenantId, input, ctx.actor.subject);
 }
 /** A claim saved with its recall mirror, built under the store root's half-life as the HTTP create route builds it. */
 export async function recordPrediction(ctx, claim) {
-    return savePrediction(ctx, { ...claim, mirror: predictionMirror(ctx.tenantId, claim, loadConfig(ctx.hippoRoot).defaultHalfLifeDays) });
+    return savePrediction(ctx, {
+        ...claim,
+        mirror: predictionMirror(ctx.tenantId, claim, configOf(ctx).defaultHalfLifeDays),
+    });
 }
 export async function listPredictions(ctx, query) {
     return predictionsOf(ctx).listPredictions(ctx.tenantId, query);