hippo-memory 1.69.0 → 1.71.0

package/dist/store/entry-writes.d.ts

@@ -1,31 +1,31 @@
-import { type MemoryEntry } from '../memory.js';
-import { type DatabaseSyncLike } from '../db.js';
+import { type MemoryEntry } from '../core/memory.js';
+import { type DatabaseSyncLike } from '../db/index.js';
 export interface WriteEntryOptions {
     actor?: string;
     afterWrite?: (db: DatabaseSyncLike, memoryId: string) => void;
     /** Runs after the row commits and before the mirrors, on an idle connection; keep it best-effort. */
     afterCommit?: () => void;
 }
+/** Write an entry to SQLite and refresh mirrors; `opts.afterWrite` runs in the same SAVEPOINT as the INSERT, so a throw rolls the row back.
+ * `opts.actor` defaults to 'cli'; the api layer passes the resolved actor so the audit log gets one row per write. */
 export declare function writeEntry(hippoRoot: string, entry: MemoryEntry, opts?: WriteEntryOptions): void;
-/** writeEntry on the caller's open store, so a loop of writes opens the store once; each row still commits alone. */
-export declare function writeEntryOn(db: DatabaseSyncLike, hippoRoot: string, entry: MemoryEntry, opts?: WriteEntryOptions): void;
-/**
- * DB-only write path. Caller owns the open `db` handle. Runs upsert +
- * afterWrite hook + audit row inside one withWriteScope. Caller
- * is responsible for opening `db`, optionally wrapping in a larger BEGIN/
- * COMMIT (e.g. supersede's BEGIN IMMEDIATE), closing `db`, AND calling
- * `writeEntryMirrors` after the larger tx commits — mirrors must run
- * post-commit so a rolled-back tx never leaves orphan markdown.
- *
- * Audit-order note: the audit row is emitted INSIDE the write scope, so audit
- * commits atomically with the row INSERT. A subsequent mirror failure cannot
- * leave a recorded audit entry without its corresponding DB row. This is a
- * documented hardening over the prior writeEntry-as-monolith ordering.
- */
+/** writeEntry for each of `entries` in one transaction, so all land or none; each
+ * keeps its audit row, and mirrors follow the commit. Returns how many were written. */
+export declare function writeEntriesTogether(hippoRoot: string, entries: readonly MemoryEntry[]): number;
+/** writeEntry for each of `entries` on one open store, so the open and its lock wait are
+ * paid once; each row commits alone, and none opens the store when the list is empty. */
+export declare function writeEntriesSeparately(hippoRoot: string, entries: readonly MemoryEntry[]): void;
+/** Adds `tag` to each of a tenant's rows that lacks it, in `ids` order, each read fresh
+ * on one open store and committed alone; an id the tenant does not hold is skipped. */
+export declare function addTagToEntries(hippoRoot: string, tenantId: string, ids: readonly string[], tag: string): void;
+/** DB-only write path: upsert, afterWrite hook and audit row inside one withWriteScope; the caller owns `db` and must call `writeEntryMirrors` after any
+ * outer tx commits, so a rolled-back tx never leaves orphan markdown. The audit row commits atomically with the INSERT. */
 export declare function writeEntryDbOnly(db: DatabaseSyncLike, entry: MemoryEntry, opts?: {
     actor?: string;
     afterWrite?: (db: DatabaseSyncLike, memoryId: string) => void;
 }): void;
+/** What follows a row's upsert inside its write scope: the remember row, last of the write's audit rows, then the summary parent's dirty mark. */
+export declare function auditEntryWrite(db: DatabaseSyncLike, entry: MemoryEntry, actor: string): void;
 /** Markdown mirror path, invoked AFTER commit (a rolled-back tx must leave no orphan markdown). */
 export declare function writeEntryMirrors(hippoRoot: string, entry: MemoryEntry): void;
 /** The caller passes the eval-only recall-boost ablation switch, so the store never reads experiment config itself. */
