hippo-memory 1.69.0 → 1.71.0

package/dist/cli/slack.js

@@ -1,38 +1,35 @@
 // `hippo slack`: backfill, dead-letter queue and workspace registry for the Slack connector.
-import { envSlackBotToken, envSlackSigningSecret, envSlackTeamId } from '../env.js';
-import { openHippoDb, closeHippoDb } from '../db.js';
-import * as api from '../api.js';
-import { resolveTenantId } from '../tenant.js';
-import { listDlq, replayDlqEntry } from '../connectors/slack/dlq.js';
+import { envSlackBotToken, envSlackSigningSecret, envSlackTeamId } from '../util/env.js';
+import * as api from '../api/index.js';
+import { listDlq } from '../connectors/dlq.js';
+import { replayDlqEntry, slackDlq } from '../connectors/slack/dlq.js';
 import { backfillChannel } from '../connectors/slack/backfill.js';
 import { slackHistoryFetcher } from '../connectors/slack/web-client.js';
 import { addWorkspace as addSlackWorkspace, listWorkspaces as listSlackWorkspaces, removeWorkspace as removeSlackWorkspace, } from '../connectors/slack/workspaces.js';
 import { printError } from './output.js';
 import { printSlackBackfillUsage, printSlackWorkspacesUsage } from './usage.js';
-// ---------------------------------------------------------------------------
+import { stringFlag } from './flag-values.js';
+import { CliExit } from './exit.js';
 // Slack subcommands (`hippo slack backfill` / `hippo slack dlq list`)
