hippo-memory 1.69.0 → 1.71.0

package/dist/cli/continuity.js

@@ -1,77 +1,83 @@
 // Where-you-left-off verbs: snapshot, session, handoff, current and working memory.
 import { saveActiveTaskSnapshot, loadActiveTaskSnapshot, clearActiveTaskSnapshot, appendSessionEvent, listSessionEvents, } from '../store/sessions.js';
 import { saveSessionHandoff, loadLatestHandoff, loadHandoffById, stampHandoffOutcome } from '../store/handoffs.js';
-import { isHandoffOutcome, formatHandoffEvidenceLine } from '../handoff.js';
-import { resolveTenantId } from '../tenant.js';
-import { wmPush, wmRead, wmClear, wmFlush } from '../working-memory.js';
-import { collectHandoffEvidence } from '../handoff-evidence.js';
+import { isHandoffOutcome, formatHandoffEvidenceLine } from '../core/handoff.js';
+import { wmPush, wmRead, wmClear, wmFlush } from '../store/working-memory.js';
+import { collectHandoffEvidence } from '../capture/handoff-evidence.js';
 import { printError } from './output.js';
-import { requireInit, printActiveTaskSnapshot, printSessionEvents, printHandoff, } from './shared.js';
-export function cmdSnapshot(hippoRoot, args, flags) {
-    requireInit(hippoRoot);
-    const subcommand = args[0] ?? 'show';
-    if (subcommand === 'save') {
-        const task = String(flags['task'] ?? '').trim();
-        const summary = String(flags['summary'] ?? '').trim();
-        const nextStep = String(flags['next-step'] ?? '').trim();
-        const sessionId = String(flags['session'] ?? flags['id'] ?? '').trim();
-        if (!task || !summary || !nextStep) {
-            printError('Usage: hippo snapshot save --task <task> --summary <summary> --next-step <step> [--source <source>] [--session <session-id>]');
-            process.exit(1);
-        }
-        const snapshot = saveActiveTaskSnapshot(hippoRoot, resolveTenantId({}), {
-            task,
-            summary,
-            next_step: nextStep,
-            source: String(flags['source'] ?? 'cli'),
-            session_id: sessionId || null,
-        });
-        console.log(`Saved active task snapshot #${snapshot.id}`);
-        console.log(`   Task: ${snapshot.task}`);
-        console.log(`   Next: ${snapshot.next_step}`);
-        if (snapshot.session_id) {
-            console.log(`   Session: ${snapshot.session_id}`);
-        }
-        return;
+import { requireInit } from './shared.js';
+import { printActiveTaskSnapshot, printSessionEvents, printHandoff } from './print.js';
+import { boolFlag, isStringFlag } from './flag-values.js';
+import { CliExit } from './exit.js';
+const ISO_DATETIME_CHARS = 19;
+function snapshotSave(hippoRoot, tenantId, flags) {
+    const task = String(flags['task'] ?? '').trim();
+    const summary = String(flags['summary'] ?? '').trim();
+    const nextStep = String(flags['next-step'] ?? '').trim();
+    const sessionId = String(flags['session'] ?? flags['id'] ?? '').trim();
+    if (!task || !summary || !nextStep) {
+        printError('Usage: hippo snapshot save --task <task> --summary <summary> --next-step <step> [--source <source>] [--session <session-id>]');
+        throw new CliExit(1);
+    }
+    const snapshot = saveActiveTaskSnapshot(hippoRoot, tenantId, {
+        task,
+        summary,
+        next_step: nextStep,
+        source: String(flags['source'] ?? 'cli'),
+        session_id: sessionId || null,
+    });
+    console.log(`Saved active task snapshot #${snapshot.id}`);
+    console.log(`   Task: ${snapshot.task}`);
+    console.log(`   Next: ${snapshot.next_step}`);
+    if (snapshot.session_id) {
+        console.log(`   Session: ${snapshot.session_id}`);
     }
-    if (subcommand === 'clear') {
-        const cleared = clearActiveTaskSnapshot(hippoRoot, resolveTenantId({}), String(flags['status'] ?? 'cleared'));
-        if (!cleared) {
-            console.log('No active task snapshot to clear.');
-            return;
-        }
-        console.log('Cleared active task snapshot.');
+}
+function snapshotClear(hippoRoot, tenantId, flags) {
+    const cleared = clearActiveTaskSnapshot(hippoRoot, tenantId, String(flags['status'] ?? 'cleared'));
+    if (!cleared) {
+        console.log('No active task snapshot to clear.');
         return;
     }
-    if (subcommand === 'show') {
-        const snapshot = loadActiveTaskSnapshot(hippoRoot, resolveTenantId({}));
-        if (!snapshot) {
-            if (flags['json']) {
-                console.log(JSON.stringify({ snapshot: null }));
-            }
-            else {
-                console.log('No active task snapshot saved.');
-            }
-            return;
-        }
+    console.log('Cleared active task snapshot.');
+}
+function snapshotShow(hippoRoot, tenantId, flags) {
+    const snapshot = loadActiveTaskSnapshot(hippoRoot, tenantId);
+    if (!snapshot) {
         if (flags['json']) {
-            console.log(JSON.stringify({ snapshot }, null, 2));
-            return;
+            console.log(JSON.stringify({ snapshot: null }));
+        }
+        else {
+            console.log('No active task snapshot saved.');
         }
-        printActiveTaskSnapshot(snapshot);
         return;
     }
+    if (flags['json']) {
+        console.log(JSON.stringify({ snapshot }, null, 2));
+        return;
+    }
+    printActiveTaskSnapshot(snapshot);
+}
+export function handleSnapshot({ hippoRoot, tenantId, args, flags }) {
+    requireInit(hippoRoot);
+    const subcommand = args[0] ?? 'show';
+    if (subcommand === 'save')
+        return snapshotSave(hippoRoot, tenantId, flags);
+    if (subcommand === 'clear')
+        return snapshotClear(hippoRoot, tenantId, flags);
+    if (subcommand === 'show')
+        return snapshotShow(hippoRoot, tenantId, flags);
     printError('Usage: hippo snapshot <save|show|clear>');
-    process.exit(1);
+    throw new CliExit(1);
 }
-function sessionLog(hippoRoot, s, flags) {
+function sessionLog(hippoRoot, tenantId, s, flags) {
     const eventType = String(flags['type'] ?? 'note').trim();
     const content = String(flags['content'] ?? '').trim();
     if (!s.sessionId || !content) {
         printError('Usage: hippo session log --id <session-id> --content <text> [--type <type>] [--task <task>] [--source <source>]');
-        process.exit(1);
+        throw new CliExit(1);
     }
-    const event = appendSessionEvent(hippoRoot, resolveTenantId({}), {
+    const event = appendSessionEvent(hippoRoot, tenantId, {
         session_id: s.sessionId,
         task: s.task || null,
         event_type: eventType || 'note',
@@ -82,8 +88,8 @@ function sessionLog(hippoRoot, s, flags) {
     console.log(`   Session: ${event.session_id}`);
     console.log(`   Type: ${event.event_type}`);
 }
-function sessionShow(hippoRoot, s, flags) {
-    const events = listSessionEvents(hippoRoot, resolveTenantId({}), {
+function sessionShow(hippoRoot, tenantId, s, flags) {
+    const events = listSessionEvents(hippoRoot, tenantId, {
         session_id: s.sessionId || undefined,
         task: s.task || undefined,
         limit: s.limit,
@@ -94,9 +100,9 @@ function sessionShow(hippoRoot, s, flags) {
     }
     printSessionEvents(events);
 }
-function sessionLatest(hippoRoot, s, flags) {
-    const snapshot = loadActiveTaskSnapshot(hippoRoot, resolveTenantId({}));
-    const events = listSessionEvents(hippoRoot, resolveTenantId({}), {
+function sessionLatest(hippoRoot, tenantId, s, flags) {
+    const snapshot = loadActiveTaskSnapshot(hippoRoot, tenantId);
+    const events = listSessionEvents(hippoRoot, tenantId, {
         session_id: s.sessionId || snapshot?.session_id || undefined,
         limit: s.limit,
     });
@@ -113,23 +119,23 @@ function sessionLatest(hippoRoot, s, flags) {
     }
     printSessionEvents(events);
 }
-function sessionComplete(hippoRoot, s, flags) {
+function sessionComplete(hippoRoot, tenantId, s, flags) {
     const { sessionId, task } = s;
     const outcomeRaw = String(flags['outcome'] ?? '').trim();
     const summary = String(flags['summary'] ?? '').trim();
     if (!sessionId) {
         printError('Usage: hippo session complete --session <session-id> --outcome <success|failure|partial> [--summary "..."]');
-        process.exit(1);
+        throw new CliExit(1);
     }
     if (!isHandoffOutcome(outcomeRaw)) {
         printError(`Invalid outcome: "${outcomeRaw}". Must be one of: success, failure, partial.`);
-        process.exit(1);
+        throw new CliExit(1);
     }
     const outcome = outcomeRaw;
     const metadata = { ended_at: new Date().toISOString() };
     if (summary)
         metadata.summary = summary;
-    const event = appendSessionEvent(hippoRoot, resolveTenantId({}), {
+    const event = appendSessionEvent(hippoRoot, tenantId, {
         session_id: sessionId,
         task: task || null,
         event_type: 'session_complete',
@@ -138,12 +144,12 @@ function sessionComplete(hippoRoot, s, flags) {
         metadata,
     });
     console.log(`Completed session ${event.session_id} with outcome=${outcome} (event #${event.id})`);
-    const stamped = stampHandoffOutcome(hippoRoot, resolveTenantId({}), sessionId, outcome);
+    const stamped = stampHandoffOutcome(hippoRoot, tenantId, sessionId, outcome);
     if (stamped > 0) {
         console.log(`Stamped outcome on handoff for session ${sessionId}`);
     }
 }
-export function cmdSession(hippoRoot, args, flags) {
+export function handleSession({ hippoRoot, tenantId, args, flags }) {
     requireInit(hippoRoot);
     const subcommand = args[0] ?? 'show';
     const sessionId = String(flags['id'] ?? flags['session'] ?? '').trim();
@@ -151,20 +157,20 @@ export function cmdSession(hippoRoot, args, flags) {
     const limit = Math.max(1, parseInt(String(flags['limit'] ?? '8'), 10) || 8);
     const s = { sessionId, task, limit };
     if (subcommand === 'log')
-        return sessionLog(hippoRoot, s, flags);
+        return sessionLog(hippoRoot, tenantId, s, flags);
     if (subcommand === 'show')
-        return sessionShow(hippoRoot, s, flags);
+        return sessionShow(hippoRoot, tenantId, s, flags);
     if (subcommand === 'latest')
-        return sessionLatest(hippoRoot, s, flags);
+        return sessionLatest(hippoRoot, tenantId, s, flags);
     if (subcommand === 'complete')
-        return sessionComplete(hippoRoot, s, flags);
+        return sessionComplete(hippoRoot, tenantId, s, flags);
     if (subcommand === 'resume')
-        return sessionResume(hippoRoot, sessionId);
+        return sessionResume(hippoRoot, tenantId, sessionId);
     printError('Usage: hippo session <log|show|latest|resume|complete>');
-    process.exit(1);
+    throw new CliExit(1);
 }
-function sessionResume(hippoRoot, sessionId) {
-    const handoff = loadLatestHandoff(hippoRoot, resolveTenantId({}), sessionId || undefined);
+function sessionResume(hippoRoot, tenantId, sessionId) {
+    const handoff = loadLatestHandoff(hippoRoot, tenantId, sessionId || undefined);
     if (!handoff) {
         console.log('No handoff to resume from.');
         return;
@@ -209,18 +215,18 @@ function sessionResume(hippoRoot, sessionId) {
 }
 /** A repeatable flag as a list: absent is empty, one value is a singleton. */
 function flagList(value) {
-    return Array.isArray(value) ? value : (typeof value === 'string' ? [value] : []);
+    return Array.isArray(value) ? value : (isStringFlag(value) ? [value] : []);
 }
-function handoffCreate(hippoRoot, flags) {
+function handoffCreate(hippoRoot, tenantId, flags) {
     const summary = String(flags['summary'] ?? '').trim();
     if (!summary) {
         printError('Usage: hippo handoff create --summary "..." [--next "..."] [--session <id>] [--task <id>] [--artifact <path>...] [--constraint <text>...] [--outcome <success|failure|partial>] [--target-runtime <name>] [--card-id <id>] [--tests <pass|fail|unknown>]');
-        process.exit(1);
+        throw new CliExit(1);
     }
     const outcomeRaw = flags['outcome'];
     if (outcomeRaw !== undefined && !isHandoffOutcome(outcomeRaw)) {
         printError(`Invalid outcome: "${String(outcomeRaw)}". Must be one of: success, failure, partial.`);
-        process.exit(1);
+        throw new CliExit(1);
     }
     const sessionId = String(flags['session'] ?? flags['id'] ?? '').trim() || `fallback-${Date.now()}-${process.pid}`;
     const nextAction = String(flags['next'] ?? '').trim() || undefined;
@@ -231,14 +237,14 @@ function handoffCreate(hippoRoot, flags) {
         // parseArgs turns a value-less flag into `true`; refuse rather than store "true".
         if (flags[name] === true) {
             printError(`--${name} needs a value`);
-            process.exit(1);
+            throw new CliExit(1);
         }
     }
     const targetRuntime = String(flags['target-runtime'] ?? '').trim() || undefined;
     const cardId = String(flags['card-id'] ?? '').trim() || undefined;
     const testStatus = String(flags['tests'] ?? '').trim();
     const evidence = collectHandoffEvidence(process.cwd(), testStatus === 'pass' || testStatus === 'fail' ? testStatus : 'unknown');
-    const handoff = saveSessionHandoff(hippoRoot, resolveTenantId({}), {
+    const handoff = saveSessionHandoff(hippoRoot, tenantId, {
         version: 1,
         sessionId,
         repoRoot: process.cwd(),
@@ -275,9 +281,9 @@ function printCreatedHandoff(handoff) {
     if (handoff.evidence)
         console.log(`   Evidence: ${formatHandoffEvidenceLine(handoff.evidence)}`);
 }
-function handoffLatest(hippoRoot, flags) {
+function handoffLatest(hippoRoot, tenantId, flags) {
     const sessionId = String(flags['session'] ?? flags['id'] ?? '').trim() || undefined;
-    const handoff = loadLatestHandoff(hippoRoot, resolveTenantId({}), sessionId);
+    const handoff = loadLatestHandoff(hippoRoot, tenantId, sessionId);
     if (!handoff) {
         if (flags['json']) {
             console.log(JSON.stringify({ handoff: null }));
@@ -293,18 +299,18 @@ function handoffLatest(hippoRoot, flags) {
     }
     printHandoff(handoff);
 }
-function handoffShow(hippoRoot, args, flags) {
+function handoffShow(hippoRoot, tenantId, args, flags) {
     const idArg = args[1];
     if (!idArg) {
         printError('Usage: hippo handoff show <id> [--json]');
-        process.exit(1);
+        throw new CliExit(1);
     }
     const handoffId = parseInt(idArg, 10);
     if (!Number.isFinite(handoffId) || handoffId <= 0) {
         printError(`Invalid handoff ID: ${idArg}`);
-        process.exit(1);
+        throw new CliExit(1);
     }
-    const handoff = loadHandoffById(hippoRoot, resolveTenantId({}), handoffId);
+    const handoff = loadHandoffById(hippoRoot, tenantId, handoffId);
     if (!handoff) {
         if (flags['json']) {
             console.log(JSON.stringify({ handoff: null }));
@@ -320,76 +326,78 @@ function handoffShow(hippoRoot, args, flags) {
     }
     printHandoff(handoff);
 }
-export function cmdHandoff(hippoRoot, args, flags) {
+export function handleHandoff({ hippoRoot, tenantId, args, flags }) {
     requireInit(hippoRoot);
     const subcommand = args[0] ?? 'latest';
     if (subcommand === 'create')
-        return handoffCreate(hippoRoot, flags);
+        return handoffCreate(hippoRoot, tenantId, flags);
     if (subcommand === 'latest')
-        return handoffLatest(hippoRoot, flags);
+        return handoffLatest(hippoRoot, tenantId, flags);
     if (subcommand === 'show')
-        return handoffShow(hippoRoot, args, flags);
+        return handoffShow(hippoRoot, tenantId, args, flags);
     printError('Usage: hippo handoff <create|latest|show>');
-    process.exit(1);
+    throw new CliExit(1);
 }
-export function cmdCurrent(hippoRoot, args, flags) {
-    requireInit(hippoRoot);
-    const subcommand = args[0] ?? 'show';
-    if (subcommand === 'show') {
-        const asJson = Boolean(flags['json']);
-        const snapshot = loadActiveTaskSnapshot(hippoRoot, resolveTenantId({}));
-        const sessionId = snapshot?.session_id ?? undefined;
-        const events = listSessionEvents(hippoRoot, resolveTenantId({}), {
-            session_id: sessionId,
-            limit: 5,
-        });
-        if (asJson) {
-            console.log(JSON.stringify({
-                snapshot: snapshot ?? null,
-                events: events.map((ev) => ({
-                    id: ev.id,
-                    session_id: ev.session_id,
-                    event_type: ev.event_type,
-                    content: ev.content,
-                    created_at: ev.created_at,
-                })),
-            }));
-            return;
-        }
-        if (!snapshot && events.length === 0) {
-            console.log('No active task or recent session events.');
-            return;
-        }
-        console.log('# Current State\n');
-        if (snapshot) {
-            console.log(`Task: ${snapshot.task}`);
-            console.log(`Status: ${snapshot.status} | Source: ${snapshot.source} | Updated: ${snapshot.updated_at}`);
-            if (snapshot.session_id) {
-                console.log(`Session: ${snapshot.session_id}`);
-            }
-            console.log(`Summary: ${snapshot.summary}`);
-            console.log(`Next: ${snapshot.next_step}`);
-        }
-        else {
-            console.log('No active task snapshot.');
+function printCurrentState(snapshot, events) {
+    console.log('# Current State\n');
+    if (snapshot) {
+        console.log(`Task: ${snapshot.task}`);
+        console.log(`Status: ${snapshot.status} | Source: ${snapshot.source} | Updated: ${snapshot.updated_at}`);
+        if (snapshot.session_id) {
+            console.log(`Session: ${snapshot.session_id}`);
         }
-        if (events.length > 0) {
-            console.log('');
-            console.log('Recent events:');
-            for (const ev of events) {
-                const ts = ev.created_at.slice(0, 19).replace('T', ' ');
-                console.log(`  [${ts}] (${ev.event_type}) ${ev.content}`);
-            }
+        console.log(`Summary: ${snapshot.summary}`);
+        console.log(`Next: ${snapshot.next_step}`);
+    }
+    else {
+        console.log('No active task snapshot.');
+    }
+    if (events.length > 0) {
+        console.log('');
+        console.log('Recent events:');
+        for (const ev of events) {
+            const ts = ev.created_at.slice(0, ISO_DATETIME_CHARS).replace('T', ' ');
+            console.log(`  [${ts}] (${ev.event_type}) ${ev.content}`);
         }
+    }
+}
+function currentShow(hippoRoot, tenantId, flags) {
+    const asJson = boolFlag(flags, 'json');
+    const snapshot = loadActiveTaskSnapshot(hippoRoot, tenantId);
+    const sessionId = snapshot?.session_id ?? undefined;
+    const events = listSessionEvents(hippoRoot, tenantId, {
+        session_id: sessionId,
+        limit: 5,
+    });
+    if (asJson) {
+        console.log(JSON.stringify({
+            snapshot: snapshot ?? null,
+            events: events.map((ev) => ({
+                id: ev.id,
+                session_id: ev.session_id,
+                event_type: ev.event_type,
+                content: ev.content,
+                created_at: ev.created_at,
+            })),
+        }));
         return;
     }
+    if (!snapshot && events.length === 0) {
+        console.log('No active task or recent session events.');
+        return;
+    }
+    printCurrentState(snapshot, events);
+}
+export function handleCurrent({ hippoRoot, tenantId, args, flags }) {
+    requireInit(hippoRoot);
+    const subcommand = args[0] ?? 'show';
+    if (subcommand === 'show')
+        return currentShow(hippoRoot, tenantId, flags);
     printError('Usage: hippo current <show>');
-    process.exit(1);
+    throw new CliExit(1);
 }
-// ---------------------------------------------------------------------------
 // Working Memory
-// ---------------------------------------------------------------------------
-export function cmdWm(hippoRoot, args, flags) {
+export function handleWm({ hippoRoot, args, flags }) {
     requireInit(hippoRoot);
     const subcommand = args[0] ?? '';
     if (subcommand === 'push')
@@ -411,7 +419,7 @@ export function cmdWm(hippoRoot, args, flags) {
         return;
     }
     printError('Usage: hippo wm <push|read|clear|flush>');
-    process.exit(1);
+    throw new CliExit(1);
 }
 function wmPushCmd(hippoRoot, flags) {
     const scope = String(flags['scope'] ?? 'default').trim();
@@ -421,7 +429,7 @@ function wmPushCmd(hippoRoot, flags) {
     const taskId = flags['task'] ? String(flags['task']).trim() : undefined;
     if (!content) {
         printError('Usage: hippo wm push --scope <scope> --content "..." [--importance 0.8] [--session <id>] [--task <id>]');
-        process.exit(1);
+        throw new CliExit(1);
     }
     const id = wmPush(hippoRoot, {
         scope,

package/dist/cli/correction-latency.d.ts

@@ -0,0 +1,24 @@
+import { MemoryEntry } from '../core/memory.js';
+export interface CorrectionPair {
+    oldId: string;
+    newId: string;
+    correctedAt: string;
+    observedAt: string;
+    latencyMs: number;
+    /** 'extraction' = new fact derived from a raw receipt; 'manual' = direct supersede call */
+    via: 'extraction' | 'manual';
+}
+export interface CorrectionLatencyReport {
+    count: number;
+    manualCount: number;
+    extractionCount: number;
+    /** Percentiles computed over `extraction` pairs only — manual pairs have no measurable lag */
+    p50Ms: number | null;
+    p95Ms: number | null;
+    maxMs: number | null;
+    pairs: CorrectionPair[];
+}
+/** Correction latency = `new.created` minus the observation time (the extracted-from row's `created`, else `new.created`).
+ * Manual supersedes have latency 0 and are excluded from percentiles so they do not mask real lag. */
+export declare function buildCorrectionLatency(entries: MemoryEntry[]): CorrectionLatencyReport;
+//# sourceMappingURL=correction-latency.d.ts.map

package/dist/{correction-latency.js → cli/correction-latency.js}

@@ -10,20 +10,8 @@ function percentile(sorted, q) {
         return sorted[lo];
     return sorted[lo] + (sorted[hi] - sorted[lo]) * (idx - lo);
 }
-/**
- * Correction latency = wall-clock delta between when hippo first saw the
- * change-of-truth and when the supersession actually landed.
- *
- * For each (old, new) chain via `old.superseded_by = new.id`:
- *   - `correctedAt` = `new.created` (always)
- *   - `observedAt`  = source row's `created` if `new.extracted_from` is set,
- *                     else `new.created` (no earlier observation possible)
- *
- * Pairs split into two cohorts:
- *   - `extraction` — derived from a raw receipt; latency is meaningful
- *   - `manual`     — direct supersede call; latency is trivially 0 and
- *                    excluded from percentiles to avoid masking real lag
- */
+/** Correction latency = `new.created` minus the observation time (the extracted-from row's `created`, else `new.created`).
+ * Manual supersedes have latency 0 and are excluded from percentiles so they do not mask real lag. */
 export function buildCorrectionLatency(entries) {
     const byId = new Map();
     for (const e of entries)

package/dist/cli/curate.d.ts

@@ -1,19 +1,15 @@
-import { type CommandContext } from './shared.js';
-export declare function cmdOutcome(hippoRoot: string, flags: Record<string, string | boolean | string[]>): void;
-export declare function cmdConflicts(hippoRoot: string, flags: Record<string, string | boolean | string[]>): void;
-export declare function cmdResolve(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
-export declare function cmdReject(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
-export declare function cmdRejections(hippoRoot: string, flags: Record<string, string | boolean | string[]>): void;
-export declare function cmdUnreject(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
-/**
- * `hippo dormant [list] [<query>...] [--limit <n>] [--json] [--global]`,
- * `hippo dormant restore <id>`, `hippo dormant forget <id>`.
- * Dormant memories are what sleep keeps instead of deleting (on by default;
- * `"dormant": { "enabled": false }` in .hippo/config.json deletes instead).
- */
-export declare function cmdDormant(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
+import { type CommandContext } from './flag-values.js';
+export declare function handleOutcome({ hippoRoot, tenantId, flags }: CommandContext): void;
+export declare function handleConflicts({ hippoRoot, flags }: CommandContext): void;
+export declare function handleResolve({ hippoRoot, tenantId, args, flags }: CommandContext): Promise<void>;
+export declare function handleReject({ hippoRoot, tenantId, args, flags }: CommandContext): void;
+export declare function handleRejections({ hippoRoot, tenantId, flags }: CommandContext): void;
+export declare function handleUnreject({ hippoRoot, tenantId, args, flags }: CommandContext): void;
+/** `hippo dormant [list|restore <id>|forget <id>]`: dormant memories are what sleep keeps instead of deleting
+ * (on by default; `"dormant": { "enabled": false }` in .hippo/config.json deletes instead). */
+export declare function handleDormant({ hippoRoot, tenantId, args, flags }: CommandContext): void;
 /** `hippo quarantine [list] [--all] [--json] [--global]`, `quarantine approve <id>`, `quarantine reject <id>` (poisoning defence). */
-export declare function cmdQuarantine(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
-export declare function handleForget({ hippoRoot, args, flags }: CommandContext): Promise<void>;
-export declare function handleInvalidate({ hippoRoot, args, flags }: CommandContext): void;
+export declare function handleQuarantine({ hippoRoot, tenantId, args, flags }: CommandContext): Promise<void>;
+export declare function handleForget({ hippoRoot, tenantId, args, flags }: CommandContext): Promise<void>;
+export declare function handleInvalidate({ hippoRoot, tenantId, args, flags }: CommandContext): void;
 //# sourceMappingURL=curate.d.ts.map