hippo-memory 1.72.0 → 2.1.0

package/dist/store/open.d.ts

@@ -5,13 +5,16 @@ export declare function initStore(hippoRoot: string): void;
 export declare function openStore(hippoRoot: string, opts?: {
     busyWaitMs?: number;
 }): DatabaseSyncLike;
-/** One call on a handle of its own, closed after; pass openStore where the call also sets up mirror folders and legacy rows. */
+/** A connection with no mirror or legacy setup, for a caller that already ran `initStore`. */
+export declare function openBareHandle(hippoRoot: string, opts?: {
+    busyWaitMs?: number;
+}): DatabaseSyncLike;
+/** One call on a handle of its own, closed after (a request scope's handle stays open);
+ *  pass openStore where the call also sets up mirror folders and legacy rows. */
 export declare function onHandle<T>(hippoRoot: string, fn: (db: DatabaseSyncLike) => T, open?: (hippoRoot: string) => DatabaseSyncLike): T;
 /** `meta` key holding the default half-life base a store's memories are on (src/consolidate/half-life-migration.ts). */
 export declare const HALF_LIFE_BASE_META_KEY = "default_half_life_base";
 /** `meta` key set once no memory of a decision, incident or other object sits on the old flat 90 days. */
 export declare const TYPED_HALF_LIFE_META_KEY = "typed_half_life_on_default";
-/** The flat half-life the decision, incident and other object writers gave their memories before they took the default. */
-export declare const LEGACY_TYPED_HALF_LIFE = 90;
 export declare function loadLegacyEntriesFromMarkdown(hippoRoot: string): MemoryEntry[];
 //# sourceMappingURL=open.d.ts.map

package/dist/store/open.js