-// ---------------------------------------------------------------------------
-function cmdSlackBackfill(hippoRoot, flags) {
-    const channel = typeof flags['channel'] === 'string' ? flags['channel'] : undefined;
+function cmdSlackBackfill(hippoRoot, tenantId, flags) {
+    const channel = stringFlag(flags, 'channel');
     if (!channel) {
         printSlackBackfillUsage();
-        process.exit(1);
+        throw new CliExit(1);
     }
     // Real fetcher requires SLACK_BOT_TOKEN with channels:history scope.
     const token = envSlackBotToken();
     if (!token) {
         printError('SLACK_BOT_TOKEN is not set. Backfill requires a Slack bot token with channels:history scope.');
-        process.exit(2);
+        throw new CliExit(2);
     }
-    // --since is advisory in V1: the slack_cursors row drives resume, so the
-    // backfill loop always picks up where it last left off. Honoured-by-cursor
-    // semantics keep idempotency clean.
-    const sinceIso = flags['since'];
+    // --since is advisory in V1: the slack_cursors row drives resume, so the backfill loop always continues where it left off (keeps idempotency clean).
+    const sinceIso = stringFlag(flags, 'since');
     void sinceIso;
     const fetcher = slackHistoryFetcher(token);
     const ctx = {
         hippoRoot,
-        tenantId: resolveTenantId({}),
+        tenantId,
         actor: api.adminActor('cli:slack-backfill'),
     };
     backfillChannel(ctx, {
@@ -48,104 +45,79 @@ function cmdSlackBackfill(hippoRoot, flags) {
         process.exit(3);
     });
 }
-function cmdSlackDlqList(hippoRoot, _flags) {
-    const db = openHippoDb(hippoRoot);
-    try {
-        const tenantId = resolveTenantId({});
-        const items = listDlq(db, { tenantId });
-        for (const it of items) {
-            console.log(`${it.id}\t${it.receivedAt}\t${it.error}`);
-        }
-    }
-    finally {
-        closeHippoDb(db);
+function cmdSlackDlqList(hippoRoot, tenantId, _flags) {
+    const items = listDlq(slackDlq, hippoRoot, { tenantId });
+    for (const it of items) {
+        console.log(`${it.id}\t${it.receivedAt}\t${it.error}`);
     }
 }
-function cmdSlackDlqReplay(hippoRoot, args, flags) {
+async function cmdSlackDlqReplay(hippoRoot, args, flags) {
     const idArg = args[2];
     if (!idArg) {
         printError('Usage: hippo slack dlq replay <id> [--force]');
-        process.exit(1);
+        throw new CliExit(1);
     }
     const id = Number(idArg);
     if (!Number.isFinite(id) || !Number.isInteger(id) || id < 1) {
         printError(`replay: invalid id ${idArg}`);
-        process.exit(1);
+        throw new CliExit(1);
     }
     const force = flags.force === true;
-    const result = replayDlqEntry({ hippoRoot }, id, {
+    const result = await replayDlqEntry({ hippoRoot }, id, {
         force,
         signingSecret: envSlackSigningSecret(),
     });
     if (!result.ok) {
         printError(`replay failed: status=${result.status} retry_count=${result.retryCount}${result.reason ? ` reason=${result.reason}` : ''}`);
-        process.exit(1);
+        throw new CliExit(1);
     }
     console.log(`replay ok: status=${result.status} memory_id=${result.memoryId ?? '(none)'} retry_count=${result.retryCount}`);
 }
 function cmdSlackWorkspacesAdd(hippoRoot, flags) {
-    const teamId = typeof flags['team'] === 'string' ? flags['team'].trim() : '';
-    const tenantId = typeof flags['tenant'] === 'string' ? flags['tenant'].trim() : '';
+    const teamId = (stringFlag(flags, 'team') ?? '').trim();
+    const tenantId = (stringFlag(flags, 'tenant') ?? '').trim();
     if (!teamId || !tenantId) {
         printError('Usage: hippo slack workspaces add --team <T> --tenant <t>');
-        process.exit(1);
-    }
-    const db = openHippoDb(hippoRoot);
-    try {
-        const ws = addSlackWorkspace(db, { teamId, tenantId });
-        console.log(`added: ${ws.teamId} -> ${ws.tenantId} (${ws.addedAt})`);
-    }
-    finally {
-        closeHippoDb(db);
+        throw new CliExit(1);
     }
+    const ws = addSlackWorkspace(hippoRoot, { teamId, tenantId });
+    console.log(`added: ${ws.teamId} -> ${ws.tenantId} (${ws.addedAt})`);
 }
 function cmdSlackWorkspacesList(hippoRoot) {
-    const db = openHippoDb(hippoRoot);
-    try {
-        const items = listSlackWorkspaces(db);
-        if (items.length === 0) {
-            console.log('(no registered workspaces; routing via HIPPO_TENANT fallback)');
-            return;
-        }
-        for (const ws of items) {
-            console.log(`${ws.teamId}\t${ws.tenantId}\t${ws.addedAt}`);
-        }
+    const items = listSlackWorkspaces(hippoRoot);
+    if (items.length === 0) {
+        console.log('(no registered workspaces; routing via HIPPO_TENANT fallback)');
+        return;
     }
-    finally {
-        closeHippoDb(db);
+    for (const ws of items) {
+        console.log(`${ws.teamId}\t${ws.tenantId}\t${ws.addedAt}`);
     }
 }
 function cmdSlackWorkspacesRemove(hippoRoot, flags) {
-    const teamId = typeof flags['team'] === 'string' ? flags['team'].trim() : '';
+    const teamId = (stringFlag(flags, 'team') ?? '').trim();
     if (!teamId) {
         printError('Usage: hippo slack workspaces remove --team <T>');
-        process.exit(1);
-    }
-    const db = openHippoDb(hippoRoot);
-    try {
-        const removed = removeSlackWorkspace(db, teamId);
-        if (!removed) {
-            printError(`no workspace registered for team ${teamId}`);
-            process.exit(1);
-        }
-        console.log(`removed: ${teamId}`);
+        throw new CliExit(1);
     }
-    finally {
-        closeHippoDb(db);
+    const removed = removeSlackWorkspace(hippoRoot, teamId);
+    if (!removed) {
+        printError(`no workspace registered for team ${teamId}`);
+        throw new CliExit(1);
     }
+    console.log(`removed: ${teamId}`);
 }
-export function cmdSlack(hippoRoot, args, flags) {
+export async function handleSlack({ hippoRoot, tenantId, args, flags }) {
     const sub = args[0];
     if (sub === 'backfill') {
-        cmdSlackBackfill(hippoRoot, flags);
+        cmdSlackBackfill(hippoRoot, tenantId, flags);
         return;
     }
     if (sub === 'dlq' && args[1] === 'list') {
-        cmdSlackDlqList(hippoRoot, flags);
+        cmdSlackDlqList(hippoRoot, tenantId, flags);
         return;
     }
     if (sub === 'dlq' && args[1] === 'replay') {
-        cmdSlackDlqReplay(hippoRoot, args, flags);
+        await cmdSlackDlqReplay(hippoRoot, args, flags);
         return;
     }
     if (sub === 'workspaces') {
@@ -163,9 +135,9 @@ export function cmdSlack(hippoRoot, args, flags) {
             return;
         }
         printSlackWorkspacesUsage();
-        process.exit(1);
+        throw new CliExit(1);
     }
     printError('Usage: hippo slack <backfill|dlq list|dlq replay <id> [--force]|workspaces add|workspaces list|workspaces remove> [...]');
-    process.exit(1);
+    throw new CliExit(1);
 }
 //# sourceMappingURL=slack.js.map

package/dist/cli/sleep-render.d.ts

@@ -0,0 +1,4 @@
+import type * as api from '../api/index.js';
+/** The lines `hippo sleep` prints for an api.sleep result; pure, so the snapshot tests read them without a console spy. */
+export declare function sleepResultLines(result: api.SleepResult): string[];
+//# sourceMappingURL=sleep-render.d.ts.map

package/dist/cli/sleep-render.js

@@ -0,0 +1,61 @@
+// The text `hippo sleep` prints for an api.sleep result, kept pure so tests read the lines directly.
+import { renderAmbientSummary } from '../core/ambient.js';
+/** The lines `hippo sleep` prints for an api.sleep result; pure, so the snapshot tests read them without a console spy. */
+export function sleepResultLines(result) {
+    return [...sleepCountLines(result), ...(result.dryRun ? ['\n(dry run  - nothing written)'] : []), ...sleepDedupeAndAuditLines(result), ...sleepShareAndGraphLines(result)];
+}
+function sleepCountLines(result) {
+    const lines = [`Running consolidation${result.dryRun ? ' (dry run)' : ''}...`, `\nResults:`, `   Active memories:  ${result.active}`, `   Removed (decayed): ${result.removed}`];
+    // Only when dormant.enabled moved something, so every other render stays byte-identical.
+    if (result.dormant !== undefined && result.dormant > 0) {
+        lines.push(`   Kept dormant:      ${result.dormant}  (hippo dormant to list)`);
+    }
+    if (result.dormantExpired !== undefined && result.dormantExpired > 0) {
+        lines.push(`   Expired dormant:   ${result.dormantExpired}  (past dormant.retentionDays)`);
+    }
+    lines.push(`   Merged episodic:   ${result.mergedEpisodic}`, `   New semantic:      ${result.newSemantic}`);
+    if (result.details && result.details.length > 0)
+        lines.push('\nDetails:', ...result.details);
+    return lines;
+}
+function sleepDedupeAndAuditLines(result) {
+    const lines = [];
+    if (result.deduped && result.deduped.removed > 0) {
+        const { removed, semDups, epiDups, crossDups } = result.deduped;
+        const parts = [];
+        if (semDups > 0)
+            parts.push(`${semDups} redundant semantic patterns`);
+        if (epiDups > 0)
+            parts.push(`${epiDups} duplicate episodic lessons`);
+        if (crossDups > 0)
+            parts.push(`${crossDups} cross-layer duplicates`);
+        lines.push(`\n${result.dryRun ? 'Would dedupe' : 'Deduped'} ${removed} duplicates (${parts.join(', ')}). ${result.dryRun ? 'Would keep' : 'Kept'} stronger copies.`);
+    }
+    if (result.audit) {
+        if (result.audit.errorsRemoved > 0) {
+            lines.push(`\nAudit: ${result.dryRun ? 'would remove' : 'removed'} ${result.audit.errorsRemoved} junk memories (too short/empty).`);
+        }
+        if (result.audit.warningCount > 0) {
+            lines.push(`Audit: ${result.audit.warningCount} low-quality memories detected (run \`hippo audit\` for details).`);
+        }
+    }
+    return lines;
+}
+function sleepShareAndGraphLines(result) {
+    const lines = [];
+    if (result.shared !== undefined && result.shared > 0) {
+        lines.push(`\nAuto-shared ${result.shared} high-value memories to global store.`);
+    }
+    if (result.secretSkipped !== undefined && result.secretSkipped > 0) {
+        // The secret veto is never silent.
+        lines.push(`\nAuto-share: withheld ${result.secretSkipped} secret-flagged ${result.secretSkipped === 1 ? 'memory' : 'memories'} (secret veto).`);
+    }
+    if (result.ambient)
+        lines.push(`\n${renderAmbientSummary(result.ambient)}`);
+    if (result.graph && result.graph.tenants > 0) {
+        const { tenants, entities, relations } = result.graph;
+        lines.push(`\nGraph: rebuilt ${tenants} tenant${tenants === 1 ? '' : 's'} (${entities} entities, ${relations} relations).`);
+    }
+    return lines;
+}
+//# sourceMappingURL=sleep-render.js.map

package/dist/cli/sleep.d.ts

@@ -1,10 +1,5 @@
-import * as api from '../api.js';
+import { type CliFlags, type CommandContext } from './flag-values.js';
 /** Runs `hippo sleep`; with `--log-file` it also tees its output to that file. */
-export declare function cmdSleep(hippoRoot: string, flags: Record<string, string | boolean | string[]>): Promise<void>;
-/**
- * Render an api.sleep result as console output, byte-identical to the
- * pre-extraction inline implementation in cmdSleepCore.
- */
-/** @internal — exported for snapshot tests (tests/cli-context-render-snapshot.test.ts). NOT a stable public API. */
-export declare function renderSleepResult(result: api.SleepResult): void;
+export declare function cmdSleep(hippoRoot: string, tenantId: string, flags: CliFlags): Promise<void>;
+export declare function handleSleep({ hippoRoot, tenantId, flags }: CommandContext): Promise<void>;
 //# sourceMappingURL=sleep.d.ts.map

package/dist/cli/sleep.js

@@ -1,25 +1,25 @@
 // The `hippo sleep` verb; main() loads it lazily, since most invocations never sleep.
 import * as path from 'path';
 import * as fs from 'fs';
-import { loadConfig } from '../config.js';
-import { isGitRepo } from '../autolearn.js';
+import { loadConfig } from '../core/config.js';
+import { isGitRepo } from '../learn/autolearn.js';
 import { importForStore, currentMachine } from '../agent-memories/sync.js';
-import { replayCompactionsAt } from '../compaction-record.js';
-import * as api from '../api.js';
-import { resolveTenantId } from '../tenant.js';
-import { renderAmbientSummary } from '../ambient.js';
-import { errorMessage, log } from '../log.js';
-import { closeHippoDb, openHippoDb } from '../db.js';
-import { repairOnceOnSleep } from '../project-merge.js';
-import { requireInit, learnFromRepo, runChurnStaleForRepo, printAgentImport, skipLearnOnSharedStore } from './shared.js';
+import { replayCompactionsAt } from '../capture/compaction-record.js';
+import * as api from '../api/index.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 { 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.
-    const logFile = typeof flags['log-file'] === 'string' ? flags['log-file'] : null;
+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 {
@@ -29,17 +29,19 @@ export async function cmdSleep(hippoRoot, flags) {
             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);
+                    const buf = 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
                 }
             };
+            // SAFETY: the wrapper forwards chunk, enc and cb untouched to the original write, so it keeps write's contract.
             process.stdout.write = ((chunk, enc, cb) => {
                 tee(chunk);
                 return origStdoutWrite(chunk, enc, cb);
             });
+            // SAFETY: the wrapper forwards chunk, enc and cb untouched to the original write, so it keeps write's contract.
             process.stderr.write = ((chunk, enc, cb) => {
                 tee(chunk);
                 return origStderrWrite(chunk, enc, cb);
@@ -50,17 +52,17 @@ export async function cmdSleep(hippoRoot, flags) {
             };
         }
         catch (err) {
-            log.warn(`could not open log file ${logFile}: ${err.message}`);
+            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');
     }
     catch (err) {
         if (logFile)
-            console.log(`[hippo] sleep failed: ${err.message}`);
+            console.log(`[hippo] sleep failed: ${errorMessage(err)}`);
         throw err;
     }
     finally {
@@ -68,74 +70,19 @@ export async function cmdSleep(hippoRoot, flags) {
             restoreStdout();
     }
 }
-/**
- * Render an api.sleep result as console output, byte-identical to the
- * pre-extraction inline implementation in cmdSleepCore.
- */
-/** @internal — exported for snapshot tests (tests/cli-context-render-snapshot.test.ts). NOT a stable public API. */
-export function renderSleepResult(result) {
-    console.log(`Running consolidation${result.dryRun ? ' (dry run)' : ''}...`);
-    console.log(`\nResults:`);
-    console.log(`   Active memories:  ${result.active}`);
-    console.log(`   Removed (decayed): ${result.removed}`);
-    // Only when dormant.enabled moved something, so every other render stays
-    // byte-identical (tests/cli-context-render-snapshot.test.ts).
-    if (result.dormant !== undefined && result.dormant > 0) {
-        console.log(`   Kept dormant:      ${result.dormant}  (hippo dormant to list)`);
-    }
-    if (result.dormantExpired !== undefined && result.dormantExpired > 0) {
-        console.log(`   Expired dormant:   ${result.dormantExpired}  (past dormant.retentionDays)`);
-    }
-    console.log(`   Merged episodic:   ${result.mergedEpisodic}`);
-    console.log(`   New semantic:      ${result.newSemantic}`);
-    if (result.details && result.details.length > 0) {
-        console.log('\nDetails:');
-        for (const d of result.details) {
-            console.log(d);
-        }
-    }
-    if (result.dryRun)
-        console.log('\n(dry run  - nothing written)');
-    if (result.deduped && result.deduped.removed > 0) {
-        const { removed, semDups, epiDups, crossDups } = result.deduped;
-        const parts = [];
-        if (semDups > 0)
-            parts.push(`${semDups} redundant semantic patterns`);
-        if (epiDups > 0)
-            parts.push(`${epiDups} duplicate episodic lessons`);
-        if (crossDups > 0)
-            parts.push(`${crossDups} cross-layer duplicates`);
-        console.log(`\n${result.dryRun ? 'Would dedupe' : 'Deduped'} ${removed} duplicates (${parts.join(', ')}). ${result.dryRun ? 'Would keep' : 'Kept'} stronger copies.`);
-    }
-    if (result.audit) {
-        if (result.audit.errorsRemoved > 0) {
-            console.log(`\nAudit: ${result.dryRun ? 'would remove' : 'removed'} ${result.audit.errorsRemoved} junk memories (too short/empty).`);
-        }
-        if (result.audit.warningCount > 0) {
-            console.log(`Audit: ${result.audit.warningCount} low-quality memories detected (run \`hippo audit\` for details).`);
-        }
-    }
-    if (result.shared !== undefined && result.shared > 0) {
-        console.log(`\nAuto-shared ${result.shared} high-value memories to global store.`);
-    }
-    if (result.secretSkipped !== undefined && result.secretSkipped > 0) {
-        // The secret veto is never silent.
-        console.log(`\nAuto-share: withheld ${result.secretSkipped} secret-flagged ${result.secretSkipped === 1 ? 'memory' : 'memories'} (secret veto).`);
-    }
-    if (result.ambient) {
-        console.log(`\n${renderAmbientSummary(result.ambient)}`);
-    }
-    if (result.graph && result.graph.tenants > 0) {
-        const { tenants, entities, relations } = result.graph;
-        console.log(`\nGraph: rebuilt ${tenants} tenant${tenants === 1 ? '' : 's'} (${entities} entities, ${relations} relations).`);
-    }
+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) {
+function repairProjectTagsOnce(hippoRoot, tenantId) {
     let db;
     try {
         db = openHippoDb(hippoRoot);
-        const r = repairOnceOnSleep(db, hippoRoot, resolveTenantId({}));
+        const r = repairOnceOnSleep(db, hippoRoot, tenantId);
         if (r === null)
             return;
         const parts = [
@@ -153,7 +100,7 @@ function repairProjectTagsOnce(hippoRoot) {
             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.
@@ -184,18 +131,14 @@ 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);
+        repairProjectTagsOnce(hippoRoot, tenantId);
         repairQualityOnceAt(hippoRoot);
     }
     // 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: Boolean(flags['dry-run']),
-        noShare: Boolean(flags['no-share']),
+        dryRun: boolFlag(flags, 'dry-run'),
+        noShare: boolFlag(flags, 'no-share'),
     });
     renderSleepResult(result);
 }

package/dist/cli/status.d.ts

@@ -1,18 +1,15 @@
-import { type CommandContext } from './shared.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: Record<string, string | boolean | string[]>): void;
+import { type PhysicsParticle } from '../core/physics.js';
+import { type CommandContext } from './flag-values.js';
+export declare function handleStatus({ hippoRoot }: 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: Record<string, string | boolean | string[]>): void;
+export declare function handleFailures({ hippoRoot, tenantId, flags }: CommandContext): void;
 export declare function handleCorrectionLatency({ hippoRoot, flags }: CommandContext): void;
 export declare function handleProvenance({ hippoRoot, 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