hippo-memory 1.70.0 → 1.72.0

package/dist/cli/sleep.js

@@ -6,57 +6,32 @@ import { isGitRepo } from '../learn/autolearn.js';
 import { importForStore, currentMachine } from '../agent-memories/sync.js';
 import { replayCompactionsAt } from '../capture/compaction-record.js';
 import * as api from '../api/index.js';
-import { resolveTenantId } from '../store/tenant.js';
+import { cliApiContext } from './api-context.js';
 import { sleepResultLines } from './sleep-render.js';
 import { errorMessage, log } from '../util/log.js';
-import { closeHippoDb, openHippoDb } from '../db/index.js';
-import { repairOnceOnSleep } from '../sharing/project-merge.js';
+import { teeStdStreams } from '../util/stream-tee.js';
 import { boolFlag, stringFlag } from './flag-values.js';
 import { requireInit, learnFromRepo, runChurnStaleForRepo, skipLearnOnSharedStore } from './shared.js';
 import { printAgentImport } from './print.js';
 import { repairQualityOnceAt } from './quality-repair-once.js';
 import { printError } from './output.js';
 /** Runs `hippo sleep`; with `--log-file` it also tees its output to that file. */
-export async function cmdSleep(hippoRoot, flags) {
-    // Tee stdout/stderr to a log file when --log-file is set. The SessionEnd
-    // hook uses this so the output is captured somewhere the SessionStart hook
-    // can re-display it next time the agent UI starts.
+export async function cmdSleep(hippoRoot, tenantId, flags) {
+    // Tee stdout/stderr to a log file when --log-file is set; the SessionEnd hook uses it so the SessionStart hook can re-display the output.
     const logFile = stringFlag(flags, 'log-file') ?? null;
     let restoreStdout = null;
     if (logFile) {
         try {
             fs.mkdirSync(path.dirname(logFile), { recursive: true });
             fs.writeFileSync(logFile, `[hippo] ${new Date().toISOString()} consolidating memory...\n`, 'utf8');
-            const origStdoutWrite = process.stdout.write.bind(process.stdout);
-            const origStderrWrite = process.stderr.write.bind(process.stderr);
-            const tee = (chunk) => {
-                try {
-                    const buf = typeof chunk === 'string' ? chunk : Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk);
-                    fs.appendFileSync(logFile, buf, 'utf8');
-                }
-                catch {
-                    // log failures are non-fatal — still write to the real stream
-                }
-            };
-            process.stdout.write = ((chunk, enc, cb) => {
-                tee(chunk);
-                return origStdoutWrite(chunk, enc, cb);
-            });
-            process.stderr.write = ((chunk, enc, cb) => {
-                tee(chunk);
-                return origStderrWrite(chunk, enc, cb);
-            });
-            restoreStdout = () => {
-                process.stdout.write = origStdoutWrite;
-                process.stderr.write = origStderrWrite;
-            };
+            restoreStdout = teeStdStreams(logFile);
         }
         catch (err) {
             log.warn(`could not open log file ${logFile}: ${errorMessage(err)}`);
         }
     }
     try {
-        await cmdSleepCore(hippoRoot, flags);
+        await cmdSleepCore(hippoRoot, tenantId, flags);
         if (logFile)
             console.log('[hippo] sleep complete');
     }
@@ -70,16 +45,17 @@ export async function cmdSleep(hippoRoot, flags) {
             restoreStdout();
     }
 }
+export function handleSleep({ hippoRoot, tenantId, flags }) {
+    return cmdSleep(hippoRoot, tenantId, flags);
+}
 function renderSleepResult(result) {
     for (const line of sleepResultLines(result))
         console.log(line);
 }
 /** Fault-isolated: a failed repair warns and runs again next sleep, and never stops the sleep. */