@@ -44,4 +44,27 @@ export declare function strengthenRetrievedOn(db: DatabaseSyncLike, ids: readonl
 export declare function setEntryTagsInTx(db: DatabaseSyncLike, entry: MemoryEntry): void;
 /** Removes a row from `memories` and full-text search on the caller's transaction, as sleep's dormant move does, and marks its summary parent dirty. */
 export declare function deleteEntryRowInTx(db: DatabaseSyncLike, entry: MemoryEntry, actor: string): void;
+/** One half-life per memory id, on the caller's transaction. */
+export declare function setHalfLivesAt(db: DatabaseSyncLike, rows: readonly {
+    id: string;
+    halfLifeDays: number;
+}[]): void;
+/** Moves every row of `from` in a tenant to project `into`. */
+export declare function restampOriginProjectAt(db: DatabaseSyncLike, tenantId: string, from: string, into: string): void;
+/** Stamps each id with its project. */
+export declare function stampOriginProjectsAt(db: DatabaseSyncLike, tenantId: string, rows: readonly {
+    id: string;
+    origin: string;
+}[]): void;
+/** Renames a live row's source from `from` to `to`; the count is 0 when another writer moved or superseded it first. */
+export declare function renameEntrySourceAt(db: DatabaseSyncLike, tenantId: string, id: string, from: string, to: string): number;
+export interface RenameSourceOptions {
+    readonly from: string;
+    readonly to: string;
+    readonly origin: string | null;
+}
+/** Renames a row's source and, when `origin` is not null, its project; the count is 0 when the row is gone or moved. */
+export declare function renameEntrySourceAndOriginAt(db: DatabaseSyncLike, tenantId: string, id: string, options: RenameSourceOptions): number;
+/** Marks `id` superseded by `newId`; false when another writer superseded it first. */
+export declare function supersedeEntryAt(db: DatabaseSyncLike, tenantId: string, id: string, newId: string): boolean;
 //# sourceMappingURL=entry-writes.d.ts.map

package/dist/store/entry-writes.js

@@ -1,24 +1,69 @@
-import { markRetrieved } from '../memory.js';
-import { closeHippoDb, openHippoDb, rethrowIfSqliteBlocked, withWriteScope } from '../db.js';
-import { RejectedValueError } from '../rejection.js';
-import { markSummaryDirtyInTx } from '../summary-dirty.js';
-import { log } from '../log.js';
-import { MEMORY_SELECT_COLUMNS, rowToEntry } from './rows.js';
+import { markRetrieved } from '../core/memory.js';
+import { closeHippoDb, openHippoDb, rethrowIfSqliteBlocked, withWriteScope } from '../db/index.js';
+import { RejectedValueError } from './rejection.js';
+import { markSummaryDirtyInTx } from './summary-dirty.js';
+import { errorMessage, log } from '../util/log.js';
 import { auditRejectionRefusal, audit } from './audit-event.js';
+import { selectEntriesByIds } from './entry-reads.js';
 import { stampOriginProject, upsertEntryRow, syncFtsRow, deleteFtsRow } from './entry-row.js';
 import { mirrorBestEffort, writeMarkdownMirror } from './mirrors.js';
-import { openStore } from './open.js';
+import { onHandle, openStore } from './open.js';
+/** Write an entry to SQLite and refresh mirrors; `opts.afterWrite` runs in the same SAVEPOINT as the INSERT, so a throw rolls the row back.
+ * `opts.actor` defaults to 'cli'; the api layer passes the resolved actor so the audit log gets one row per write. */
 export function writeEntry(hippoRoot, entry, opts) {
+    onHandle(hippoRoot, (db) => {
+        writeEntryOn(db, hippoRoot, entry, opts);
+    }, openStore);
+}
+/** writeEntry for each of `entries` in one transaction, so all land or none; each
+ * keeps its audit row, and mirrors follow the commit. Returns how many were written. */
+export function writeEntriesTogether(hippoRoot, entries) {
+    const stamped = entries.map((entry) => stampOriginProject(hippoRoot, entry));
     const db = openStore(hippoRoot);
     try {
-        writeEntryOn(db, hippoRoot, entry, opts);
+        withWriteScope(db, 'write_entries_together', () => {
+            for (const entry of stamped)
+                writeEntryDbOnly(db, entry);
+        });
+        for (const entry of stamped)
+            writeEntryMirrors(hippoRoot, entry);
+    }
+    catch (error) {
+        // The scope has unwound, so the refusal row outlives the rollback, as writeEntryOn's does.
+        if (error instanceof RejectedValueError)
+            auditRejectionRefusal(db, error, 'cli');
+        throw error;
     }
     finally {
         closeHippoDb(db);
     }
+    return stamped.length;
+}
+/** writeEntry for each of `entries` on one open store, so the open and its lock wait are
+ * paid once; each row commits alone, and none opens the store when the list is empty. */
+export function writeEntriesSeparately(hippoRoot, entries) {
+    if (entries.length === 0)
+        return;
+    onHandle(hippoRoot, (db) => {
+        for (const entry of entries)
+            writeEntryOn(db, hippoRoot, entry);
+    }, openStore);
+}
+/** Adds `tag` to each of a tenant's rows that lacks it, in `ids` order, each read fresh
+ * on one open store and committed alone; an id the tenant does not hold is skipped. */
+export function addTagToEntries(hippoRoot, tenantId, ids, tag) {
+    onHandle(hippoRoot, (db) => {
+        const live = selectEntriesByIds(db, ids, tenantId);
+        for (const id of new Set(ids)) {
+            const entry = live.get(id);
+            if (!entry || entry.tags.includes(tag))
+                continue;
+            writeEntryOn(db, hippoRoot, { ...entry, tags: [...entry.tags, tag] });
+        }
+    }, openStore);
 }
 /** writeEntry on the caller's open store, so a loop of writes opens the store once; each row still commits alone. */
-export function writeEntryOn(db, hippoRoot, entry, opts) {
+function writeEntryOn(db, hippoRoot, entry, opts) {
     try {
         const stamped = stampOriginProject(hippoRoot, entry);
         writeEntryDbOnly(db, stamped, opts);
@@ -34,19 +79,8 @@ export function writeEntryOn(db, hippoRoot, entry, opts) {
         throw error;
     }
 }
-/**
- * DB-only write path. Caller owns the open `db` handle. Runs upsert +
- * afterWrite hook + audit row inside one withWriteScope. Caller
- * is responsible for opening `db`, optionally wrapping in a larger BEGIN/
- * COMMIT (e.g. supersede's BEGIN IMMEDIATE), closing `db`, AND calling
- * `writeEntryMirrors` after the larger tx commits — mirrors must run
- * post-commit so a rolled-back tx never leaves orphan markdown.
- *
- * Audit-order note: the audit row is emitted INSIDE the write scope, so audit
- * commits atomically with the row INSERT. A subsequent mirror failure cannot
- * leave a recorded audit entry without its corresponding DB row. This is a
- * documented hardening over the prior writeEntry-as-monolith ordering.
- */
+/** DB-only write path: upsert, afterWrite hook and audit row inside one withWriteScope; the caller owns `db` and must call `writeEntryMirrors` after any
+ * outer tx commits, so a rolled-back tx never leaves orphan markdown. The audit row commits atomically with the INSERT. */
 export function writeEntryDbOnly(db, entry, opts) {
     // Inside a caller's transaction (e.g. supersede's BEGIN IMMEDIATE) the scope is a SAVEPOINT,
     // so a throw here rolls back only this write and leaves the outer open.
@@ -55,16 +89,20 @@ export function writeEntryDbOnly(db, entry, opts) {
         if (opts?.afterWrite) {
             opts.afterWrite(db, entry.id);
         }
-        audit(db, 'remember', entry.id, {
+        auditEntryWrite(db, entry, opts?.actor ?? 'cli');
+    });
+}
+/** What follows a row's upsert inside its write scope: the remember row, last of the write's audit rows, then the summary parent's dirty mark. */
+export function auditEntryWrite(db, entry, actor) {
+    audit(db, 'remember', { targetId: entry.id, metadata: {
             kind: entry.kind ?? 'distilled',
             scope: entry.scope ?? null,
-        }, opts?.actor ?? 'cli', entry.tenantId);
-        // A child write marks its summary parent dirty for the sleep-cycle rebuild; most writes
-        // have no parent, so the hot path pays one null check.
-        if (entry.dag_parent_id) {
-            markSummaryDirtyInTx(db, entry.dag_parent_id, entry.tenantId, opts?.actor ?? 'cli');
-        }
-    });
+        }, actor, tenantId: entry.tenantId });
+    // A child write marks its summary parent dirty for the sleep-cycle rebuild; most writes
+    // have no parent, so the hot path pays one null check.
+    if (entry.dag_parent_id) {
+        markSummaryDirtyInTx(db, entry.dag_parent_id, entry.tenantId, actor);
+    }
 }
 /** Markdown mirror path, invoked AFTER commit (a rolled-back tx must leave no orphan markdown). */
 export function writeEntryMirrors(hippoRoot, entry) {
@@ -104,23 +142,15 @@ export function strengthenRetrievedInOwnTx(db, ids, opts) {
     }
 }
 function warnStrengthenFailed(error) {
-    log.warn(`retrieval stats not saved (${error instanceof Error ? error.message : String(error)})`);
+    log.warn(`retrieval stats not saved (${errorMessage(error)})`);
 }
 /** strengthenRetrieved on the caller's handle, inside the caller's transaction. Throws; the caller decides. */
 export function strengthenRetrievedOn(db, ids, opts) {
     const found = new Set();
     if (ids.length === 0 || opts.recallBoostAblated)
         return found;
-    const { tenantId } = opts;
-    const tenantClause = tenantId !== undefined ? ' AND tenant_id = ?' : '';
-    const select = db.prepare(`SELECT ${MEMORY_SELECT_COLUMNS} FROM memories WHERE id = ?${tenantClause}`);
-    const live = [];
-    for (const id of ids) {
-        // SAFETY: the SELECT names exactly MEMORY_SELECT_COLUMNS, matching MemoryRow's field set.
-        const row = (tenantId !== undefined ? select.get(id, tenantId) : select.get(id));
-        if (row)
-            live.push(rowToEntry(row));
-    }
+    const byId = selectEntriesByIds(db, ids, opts.tenantId);
+    const live = [...new Set(ids)].flatMap((id) => byId.get(id) ?? []);
     const update = db.prepare('UPDATE memories SET retrieval_count = ?, last_retrieved = ?, half_life_days = ?, strength = ? WHERE id = ?');
     for (const e of markRetrieved(live)) {
         update.run(e.retrieval_count, e.last_retrieved, e.half_life_days, e.strength, e.id);
@@ -141,4 +171,38 @@ export function deleteEntryRowInTx(db, entry, actor) {
     if (entry.dag_parent_id)
         markSummaryDirtyInTx(db, entry.dag_parent_id, entry.tenantId, actor);
 }
+/** One half-life per memory id, on the caller's transaction. */
+export function setHalfLivesAt(db, rows) {
+    const update = db.prepare('UPDATE memories SET half_life_days = ? WHERE id = ?');
+    for (const r of rows)
+        update.run(r.halfLifeDays, r.id);
+}
+/** Moves every row of `from` in a tenant to project `into`. */
+export function restampOriginProjectAt(db, tenantId, from, into) {
+    db.prepare(`UPDATE memories SET origin_project = ?, updated_at = datetime('now') WHERE tenant_id = ? AND origin_project = ?`)
+        .run(into, tenantId, from);
+}
+/** Stamps each id with its project. */
+export function stampOriginProjectsAt(db, tenantId, rows) {
+    const stamp = db.prepare(`UPDATE memories SET origin_project = ?, updated_at = datetime('now') WHERE tenant_id = ? AND id = ?`);
+    for (const { id, origin } of rows)
+        stamp.run(origin, tenantId, id);
+}
+/** Renames a live row's source from `from` to `to`; the count is 0 when another writer moved or superseded it first. */
+export function renameEntrySourceAt(db, tenantId, id, from, to) {
+    const moved = db.prepare(`UPDATE memories SET source = ? WHERE id = ? AND tenant_id = ? AND source = ? AND superseded_by IS NULL`).run(to, id, tenantId, from);
+    return Number(moved.changes ?? 0);
+}
+/** Renames a row's source and, when `origin` is not null, its project; the count is 0 when the row is gone or moved. */
+export function renameEntrySourceAndOriginAt(db, tenantId, id, options) {
+    const { from, to, origin } = options;
+    const done = db.prepare(`UPDATE memories SET source = ?, origin_project = COALESCE(?, origin_project) WHERE id = ? AND tenant_id = ? AND source = ?`).run(to, origin, id, tenantId, from);
+    return Number(done.changes ?? 0);
+}
+/** Marks `id` superseded by `newId`; false when another writer superseded it first. */
+export function supersedeEntryAt(db, tenantId, id, newId) {
+    const result = db.prepare(`UPDATE memories SET superseded_by = ? WHERE id = ? AND tenant_id = ? AND superseded_by IS NULL`)
+        .run(newId, id, tenantId);
+    return Number(result.changes ?? 0) !== 0;
+}
 //# sourceMappingURL=entry-writes.js.map

package/dist/{failure-log.d.ts → store/failure-log.d.ts}

@@ -1,5 +1,8 @@
-import type { CaptureErrorOutcome, RoutineRule } from './capture/failure-reading.js';
-import type { DatabaseSyncLike } from './db.js';
+import type { DatabaseSyncLike } from '../db/index.js';
+/** Why a failure was not stored, or `stored`. */
+export type CaptureErrorOutcome = 'stored' | 'duplicate' | 'skipped-interrupt' | 'skipped-routine' | 'skipped-invalid';
+/** Which routine check skipped a failure; the log keeps it so declines can be told apart from empty searches. */
+export type RoutineRule = 'declined' | 'os-permission' | 'no-match' | 'search-tool' | 'quiet-exit';
 /** Rows older than this are pruned on write, which also bounds how far back a repeat can be found. */
 export declare const FAILURE_LOG_RETENTION_DAYS = 90;
 /** A capture-error outcome, or `store-failed` when storing the lesson threw. */
@@ -52,6 +55,8 @@ export interface FailureSummary {
     repeats: number;
     sessions: number;
 }
+/** Failed tool calls logged since `sinceIso`, in every tenant; throws when the table is missing. */
+export declare function countFailuresSince(db: DatabaseSyncLike, sinceIso: string): number;
 /** Sum the failure log for one tenant since `sinceIso`. */
 export declare function summarizeFailures(db: DatabaseSyncLike, tenantId: string, sinceIso: string): FailureSummary;
 //# sourceMappingURL=failure-log.d.ts.map

package/dist/{failure-log.js → store/failure-log.js}

@@ -1,5 +1,6 @@
 /** Failure log: every failed tool call the capture-error hook sees, stored or not. */
-import { ConflictError } from './api-errors.js';
+import { ConflictError } from '../core/api-errors.js';
+import { DAY_MS } from '../util/time.js';
 /** Rows older than this are pruned on write, which also bounds how far back a repeat can be found. */
 export const FAILURE_LOG_RETENTION_DAYS = 90;
 /** Longest session id or tool name kept; the hook payload is not trusted to be short. */
@@ -10,7 +11,7 @@ export function recordFailure(db, event) {
     const now = new Date(event.now ?? Date.now()).toISOString();
     db.prepare(`INSERT INTO failure_log (ts, tenant_id, session_id, tool, outcome, skip_rule, sig_hash, detail_hash, owner_subject, origin_project, request_id)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(now, event.tenantId, event.sessionId?.slice(0, MAX_FIELD) ?? null, event.tool?.slice(0, MAX_FIELD) ?? null, event.outcome, event.rule ?? null, event.sigHash ?? null, event.detailHash ?? null, event.ownerSubject ?? null, event.originProject ?? null, event.requestId ?? null);
-    const cutoff = new Date(Date.parse(now) - FAILURE_LOG_RETENTION_DAYS * 86_400_000).toISOString();
+    const cutoff = new Date(Date.parse(now) - FAILURE_LOG_RETENTION_DAYS * DAY_MS).toISOString();
     db.prepare(`DELETE FROM failure_log WHERE ts < ?`).run(cutoff);
 }
 /** The outcome logged for a caller's request id, or null, so a retried send finds the first one; another session's id is a ConflictError. */
@@ -49,6 +50,12 @@ export function failuresBySession(db, tenantId, sinceIso) {
     }
     return [...bySession.values()];
 }
+/** Failed tool calls logged since `sinceIso`, in every tenant; throws when the table is missing. */
+export function countFailuresSince(db, sinceIso) {
+    // SAFETY: COUNT aggregate row.
+    const row = db.prepare(`SELECT COUNT(*) AS n FROM failure_log WHERE ts >= ?`).get(sinceIso);
+    return Number(row?.n ?? 0);
+}
 /** Sum the failure log for one tenant since `sinceIso`. */
 export function summarizeFailures(db, tenantId, sinceIso) {
     // SAFETY: the SELECT names exactly these two columns, TEXT and an aggregate.

package/dist/store/goals.d.ts

@@ -0,0 +1,96 @@
+import { type DatabaseSyncLike } from '../db/index.js';
+export type GoalStatus = 'active' | 'suspended' | 'completed';
+export type PolicyType = 'schema-fit-biased' | 'error-prioritized' | 'recency-first' | 'hybrid';
+export interface GoalRow {
+    id: string;
+    session_id: string;
+    tenant_id: string;
+    goal_name: string;
+    level: number;
+    parent_goal_id: string | null;
+    status: GoalStatus;
+    success_condition: string | null;
+    retrieval_policy_id: string | null;
+    created_at: string;
+    completed_at: string | null;
+    outcome_score: number | null;
+}
+export interface Goal {
+    id: string;
+    sessionId: string;
+    tenantId: string;
+    goalName: string;
+    level: number;
+    parentGoalId?: string;
+    status: GoalStatus;
+    successCondition?: string;
+    retrievalPolicyId?: string;
+    createdAt: string;
+    completedAt?: string;
+    outcomeScore?: number;
+}
+export interface RetrievalPolicy {
+    id: string;
+    goalId: string;
+    policyType: PolicyType;
+    weightSchemaFit: number;
+    weightRecency: number;
+    weightOutcome: number;
+    errorPriority: number;
+}
+export declare function rowToGoal(row: GoalRow): Goal;
+export interface PushGoalOpts {
+    sessionId: string;
+    tenantId: string;
+    goalName: string;
+    level?: number;
+    parentGoalId?: string;
+    successCondition?: string;
+    policy?: {
+        policyType: PolicyType;
+        weightSchemaFit?: number;
+        weightRecency?: number;
+        weightOutcome?: number;
+        errorPriority?: number;
+    };
+}
+export declare function pushGoal(hippoRoot: string, opts: PushGoalOpts): Goal;
+export declare function pushGoalWithDb(db: DatabaseSyncLike, opts: PushGoalOpts): Goal;
+export interface GetActiveGoalsOpts {
+    sessionId: string;
+    tenantId: string;
+}
+export declare function getActiveGoals(hippoRoot: string, opts: GetActiveGoalsOpts): Goal[];
+/** A session's active goals, oldest first, and the retrieval policy of each goal that names one. */
+export interface ActiveGoals {
+    readonly goals: Goal[];
+    readonly policies: ReadonlyMap<string, RetrievalPolicy>;
+}
+/** The active goals and their policies on one handle, so a goal and its policy never disagree. */
+export declare function activeGoalsWithPolicies(hippoRoot: string, opts: GetActiveGoalsOpts): ActiveGoals;
+/** Every goal of a (tenant, session), whatever its status, oldest first. */
+export declare function getSessionGoals(hippoRoot: string, opts: GetActiveGoalsOpts): Goal[];
+/** One `goal_recall_log` row: a boosted local memory recalled while its goal was active. */
+export interface GoalRecallLogRow {
+    goalId: string;
+    memoryId: string;
+    tenantId: string;
+    sessionId: string;
+    recalledAt: string;
+    score: number;
+}
+/** The rows whose memory lives in this store: goal_recall_log.memory_id references memories, so a global row would fail
+ *  the insert. A global result keeps its boost; it only earns no log row, so no outcome propagation. */
+export declare function localGoalRecallRows(db: DatabaseSyncLike, rows: readonly GoalRecallLogRow[]): GoalRecallLogRow[];
+/** INSERT OR IGNORE: UNIQUE(memory_id, goal_id) makes a re-recall during the same goal life a no-op for outcome attribution. */
+export declare function writeGoalRecallLog(db: DatabaseSyncLike, rows: readonly GoalRecallLogRow[]): void;
+export interface CompleteGoalOpts {
+    outcomeScore?: number;
+    /** When true, skip the strength-multiplier propagation (default false); status still goes to 'completed' and `outcome_score` is still recorded.
+     * The idempotency guard returns early on a second `completeGoal` call before this flag is read. */
+    noPropagate?: boolean;
+}
+export declare function completeGoal(hippoRoot: string, goalId: string, opts: CompleteGoalOpts): void;
+export declare function suspendGoal(hippoRoot: string, goalId: string): void;
+export declare function resumeGoal(hippoRoot: string, goalId: string): void;
+//# sourceMappingURL=goals.d.ts.map