@@ -18,7 +18,8 @@ export function initStore(hippoRoot) {
 export function openStore(hippoRoot, opts) {
     // Open first: a folder marked for another store must refuse before any mirror folder appears.
     const { db, facts } = openHippoDbWithFacts(hippoRoot, opts);
-    // A store worker's reader: its writer ran the steps below before this thread was sent a job, and this connection cannot write them.
+    // A store worker's reader: its writer ran the steps below before this thread was sent a job, and this connection
+    // cannot write them.
     if (currentRequestStores()?.setupDoneFor === hippoRoot)
         return db;
     try {
@@ -44,7 +45,12 @@ export function openStore(hippoRoot, opts) {
         throw error;
     }
 }
-/** One call on a handle of its own, closed after; pass openStore where the call also sets up mirror folders and legacy rows. */
+/** A connection with no mirror or legacy setup, for a caller that already ran `initStore`. */
+export function openBareHandle(hippoRoot, opts) {
+    return openHippoDb(hippoRoot, opts);
+}
+/** One call on a handle of its own, closed after (a request scope's handle stays open);
+ *  pass openStore where the call also sets up mirror folders and legacy rows. */
 export function onHandle(hippoRoot, fn, open = openHippoDb) {
     const db = open(hippoRoot);
     try {
@@ -58,10 +64,8 @@ export function onHandle(hippoRoot, fn, open = openHippoDb) {
 export const HALF_LIFE_BASE_META_KEY = 'default_half_life_base';
 /** `meta` key set once no memory of a decision, incident or other object sits on the old flat 90 days. */
 export const TYPED_HALF_LIFE_META_KEY = 'typed_half_life_on_default';
-/** The flat half-life the decision, incident and other object writers gave their memories before they took the default. */
-export const LEGACY_TYPED_HALF_LIFE = 90;
-/** A store with no memories starts on the current default half-life base so `hippo sleep` never migrates it; one that holds memories but no recorded base
- * predates the record and keeps the legacy 7-day base until sleep migrates it. */
+/** A store with no memories starts on the current default half-life base so `hippo sleep` never migrates it; one that
+ * holds memories but no recorded base predates the record and keeps the legacy 7-day base until sleep migrates it. */
 function recordHalfLifeBaseForNewStore(db) {
     if (getMeta(db, HALF_LIFE_BASE_META_KEY, '') !== '')
         return;
@@ -103,7 +107,12 @@ function importLegacyEntries(db, hippoRoot, legacyEntries) {
         catch (err) {
             if (err instanceof RejectedValueError) {
                 rejectedCount++;
-                audit(db, 'reject_refusal', { targetId: err.entryId, metadata: { digest: err.digest, reason: err.reason }, actor: 'cli', tenantId: err.tenantId });
+                audit(db, 'reject_refusal', {
+                    targetId: err.entryId,
+                    metadata: { digest: err.digest, reason: err.reason },
+                    actor: 'cli',
+                    tenantId: err.tenantId,
+                });
                 continue;
             }
             throw err;
@@ -150,7 +159,7 @@ export function loadLegacyEntriesFromMarkdown(hippoRoot) {
                     entries.push(entry);
             }
             catch (err) {
-                log.warn(`store: skipped unreadable legacy file ${file}: ${errorMessage(err)}`);
+                log.warn(`store: skipped unreadable legacy file ${file}: ${errorMessage(err)}`, errorFields(err));
             }
         }
     }
@@ -162,7 +171,7 @@ function readLegacyJsonObject(file) {
         parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
     }
     catch (err) {
-        log.warn(`store: unreadable ${path.basename(file)} read as empty: ${errorMessage(err)}`);
+        log.warn(`store: unreadable ${path.basename(file)} read as empty: ${errorMessage(err)}`, errorFields(err));
         return null;
     }
     if (!isJsonObject(parsed)) {
@@ -176,7 +185,8 @@ function loadLegacyIndexFile(hippoRoot) {
     const empty = { version: 1, entries: {}, last_retrieval_ids: [], last_trace_id: null };
     if (!fs.existsSync(indexPath))
         return empty;
-    // SAFETY: index.json is written by writeIndexMirror as a HippoIndex; readers default every field, so only the object shape is checked.
+    // SAFETY: index.json is written by writeIndexMirror as a HippoIndex; readers default every field, so only the object
+    // shape is checked.
     return readLegacyJsonObject(indexPath) ?? empty;
 }
 function loadLegacyStatsFile(hippoRoot) {

package/dist/store/pilot-arm.d.ts

@@ -2,7 +2,8 @@ import { type DatabaseSyncLike } from '../db/index.js';
 export type PilotArm = 'hippo' | 'holdout';
 /** Deterministic split: the same session and rate always land in the same arm. */
 export declare function hashArm(sessionId: string, rateBp: number): PilotArm;
-/** The session's first stored arm, or null; never writes. Without `tenantId` any tenant's row counts, since on one machine a session has one arm. */
+/** The session's first stored arm, or null; never writes. Without `tenantId` any tenant's row counts, since on one
+ * machine a session has one arm. */
 export declare function readPilotArm(db: DatabaseSyncLike, sessionId: string, tenantId?: string): PilotArm | null;
 /** The stored arm, else the hash arm written once; on any error the hash arm comes back unrecorded. */
 export declare function ensurePilotArm(db: DatabaseSyncLike, tenantId: string, sessionId: string, rateBp: number, opts?: {

package/dist/store/pilot-arm.js

@@ -1,8 +1,9 @@
 // Pilot arm: one token_ledger row per session names its arm, `hippo` or `holdout`, so a pilot can compare them.
-// `items` holds the holdout rate in basis points; readers outside this repo depend on these rows, so their shape is fixed.
+// `items` holds the holdout rate in basis points; readers outside this repo depend on these rows, so their shape is
+// fixed.
 import { createHash } from 'node:crypto';
 import { HOOK_DB_WAIT_MS, scopedBusyWait, withWriteScope } from '../db/index.js';
-import { errorMessage, log } from '../util/log.js';
+import { errorMessage, log, errorFields } from '../util/log.js';
 import { firstPilotArmHash } from './token-ledger-rows.js';
 import { recordTokenUse } from './token-ledger.js';
 /** Deterministic split: the same session and rate always land in the same arm. */
@@ -10,13 +11,15 @@ export function hashArm(sessionId, rateBp) {
     const bucket = parseInt(createHash('sha256').update(sessionId).digest('hex').slice(0, 8), 16) % 10000;
     return bucket < rateBp ? 'holdout' : 'hippo';
 }
-/** The session's first stored arm, or null; never writes. Without `tenantId` any tenant's row counts, since on one machine a session has one arm. */
+/** The session's first stored arm, or null; never writes. Without `tenantId` any tenant's row counts, since on one
+ * machine a session has one arm. */
 export function readPilotArm(db, sessionId, tenantId) {
     const row = firstPilotArmHash(db, sessionId, tenantId);
     return row?.block_hash === 'holdout' || row?.block_hash === 'hippo' ? row.block_hash : null;
 }
 /** The stored arm, else the hash arm written once; on any error the hash arm comes back unrecorded. */
-// The wait is the caller's lock-wait scope (a hook's 1 s, a server request's 250 ms); it holds on a handle opened in that scope.
+// The wait is the caller's lock-wait scope (a hook's 1 s, a server request's 250 ms); it holds on a handle opened in
+// that scope.
 export function ensurePilotArm(db, tenantId, sessionId, rateBp, opts = {}) {
     const hashed = hashArm(sessionId, rateBp);
     const readTenant = opts.ownTenantOnly ? tenantId : undefined;
@@ -28,14 +31,23 @@ export function ensurePilotArm(db, tenantId, sessionId, rateBp, opts = {}) {
         return withWriteScope(db, 'pilot_arm', () => {
             const stored = readPilotArm(db, sessionId, readTenant);
             if (stored === null) {
-                recordTokenUse(db, { tenantId, sessionId, surface: 'pilot', event: 'arm', items: rateBp, tokens: 0, hash: hashed, now: opts.now });
+                recordTokenUse(db, {
+                    tenantId,
+                    sessionId,
+                    surface: 'pilot',
+                    event: 'arm',
+                    items: rateBp,
+                    tokens: 0,
+                    hash: hashed,
+                    now: opts.now,
+                });
             }
             return stored ?? hashed;
         }, { busyWaitMs: scopedBusyWait() ?? HOOK_DB_WAIT_MS });
     }
     catch (err) {
         // A prompt hook must not fail on pilot bookkeeping; concurrent callers still agree on the hash arm.
-        log.debug(`pilot arm not stored, using the hash arm: ${errorMessage(err)}`);
+        log.debug(`pilot arm not stored, using the hash arm: ${errorMessage(err)}`, errorFields(err));
         return hashed;
     }
 }

package/dist/store/planning-fallacy-evidence.d.ts

@@ -1,8 +1,8 @@
 import { type PredictionBaserate } from './predictions.js';
 export interface ClassResolution {
     classTag: string | null;
-    /** True when >=2 classes tied at the best overlap score AND best >= 1. Caller emits `recall_autodebias_hint_tiebreak` and returns a null hint
-     * (silent: an alphabetical tiebreak would show the wrong class half the time). */
+    /** True when >=2 classes tied at the best overlap score AND best >= 1. Caller emits `recall_autodebias_hint_tiebreak`
+     * and returns a null hint (silent: an alphabetical tiebreak would show the wrong class half the time). */
     tiebreak: boolean;
 }
 /** The prediction class a forward claim resolves to, and that class's closed-prediction stats when one resolved. */

package/dist/store/planning-fallacy-evidence.js

@@ -1,7 +1,8 @@
 import { onHandle } from './open.js';
 import { computePredictionBaserate } from './predictions.js';
-/** Resolve a query-token set to a unique best-matching class_tag for the tenant: lower-cased token overlap, best score >= 1 AND above the 2nd-best.
- * TENANT-GLOBAL by design, not scope-filtered (base rates need the full sample): class_tag NAMES can cross scopes; use opaque names or HIPPO_AUTODEBIAS=off. */
+/** Resolve a query-token set to a unique best-matching class_tag for the tenant: lower-cased token overlap, best score
+ * >= 1 AND above the 2nd-best. TENANT-GLOBAL by design, not scope-filtered (base rates need the full sample): class_tag
+ * NAMES can cross scopes; use opaque names or HIPPO_AUTODEBIAS=off. */
 function resolveClassFromTokens(hippoRoot, tenantId, queryTokens) {
     if (queryTokens.length === 0)
         return { classTag: null, tiebreak: false };
@@ -27,8 +28,8 @@ function resolveClassFromTokens(hippoRoot, tenantId, queryTokens) {
                 bestClass = class_tag;
             }
             else if (score === bestScore && score > 0) {
-                // Tie at current best: bump secondBest, do NOT update bestClass (an alphabetical tiebreak would pick the wrong class on ambiguous queries; stay silent
-                // on tie).
+                // Tie at current best: bump secondBest, do NOT update bestClass (an alphabetical tiebreak would pick the wrong
+                // class on ambiguous queries; stay silent on tie).
                 secondBest = score;
             }
             else if (score > secondBest) {
@@ -46,7 +47,9 @@ function resolveClassFromTokens(hippoRoot, tenantId, queryTokens) {
 export function planningFallacyEvidenceAt(hippoRoot, tenantId, classQueryTokens) {
     const resolution = resolveClassFromTokens(hippoRoot, tenantId, classQueryTokens);
     // emitAudit=false: the recall_autodebias_hint row carries n_closed and mean_ratio, so predict_baserate stays off.
-    const baserate = resolution.classTag ? computePredictionBaserate(hippoRoot, tenantId, resolution.classTag, 'recall', false) : null;
+    const baserate = resolution.classTag
+        ? computePredictionBaserate(hippoRoot, tenantId, resolution.classTag, 'recall', false)
+        : null;
     return { ...resolution, baserate };
 }
 //# sourceMappingURL=planning-fallacy-evidence.js.map

package/dist/store/port/agent-import.d.ts

@@ -0,0 +1,62 @@
+import type { MemoryEntry } from '../../core/memory.js';
+import type { AppendAuditOpts } from '../audit.js';
+import type { DormantSnapshot } from '../dormant.js';
+import type { RenameSourceOptions } from '../entry-writes.js';
+import type { GatedWriteResult } from '../gated-write.js';
+import type { ProjectTagReads } from '../project-tags.js';
+import type { SetAsideResult, SetAsideWhy } from '../set-aside.js';
+/** The calls one container's sync makes inside its transaction, bound to the target store's handle and root. */
+export interface ContainerTx {
+    liveBySourcePrefix(tenantId: string, prefix: string): MemoryEntry[];
+    dormantBySourcePrefix(tenantId: string, prefix: string): DormantSnapshot[];
+    readDormant(tenantId: string, id: string): DormantSnapshot | null;
+    deleteDormant(tenantId: string, id: string): void;
+    replaceDormant(tenantId: string, id: string, entry: MemoryEntry): void;
+    entryIdTaken(id: string): boolean;
+    /** True when `text` matches a rejected-value tombstone of the tenant. */
+    isRejected(tenantId: string, text: string): boolean;
+    renameSource(tenantId: string, id: string, from: string, to: string): number;
+    renameSourceAndOrigin(tenantId: string, id: string, move: RenameSourceOptions): number;
+    setTags(entry: MemoryEntry): void;
+    supersede(tenantId: string, id: string, newId: string): boolean;
+    markSummaryDirty(summaryId: string, tenantId: string, actor: string): void;
+    appendAudit(event: AppendAuditOpts): void;
+    gatedWrite(entry: MemoryEntry, opts: {
+        actor: string;
+        worthCheck: boolean;
+    }): GatedWriteResult;
+    setAside(tag: string, row: MemoryEntry, why: SetAsideWhy): SetAsideResult;
+    /** The entry with the target store's origin stamped when it has none. */
+    stampOrigin(entry: MemoryEntry): MemoryEntry;
+}
+/** One open target store; close releases its handle, and a stand-in's folder with it. */
+export interface ImportTarget {
+    readonly root: string;
+    /** The tenant the import writes as. */
+    readonly tenantId: string;
+    liveBySourcePrefix(prefix: string): MemoryEntry[];
+    rowsOutsideSourcePrefix(prefix: string, origins: readonly string[] | null): Array<{
+        id: string;
+        content: string;
+        source: string;
+    }>;
+    projectTagReads(): ProjectTagReads;
+    /** `work` in one write scope, or a trial scope that rolls back on `dryRun`. */
+    inContainer<T>(scope: string, dryRun: boolean, work: (tx: ContainerTx) => T): T;
+    writeMirror(entry: MemoryEntry): void;
+    removeMirror(id: string): void;
+    bumpRemembered(count: number): void;
+    close(): void;
+}
+export interface AgentImport {
+    /** Creates the store at `root` with its folders. */
+    create(root: string): void;
+    open(root: string, opts: {
+        busyWaitMs?: number;
+    }): ImportTarget;
+    /** An empty store in a scratch folder a dry run plans against. */
+    openStandIn(): ImportTarget;
+    /** True when `err` means another writer held the store past its wait. */
+    isBusy<E>(err: E): boolean;
+}
+//# sourceMappingURL=agent-import.d.ts.map

package/dist/store/port/agent-import.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=agent-import.js.map

package/dist/store/port/consolidation.d.ts

@@ -0,0 +1,129 @@
+import type { MemoryEntry } from '../../core/memory.js';
+import type { PhysicsParticle } from '../../core/physics.js';
+import type { WriteBudget } from '../../util/write-budget.js';
+import type { AppendAuditOpts, AuditOp } from '../audit.js';
+import type { DetectedConflict } from '../conflicts.js';
+import type { FlushComponent, LoadedRows } from '../delete-and-batch.js';
+import type { EntriesWithBase } from '../entry-reads.js';
+import type { HalfLifeMove, HalfLifeRows } from '../half-life.js';
+import type { SessionDecayContext } from '../index-and-stats.js';
+import type { SessionEvent } from '../rows.js';
+import type { RebuildPatch } from '../summaries.js';
+import type { TombstoneChecks } from '../tombstone-checks.js';
+/** What sleep reads and writes on hippo.db, every tenant at once. */
+export interface Consolidation {
+    /** Every memory of every tenant, with a by-id lookup of each as loaded for the flush to compare against. */
+    entriesWithBase(): EntriesWithBase;
+    /** The ids of every memory a typed object row names; sleep never retires one. */
+    objectBackedIds(): Set<string>;
+    /** The full-text index counts when they drift from `memories` (re-synced when `repair`), else null. */
+    ftsDrift(repair: boolean): {
+        memories: number;
+        fts: number;
+    } | null;
+    /** The sleep count and the average interval between recent sleeps. */
+    sessionDecayContext(): SessionDecayContext;
+    /** Tombstone lookups and refusal audit rows on one lazily opened handle; nothing opens under dryRun. */
+    tombstoneChecks(dryRun: boolean): TombstoneChecks;
+    /** The default half-life base the memories are on. */
+    halfLifeBase(): number;
+    /** Plans from one read of the rows, then writes the moves `plan` returns once (nothing under dryRun). */
+    moveHalfLives<R>(to: number, opts: {
+        dryRun: boolean;
+        actor: string;
+    }, plan: (rows: HalfLifeRows) => {
+        moves: readonly HalfLifeMove[];
+        outcome: R;
+    }): {
+        from: number;
+        outcome: R | null;
+    };
+    /** The tenant's sessions completed since `sinceMs`. */
+    promotableSessions(tenantId: string, sinceMs: number): Array<{
+        session_id: string;
+    }>;
+    /** True when the tenant already holds a trace for the session. */
+    traceExists(tenantId: string, sessionId: string): boolean;
+    /** The tenant's session events, filtered as `listSessionEvents` filters them. */
+    sessionEvents(tenantId: string, opts: {
+        session_id?: string;
+        limit?: number;
+    }): SessionEvent[];
+    /** Every stored physics particle, in load order. */
+    storedParticles(): PhysicsParticle[];
+    /** Writes the particles over their stored state, as one batch. */
+    saveParticles(particles: PhysicsParticle[]): void;
+    /** Commits each component whole, in chunks the budget paces, under sleep's own lock wait; resolves to the ids it
+     * removed. */
+    commitFlush(components: readonly FlushComponent[], opts: {
+        snapshot: LoadedRows;
+        budget: WriteBudget;
+    }): Promise<string[]>;
+    /** Counts (dryRun) or deletes the dormant memories moved before `cutoffIso`, under sleep's own lock wait. */
+    expireDormant(cutoffIso: string, opts: {
+        dryRun: boolean;
+        budget: WriteBudget;
+    }): Promise<number>;
+    /** Replaces the detected conflicts with these. */
+    replaceConflicts(detected: DetectedConflict[], detectedAt: string): void;
+    /** Appends one consolidation-run row. */
+    recordRun(run: {
+        timestamp: string;
+        decayed: number;
+        merged: number;
+        removed: number;
+    }): void;
+    /** Adds one to the store's sleep count. */
+    countSleep(): void;
+    /** Appends each row as its own write; a failed row is logged and counted, and the failures returned as a count. */
+    auditEachRow(events: readonly AppendAuditOpts[]): number;
+    /** Logs and counts an audit row that could not be written, for a caller whose own write threw. */
+    reportAuditFailure(op: AuditOp, reason: string): void;
+    /** Every memory of every tenant, as it stands now. */
+    allEntries(): MemoryEntry[];
+    /** The current distilled memories: no raw row and no superseded one. */
+    currentDistilledEntries(): MemoryEntry[];
+    /** Deletes each target in its own transaction; true where the row went. */
+    deleteOneByOne(targets: readonly {
+        id: string;
+        reason: string;
+    }[], opts: {
+        actor?: string;
+        automatic?: boolean;
+    }): boolean[];
+    /** The ids of the unit a flush stopped before, if `err` is that stop. */
+    failedUnitOf(err: Error | null): string[] | undefined;
+    /** Tenants with pending graph work, each with its highest pending queue id. */
+    dirtyGraphTenants(): {
+        tenantId: string;
+        maxPendingId: number;
+    }[];
+    /** Marks the tenant's pending graph work up to `maxId` processed; returns how many rows it marked. */
+    markGraphDrained(tenantId: string, maxId: number): number;
+    /** Writes one memory through the rejection guard, which throws RejectedValueError on a tombstoned value. */
+    writeEntry(entry: MemoryEntry): void;
+    /** Writes the memories in one transaction; returns how many it wrote. */
+    writeTogether(entries: readonly MemoryEntry[]): number;
+    /** Up to `limit` summaries marked dirty. */
+    dirtySummaries(limit: number): MemoryEntry[];
+    /** The current children of one summary. */
+    childrenOfSummary(summaryId: string, tenantId: string): MemoryEntry[];
+    /** One read of the children of every summary given, looked up per summary. */
+    childrenOfSummaries(summaries: ReadonlyArray<{
+        id: string;
+        tenant_id: string;
+    }>): (summary: {
+        id: string;
+        tenant_id: string;
+    }) => MemoryEntry[];
+    /** Applies a rebuilt summary while it is still dirty; `refused` when its new content is tombstoned. */
+    applyRebuild(summary: MemoryEntry, patch: RebuildPatch): {
+        changed: boolean;
+        refused: boolean;
+    };
+    /** Clears the dirty mark a fresh summary got from its own child links. */
+    clearSummaryDirty(summaryId: string, tenantId: string, actor: string, source?: string): void;
+    /** The L2 topic summaries with no L3 profile above them. */
+    unprofiledTopicSummaries(): MemoryEntry[];
+}
+//# sourceMappingURL=consolidation.d.ts.map

package/dist/store/port/consolidation.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=consolidation.js.map

package/dist/store/port/learning.d.ts

@@ -0,0 +1,19 @@
+import type { MemoryEntry } from '../../core/memory.js';
+/** What auto-learn, extraction and invalidation read and write on hippo.db. */
+export interface Learning {
+    /** Every memory of `tenantId`, or of every tenant when it is undefined. */
+    allEntries(tenantId?: string): MemoryEntry[];
+    /** The memories whose content shares a token with `tokens`, plus those carrying exactly `tag`. */
+    entriesMentioning(tokens: readonly string[], tag: string, tenantId?: string): MemoryEntry[];
+    readEntry(id: string, tenantId?: string): MemoryEntry | null;
+    /** Rows of `tenantId` that are current and whose origin project is one of `origins`. */
+    currentEntriesFromOrigins(tenantId: string, origins: readonly string[]): MemoryEntry[];
+    /** Writes one memory; throws RejectedValueError when its value was rejected. */
+    writeEntry(entry: MemoryEntry): void;
+    /** Writes the rows in one transaction and returns how many. */
+    writeEntriesTogether(entries: readonly MemoryEntry[]): number;
+    addTagToEntries(tenantId: string, ids: readonly string[], tag: string): void;
+    /** When each memory was last confirmed by a good outcome, by id. */
+    confirmedOutcomeTimes(tenantId: string): Map<string, string>;
+}
+//# sourceMappingURL=learning.d.ts.map

package/dist/store/port/learning.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=learning.js.map

package/dist/store/port/local-files.d.ts

@@ -0,0 +1,18 @@
+import type { AgentImport } from './agent-import.js';
+import type { Consolidation } from './consolidation.js';
+import type { Learning } from './learning.js';
+import type { Promotion } from './promotion.js';
+export type { AgentImport, ContainerTx, ImportTarget } from './agent-import.js';
+export type { Consolidation } from './consolidation.js';
+export type { Learning } from './learning.js';
+export type { Promotion } from './promotion.js';
+/** The store is hippo.db and its files under `hippoRoot`, so a path that reopens them by folder (sleep, its child
+ * process, the global store) may run. */
+export interface LocalFiles {
+    readonly hippoRoot: string;
+    readonly consolidation: Consolidation;
+    readonly agentImport: AgentImport;
+    readonly promotion: Promotion;
+    readonly learning: Learning;
+}
+//# sourceMappingURL=local-files.d.ts.map

package/dist/store/port/local-files.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=local-files.js.map

package/dist/store/port/promotion.d.ts

@@ -0,0 +1,20 @@
+import type { MemoryEntry } from '../../core/memory.js';
+export interface PromoteOptions {
+    actor?: string;
+    tenantId?: string;
+    /** Also writes one `promote` audit row for the copy ({sourceId}), in the copy's own transaction. */
+    auditAs?: {
+        tenantId: string;
+        actor: string;
+    };
+}
+export interface Promotion {
+    /** The tenant and scope of the local memory, or undefined when no row has the id. */
+    reach(id: string): {
+        tenantId: string;
+        scope: string | null;
+    } | undefined;
+    /** Copies the local memory into the global store as a new `g_` row; the caller embeds the copy. */
+    copyToGlobal(id: string, opts: PromoteOptions): MemoryEntry;
+}
+//# sourceMappingURL=promotion.d.ts.map

package/dist/store/port/promotion.js

@@ -0,0 +1,3 @@
+// The local-to-global copy behind `promote`, sync like the rest of LocalFiles so its audit row commits with the copy.
+export {};
+//# sourceMappingURL=promotion.js.map