-function repairProjectTagsOnce(hippoRoot) {
-    let db;
+function repairProjectTagsOnce(hippoRoot, tenantId) {
     try {
-        db = openHippoDb(hippoRoot);
-        const r = repairOnceOnSleep(db, hippoRoot, resolveTenantId({}));
+        const r = api.repairProjectNamesOnce(cliApiContext(hippoRoot, tenantId));
         if (r === null)
             return;
         const parts = [
@@ -92,12 +68,8 @@ function repairProjectTagsOnce(hippoRoot) {
     catch (err) {
         log.warn(`project tag repair skipped, retried next sleep: ${errorMessage(err)}`);
     }
-    finally {
-        if (db)
-            closeHippoDb(db);
-    }
 }
-async function cmdSleepCore(hippoRoot, flags) {
+async function cmdSleepCore(hippoRoot, tenantId, flags) {
     requireInit(hippoRoot);
     // Phase 1: Auto-learn from git and every coding agent's own memories (CLI-only, uses process.cwd() / os.homedir()).
     // Stays in cli.ts; api.sleep covers Phase 2-6 only.
@@ -108,13 +80,13 @@ async function cmdSleepCore(hippoRoot, flags) {
     else if (learn) {
         const config = loadConfig(hippoRoot);
         if (config.autoLearnOnSleep && isGitRepo(process.cwd())) {
-            const { added } = learnFromRepo(hippoRoot, process.cwd(), 1);
+            const { added } = learnFromRepo(hippoRoot, tenantId, process.cwd(), 1);
             if (added > 0)
                 console.log(`Auto-learned ${added} lessons from today's git commits.`);
         }
         // Opt-in code-churn staleness, off by default (config.churnStaleness.enabled).
         if (config.churnStaleness.enabled && isGitRepo(process.cwd())) {
-            for (const { root, result } of runChurnStaleForRepo(hippoRoot, false)) {
+            for (const { root, result } of runChurnStaleForRepo(hippoRoot, tenantId, false)) {
                 if (result.marked > 0)
                     console.log(`Tagged ${result.marked} memories churn-stale in ${root}.`);
                 if (result.error)
@@ -128,15 +100,11 @@ async function cmdSleepCore(hippoRoot, flags) {
         const finished = replayCompactionsAt(hippoRoot, (message) => log.warn(`compaction replay: ${message}`));
         if (finished > 0)
             console.log(`Finished saving ${finished} compaction${finished === 1 ? '' : 's'} left over from earlier sessions.`);
-        repairProjectTagsOnce(hippoRoot);
-        repairQualityOnceAt(hippoRoot);
+        repairProjectTagsOnce(hippoRoot, tenantId);
+        repairQualityOnceAt(hippoRoot, tenantId);
     }
     // Phase 2-6: Pure-storage pipeline (consolidate + dedup + audit + share + ambient).
-    const ctx = {
-        hippoRoot,
-        tenantId: resolveTenantId({}),
-        actor: api.adminActor('cli'),
-    };
+    const ctx = cliApiContext(hippoRoot, tenantId);
     const result = await api.sleep(ctx, {
         dryRun: boolFlag(flags, 'dry-run'),
         noShare: boolFlag(flags, 'no-share'),

package/dist/cli/status.d.ts

@@ -1,18 +1,15 @@
-import { type CliFlags, type CommandContext } from './flag-values.js';
-export declare function cmdStatus(hippoRoot: string): void;
-/**
- * `hippo tokens [--days <n>] [--json] [--global]`: the token ledger.
- * Tokens of memory text handed to agents per surface, blocks
- * the per-prompt hook skipped as unchanged and the tokens that saved,
- * and the hook blocks' tokens later model calls re-read, counted when each session ends.
- * Counts are estimates (characters / 4), the same estimate every budget uses.
- */
-export declare function cmdTokens(hippoRoot: string, flags: CliFlags): void;
+import { type PhysicsParticle } from '../core/physics.js';
+import { type CommandContext } from './flag-values.js';
+export declare function handleStatus({ hippoRoot, tenantId }: CommandContext): void;
+export declare function physicsEnergyText(particles: PhysicsParticle[], gMemory: number): string;
+/** `hippo tokens [--days <n>] [--json] [--global]`: the token ledger per surface, tokens saved by skipped unchanged blocks, and re-read hook tokens.
+ * Counts are estimates (characters / 4), the same estimate every budget uses. */
+export declare function handleTokens({ hippoRoot, tenantId, flags }: CommandContext): void;
 /** `hippo failures [--days <n>] [--json] [--global]`: failed tool calls by outcome, and repeats across sessions. */
-export declare function cmdFailures(hippoRoot: string, flags: CliFlags): void;
-export declare function handleCorrectionLatency({ hippoRoot, flags }: CommandContext): void;
-export declare function handleProvenance({ hippoRoot, flags }: CommandContext): void;
+export declare function handleFailures({ hippoRoot, tenantId, flags }: CommandContext): void;
+export declare function handleCorrectionLatency({ hippoRoot, tenantId, flags }: CommandContext): void;
+export declare function handleProvenance({ hippoRoot, tenantId, flags }: CommandContext): void;
 export declare function handleDoctor({ flags }: CommandContext): void;
 export declare function handleSupportBundle({ flags }: CommandContext): void;
-export declare function handleInspect({ hippoRoot, args }: CommandContext): void;
+export declare function handleInspect({ hippoRoot, tenantId, args }: CommandContext): Promise<void>;
 //# sourceMappingURL=status.d.ts.map

package/dist/cli/status.js

@@ -1,52 +1,47 @@
 // Read-only report verbs: status, inspect, tokens, failures, provenance, correction latency, doctor and support bundle.
 import { envHomeDir } from '../util/env.js';
-import { evalNow } from '../core/ablation.js';
+import { evalNow, strengthAblation } from '../core/ablation.js';
 import * as path from 'path';
 import * as fs from 'fs';
 import * as os from 'os';
 import { fileURLToPath } from 'node:url';
-import { calculateStrength, calculateRewardFactor, resolveConfidence, confidenceFacets, Layer } from '../core/memory.js';
-import { readEntry, loadAllEntries } from '../store/entry-reads.js';
-import { loadStats } from '../store/index-and-stats.js';
-import { listMemoryConflicts } from '../store/conflicts.js';
-import { loadEmbeddingIndex, embeddingModelRequiresReindex } from '../store/embeddings/index.js';
-import { resolveEmbeddingProvider } from '../store/embeddings/provider.js';
-import { loadStoredParticles } from '../store/vector-writes.js';
+import { calculateStrength, calculateRewardFactor, resolveConfidence, Layer } from '../core/memory.js';
+import { resolveEmbeddingProvider } from '../embeddings/provider.js';
 import { computeSystemEnergy, vecNorm } from '../core/physics.js';
 import { loadConfig } from '../core/config.js';
 import { runDoctor, formatDoctor } from '../doctor.js';
 import { buildSupportBundle, TAIL_MAX_LINES } from '../support-bundle.js';
 import { PACKAGE_VERSION } from '../util/version.js';
 import { FAILURE_LOG_RETENTION_DAYS } from '../store/failure-log.js';
-import { getGlobalRoot } from '../sharing/shared.js';
-import { buildProvenanceCoverage } from './provenance-coverage.js';
-import { buildCorrectionLatency } from './correction-latency.js';
+import { getGlobalRoot } from '../sharing/global-store.js';
 import * as api from '../api/index.js';
-import { resolveTenantId } from '../store/tenant.js';
+import { getMemory } from '../api/memories.js';
+import { correctionLatencyReport, embeddingReindexNeeded, provenanceCoverageReport, storeStatus, storedParticles, vectorSummary, } from '../api/status.js';
+import { cliApiContext } from './api-context.js';
 import { errorMessage, log } from '../util/log.js';
 import { printError } from './output.js';
 import { parseCountFlag, stringFlagOrExit, flagIsTrue } from './flag-values.js';
 import { requireInit, resolveAuthRoot } from './shared.js';
 import { fmt } from './print.js';
+import { isJsonObject } from '../util/json.js';
 import { hookStoreRoot } from './hook-runtime.js';
-import { DAY_MS } from '../util/time.js';
-export function cmdStatus(hippoRoot) {
+import { DAY_MS, HOUR_MS, MINUTE_MS } from '../util/time.js';
+import { CliExit } from './exit.js';
+export function handleStatus({ hippoRoot, tenantId }) {
     requireInit(hippoRoot);
-    const entries = loadAllEntries(hippoRoot);
-    const stats = loadStats(hippoRoot);
-    const now = evalNow();
-    const { byLayer, byConfidence, pinned, atRisk, agedOut, avgStrength } = tallyStatus(entries, now);
+    const ctx = cliApiContext(hippoRoot, tenantId);
+    const { stats, counts } = storeStatus(ctx, evalNow(), 0.2);
+    const { byLayer, byConfidence, pinned, atRisk, agedOut, avgStrength } = counts;
     console.log('Hippo Status');
     console.log('---------------------------');
-    console.log(`Total memories:    ${entries.length}`);
+    console.log(`Total memories:    ${counts.total}`);
     console.log(`  Buffer:          ${byLayer[Layer.Buffer]}`);
     console.log(`  Episodic:        ${byLayer[Layer.Episodic]}`);
     console.log(`  Semantic:        ${byLayer[Layer.Semantic]}`);
     console.log(`  Trace:           ${byLayer[Layer.Trace]}`);
-    const conflictCount = listMemoryConflicts(hippoRoot).length;
     console.log(`Pinned:            ${pinned}`);
     console.log(`At risk (<0.2):    ${atRisk}`);
-    console.log(`Open conflicts:    ${conflictCount}`);
+    console.log(`Open conflicts:    ${counts.openConflicts}`);
     console.log(`Avg strength:      ${fmt(avgStrength)}`);
     console.log('');
     console.log('Confidence breakdown:');
@@ -56,58 +51,25 @@ export function cmdStatus(hippoRoot) {
     console.log(`  Stale:           ${byConfidence['stale'] ?? 0}`);
     console.log(`  Aged out:        ${agedOut}  (of the above; excludes pinned, verified)`);
     console.log('');
-    console.log(`Total remembered:  ${stats['total_remembered'] ?? 0}`);
-    console.log(`Total recalled:    ${stats['total_recalled'] ?? 0}`);
-    console.log(`Total forgotten:   ${stats['total_forgotten'] ?? 0}`);
-    const runs = stats['consolidation_runs'] ?? [];
+    console.log(`Total remembered:  ${stats.total_remembered ?? 0}`);
+    console.log(`Total recalled:    ${stats.total_recalled ?? 0}`);
+    console.log(`Total forgotten:   ${stats.total_forgotten ?? 0}`);
+    const runs = stats.consolidation_runs ?? [];
     if (Array.isArray(runs) && runs.length > 0) {
         const last = runs[runs.length - 1];
-        console.log(`Last sleep:        ${last['timestamp']}`);
+        console.log(`Last sleep:        ${isJsonObject(last) ? last['timestamp'] : undefined}`);
     }
     else {
         console.log(`Last sleep:        never`);
     }
-    printEmbeddingStatus(hippoRoot, entries);
-    printPhysicsStatus(hippoRoot);
-}
-function tallyStatus(entries, now) {
-    const byLayer = {
-        [Layer.Buffer]: 0,
-        [Layer.Episodic]: 0,
-        [Layer.Semantic]: 0,
-        [Layer.Trace]: 0,
-    };
-    const byConfidence = {
-        verified: 0,
-        observed: 0,
-        inferred: 0,
-        stale: 0,
-    };
-    let totalStrength = 0;
-    let pinned = 0;
-    let atRisk = 0; // strength < 0.2
-    let agedOut = 0;
-    for (const e of entries) {
-        const s = calculateStrength(e, now);
-        byLayer[e.layer] = (byLayer[e.layer] ?? 0) + 1;
-        totalStrength += s;
-        if (e.pinned)
-            pinned++;
-        if (s < 0.2)
-            atRisk++;
-        const facets = confidenceFacets(e, now);
-        byConfidence[facets.tier] = (byConfidence[facets.tier] ?? 0) + 1;
-        if (facets.agedOut)
-            agedOut++;
-    }
-    const avgStrength = entries.length > 0 ? totalStrength / entries.length : 0;
-    return { byLayer, byConfidence, pinned, atRisk, agedOut, avgStrength };
+    printEmbeddingStatus(ctx, counts);
+    printPhysicsStatus(ctx);
 }
 // Embedding status (provider-aware)
-function printEmbeddingStatus(hippoRoot, entries) {
+function printEmbeddingStatus(ctx, counts) {
     const embedProvider = (() => {
         try {
-            return resolveEmbeddingProvider(hippoRoot);
+            return resolveEmbeddingProvider(ctx.hippoRoot);
         }
         catch {
             // Status reports a bad provider config as "misconfigured" below instead of failing.
@@ -119,7 +81,7 @@ function printEmbeddingStatus(hippoRoot, entries) {
         console.log(`Embeddings:        misconfigured (check embeddings.provider / apiBaseUrl), BM25 only`);
         return;
     }
-    const embeddingsDisabled = loadConfig(hippoRoot).embeddings.enabled === false;
+    const embeddingsDisabled = loadConfig(ctx.hippoRoot).embeddings.enabled === false;
     const embAvail = embedProvider.isAvailable();
     if (embeddingsDisabled) {
         console.log(`Embeddings:        disabled in config (embeddings.enabled = false), BM25 only`);
@@ -135,36 +97,35 @@ function printEmbeddingStatus(hippoRoot, entries) {
     }
     // Show cached counts whenever vectors exist on disk (even when disabled or
     // the key was removed), so the user still sees what is already indexed.
-    const embIndex = loadEmbeddingIndex(hippoRoot);
-    if (!embAvail && Object.keys(embIndex).length === 0)
+    const { ids: embeddedIds, dims } = vectorSummary(ctx);
+    if (!embAvail && embeddedIds.size === 0)
         return;
-    const activeIds = new Set(entries.map((e) => e.id));
-    const activeEmbedded = Object.keys(embIndex).filter((id) => activeIds.has(id)).length;
-    const orphaned = Object.keys(embIndex).length - activeEmbedded;
-    const dims = Object.values(embIndex)[0]?.length;
-    let line = `Embedded:          ${activeEmbedded}/${entries.length} memories`;
+    const orphaned = embeddedIds.size - counts.embedded;
+    let line = `Embedded:          ${counts.embedded}/${counts.total} memories`;
     if (dims)
         line += ` (${dims}-dim)`;
     if (orphaned > 0)
         line += ` (${orphaned} orphaned, run \`hippo embed\` to prune)`;
     console.log(line);
-    if (embeddingModelRequiresReindex(hippoRoot, embedProvider.id, embIndex)) {
+    // No index argument: the check then asks SQLite whether any vector exists instead of loading them.
+    if (embeddingReindexNeeded(ctx, embedProvider.id)) {
         console.log(`                   model changed, run \`hippo embed\` to reindex`);
     }
 }
+// The all-pairs energy sum is quadratic, so a large particle set skips it.
+const PHYSICS_ENERGY_STATUS_MAX = 2000;
 // Physics status
-function printPhysicsStatus(hippoRoot) {
+function printPhysicsStatus(ctx) {
     try {
-        const particles = loadStoredParticles(hippoRoot);
+        const particles = storedParticles(ctx);
         if (particles.length > 0) {
-            const physConfig = loadConfig(hippoRoot);
-            const energy = computeSystemEnergy(particles, physConfig.physics.G_memory);
             let sumVelMag = 0;
             for (const p of particles)
                 sumVelMag += vecNorm(p.velocity);
             const avgVelMag = sumVelMag / particles.length;
             console.log('');
-            console.log(`Physics: ${particles.length} particles, energy: ${fmt(energy.total, 4)} (KE: ${fmt(energy.kinetic, 4)}, PE: ${fmt(energy.potential, 4)}), avg vel: ${fmt(avgVelMag, 4)}`);
+            console.log(`Physics: ${particles.length} particles, ` +
+                `${physicsEnergyText(particles, loadConfig(ctx.hippoRoot).physics.G_memory)}, avg vel: ${fmt(avgVelMag, 4)}`);
         }
     }
     catch (err) {
@@ -172,15 +133,21 @@ function printPhysicsStatus(hippoRoot) {
         log.debug(`physics status skipped: ${errorMessage(err)}`);
     }
 }
-function cmdInspect(hippoRoot, id) {
+export function physicsEnergyText(particles, gMemory) {
+    if (particles.length > PHYSICS_ENERGY_STATUS_MAX)
+        return `energy: skipped (${particles.length} particles)`;
+    const energy = computeSystemEnergy(particles, gMemory);
+    return `energy: ${fmt(energy.total, 4)} (KE: ${fmt(energy.kinetic, 4)}, PE: ${fmt(energy.potential, 4)})`;
+}
+async function cmdInspect(hippoRoot, tenantId, id) {
     requireInit(hippoRoot);
-    const entry = readEntry(hippoRoot, id, resolveTenantId({}));
+    const entry = await getMemory(cliApiContext(hippoRoot, tenantId), id);
     if (!entry) {
         printError(`Memory not found: ${id}`);
-        process.exit(1);
+        throw new CliExit(1);
     }
     const now = evalNow();
-    const currentStrength = calculateStrength(entry, now);
+    const currentStrength = calculateStrength(entry, now, { ablation: strengthAblation() });
     const lastRetrieved = new Date(entry.last_retrieved);
     const created = new Date(entry.created);
     const ageDays = (now.getTime() - created.getTime()) / DAY_MS;
@@ -199,7 +166,7 @@ function cmdInspect(hippoRoot, id) {
     console.log(`Schema fit:       ${entry.schema_fit}`);
     console.log(`Pinned:           ${entry.pinned}`);
     console.log(`Tags:             ${entry.tags.join(', ') || 'none'}`);
-    const rewardFactor = calculateRewardFactor(entry);
+    const rewardFactor = calculateRewardFactor(entry, strengthAblation());
     const pos = entry.outcome_positive ?? 0;
     const neg = entry.outcome_negative ?? 0;
     const outcomeLabel = pos === 0 && neg === 0
@@ -214,20 +181,11 @@ function cmdInspect(hippoRoot, id) {
     console.log('-'.repeat(40));
     console.log(entry.content);
 }
-/**
- * `hippo tokens [--days <n>] [--json] [--global]`: the token ledger.
- * Tokens of memory text handed to agents per surface, blocks
- * the per-prompt hook skipped as unchanged and the tokens that saved,
- * and the hook blocks' tokens later model calls re-read, counted when each session ends.
- * Counts are estimates (characters / 4), the same estimate every budget uses.
- */
-export function cmdTokens(hippoRoot, flags) {
+/** `hippo tokens [--days <n>] [--json] [--global]`: the token ledger per surface, tokens saved by skipped unchanged blocks, and re-read hook tokens.
+ * Counts are estimates (characters / 4), the same estimate every budget uses. */
+export function handleTokens({ hippoRoot, tenantId, flags }) {
     const root = resolveAuthRoot(hippoRoot, flags);
-    const ctx = {
-        hippoRoot: root,
-        tenantId: resolveTenantId({}),
-        actor: api.adminActor('cli'),
-    };
+    const ctx = cliApiContext(root, tenantId);
     const days = parseCountFlag(flags['days']);
     const summary = api.tokenSummary(ctx, { days: days > 0 ? days : undefined });
     if (flags['json']) {
@@ -257,15 +215,11 @@ export function cmdTokens(hippoRoot, flags) {
     console.log("  Re-reads usually bill at the provider's cached-input rate, a fraction of the full input price.");
 }
 /** `hippo failures [--days <n>] [--json] [--global]`: failed tool calls by outcome, and repeats across sessions. */
-export function cmdFailures(hippoRoot, flags) {
+export function handleFailures({ hippoRoot, tenantId, flags }) {
     // The store the capture-error hook writes to; a report never creates one.
     const root = flags['global'] ? getGlobalRoot() : hookStoreRoot(hippoRoot);
     requireInit(root);
-    const ctx = {
-        hippoRoot: root,
-        tenantId: resolveTenantId({}),
-        actor: api.adminActor('cli'),
-    };
+    const ctx = cliApiContext(root, tenantId);
     const days = parseCountFlag(flags['days']);
     const summary = api.failureSummary(ctx, { days: days > 0 ? days : undefined });
     if (flags['json']) {
@@ -298,10 +252,9 @@ export function cmdFailures(hippoRoot, flags) {
         console.log(`\n  Repeats: ${summary.repeats} of ${summary.rated} errors first happened in another session.${unrated}`);
     }
 }
-export function handleCorrectionLatency({ hippoRoot, flags }) {
+export function handleCorrectionLatency({ hippoRoot, tenantId, flags }) {
     requireInit(hippoRoot);
-    const entries = loadAllEntries(hippoRoot);
-    const report = buildCorrectionLatency(entries);
+    const report = correctionLatencyReport(cliApiContext(hippoRoot, tenantId));
     if (flags['json']) {
         console.log(JSON.stringify(report, null, 2));
     }
@@ -314,11 +267,11 @@ export function handleCorrectionLatency({ hippoRoot, flags }) {
                 return 'n/a';
             if (ms < 1000)
                 return `${ms}ms`;
-            if (ms < 60_000)
+            if (ms < MINUTE_MS)
                 return `${(ms / 1000).toFixed(1)}s`;
-            if (ms < 3_600_000)
-                return `${(ms / 60_000).toFixed(1)}m`;
-            return `${(ms / 3_600_000).toFixed(1)}h`;
+            if (ms < HOUR_MS)
+                return `${(ms / MINUTE_MS).toFixed(1)}m`;
+            return `${(ms / HOUR_MS).toFixed(1)}h`;
         };
         console.log(`Corrections: ${report.count} total (${report.extractionCount} extraction-driven, ${report.manualCount} manual)`);
         console.log(`Latency p50: ${fmt(report.p50Ms)}, p95: ${fmt(report.p95Ms)}, max: ${fmt(report.maxMs)}`);
@@ -328,10 +281,9 @@ export function handleCorrectionLatency({ hippoRoot, flags }) {
         }
     }
 }
-export function handleProvenance({ hippoRoot, flags }) {
+export function handleProvenance({ hippoRoot, tenantId, flags }) {
     requireInit(hippoRoot);
-    const entries = loadAllEntries(hippoRoot);
-    const coverage = buildProvenanceCoverage(entries);
+    const coverage = provenanceCoverageReport(cliApiContext(hippoRoot, tenantId));
     if (flags['json']) {
         console.log(JSON.stringify(coverage, null, 2));
     }
@@ -349,7 +301,7 @@ export function handleProvenance({ hippoRoot, flags }) {
         }
     }
     if (flags['strict'] && coverage.coverage < 1) {
-        process.exit(1);
+        throw new CliExit(1);
     }
 }
 export function handleDoctor({ flags }) {
@@ -358,13 +310,13 @@ export function handleDoctor({ flags }) {
     const report = runDoctor({ version: pkg.version });
     console.log(flags['json'] ? JSON.stringify(report, null, 2) : formatDoctor(report));
     if (!report.ok)
-        process.exit(1);
+        throw new CliExit(1);
 }
 export function handleSupportBundle({ flags }) {
     const outFlag = stringFlagOrExit(flags, 'out');
     if (outFlag === '') {
         printError('--out requires a file path.');
-        process.exit(1);
+        throw new CliExit(1);
     }
     const includeLogs = flagIsTrue(flags, 'include-logs');
     const home = envHomeDir() || os.homedir();
@@ -383,20 +335,22 @@ export function handleSupportBundle({ flags }) {
         else {
             printError(errorMessage(err));
         }
-        process.exit(1);
+        throw new CliExit(1);
     }
     const kb = Math.round(Buffer.byteLength(json) / 1024);
     console.log(`Wrote ${file} (${kb} KB).`);
     console.log(includeLogs
-        ? `It holds versions, doctor checks, config with secrets removed, store counts, and the last ${TAIL_MAX_LINES} lines of each hippo log with known secret shapes removed. Those log lines can quote memory text. Read it before you attach it to a ticket.`
-        : 'It holds versions, doctor checks, config with secrets removed, store counts and log file names. It never holds memory text. Read it before you attach it to a ticket.');
+        ? `It holds versions, doctor checks, config with secrets removed, store counts, and the last ${TAIL_MAX_LINES} lines of ` +
+            'each hippo log with known secret shapes removed. Those log lines can quote memory text. Read it before you attach it to a ticket.'
+        : 'It holds versions, doctor checks, config with secrets removed, store counts and log file names. It never holds memory text. Read it before you ' +
+            'attach it to a ticket.');
 }
-export function handleInspect({ hippoRoot, args }) {
+export async function handleInspect({ hippoRoot, tenantId, args }) {
     const id = args[0];
     if (!id) {
         printError('Please provide a memory ID.');
-        process.exit(1);
+        throw new CliExit(1);
     }
-    cmdInspect(hippoRoot, id);
+    await cmdInspect(hippoRoot, tenantId, id);
 }
 //# sourceMappingURL=status.js.map

package/dist/cli/stdin.d.ts

@@ -1,13 +1,11 @@
-/** `timedOut` means the window closed with stdin still open, so absent
- * `text` is "unknown", not "none", and present `text` may be truncated.
- * Treating absence as a manual run is only safe when it is false. */
+/** `timedOut` means the window closed with stdin still open, so absent `text` is "unknown", not "none", and present `text` may be truncated;
+ * treating absence as a manual run is only safe when it is false. */
 export interface BoundedStdin {
     text?: string;
     timedOut: boolean;
 }
-/** Never blocks: a TTY resolves at once, otherwise waits up to `waitMs` of
- * idle (default 1000ms, or `HIPPO_STDIN_WAIT_MS`), refreshed on each chunk
- * so a slow but real write is not cut off, and capped at `waitMs * 10`. */
+/** Never blocks: a TTY resolves at once, otherwise waits up to `waitMs` of idle (default 1000ms, or `HIPPO_STDIN_WAIT_MS`),
+ * refreshed on each chunk so a slow real write is not cut off, capped at `waitMs * 10`. */
 export declare function readStdinBounded(waitMs?: number): Promise<BoundedStdin>;
 /** A hook payload with Copilot's camelCase fields copied to the snake_case keys hippo reads. The camelCase keys stay,
  * so the sessionStart reply can follow the sender's casing; text that needs no change comes back exactly as sent. */

package/dist/cli/stdin.js

@@ -4,9 +4,8 @@ const DEFAULT_STDIN_WAIT_MS = 1000;
 function defaultWaitMs() {
     return envStdinWaitMs() ?? DEFAULT_STDIN_WAIT_MS;
 }
-/** Never blocks: a TTY resolves at once, otherwise waits up to `waitMs` of
- * idle (default 1000ms, or `HIPPO_STDIN_WAIT_MS`), refreshed on each chunk
- * so a slow but real write is not cut off, and capped at `waitMs * 10`. */
+/** Never blocks: a TTY resolves at once, otherwise waits up to `waitMs` of idle (default 1000ms, or `HIPPO_STDIN_WAIT_MS`),
+ * refreshed on each chunk so a slow real write is not cut off, capped at `waitMs * 10`. */
 export function readStdinBounded(waitMs = defaultWaitMs()) {
     let stdin;
     try {

package/dist/cli/transfer.d.ts

@@ -1,10 +1,10 @@
-import { type CliFlags, type CommandContext } from './flag-values.js';
-export declare function cmdLearn(hippoRoot: string, flags: CliFlags): void;
-export declare function cmdImport(hippoRoot: string, args: string[], flags: CliFlags): void;
-export declare function cmdSync(hippoRoot: string, flags?: CliFlags): void;
-export declare function handleWatch({ hippoRoot, args }: CommandContext): Promise<void>;
-export declare function handlePromote({ hippoRoot, args }: CommandContext): Promise<void>;
-export declare function handleShare({ hippoRoot, args, flags }: CommandContext): void;
-export declare function handlePeers({ flags }: CommandContext): void;
-export declare function handleExport({ hippoRoot, args, flags }: CommandContext): void;
+import { type CommandContext } from './flag-values.js';
+export declare function handleLearn({ hippoRoot, tenantId, flags }: CommandContext): void;
+export declare function handleImport({ hippoRoot, tenantId, args, flags }: CommandContext): void;
+export declare function handleSync({ hippoRoot, flags }: CommandContext): void;
+export declare function handleWatch({ hippoRoot, tenantId, args }: CommandContext): Promise<void>;
+export declare function handlePromote({ hippoRoot, tenantId, args }: CommandContext): Promise<void>;
+export declare function handleShare({ hippoRoot, tenantId, args, flags }: CommandContext): Promise<void>;
+export declare function handlePeers({ tenantId, flags }: CommandContext): void;
+export declare function handleExport({ hippoRoot, tenantId, args, flags }: CommandContext): void;
 //# sourceMappingURL=transfer.d.ts.map