hippo-memory 2.0.0 → 2.1.0

package/dist/cli/shared.js

@@ -10,17 +10,23 @@ import * as client from './client.js';
 import { detectServer, removePidfileIfOwned } from '../server/server-detect.js';
 import { learn, CLI_LEARN } from '../api/index.js';
 import { cliApiContext } from './api-context.js';
-import { errorMessage, log } from '../util/log.js';
+import { errorMessage, log, errorFields } from '../util/log.js';
 import { printError } from './output.js';
 export function requireInit(hippoRoot) {
     if (!isInitialized(hippoRoot)) {
-        printError(`No hippo store at ${hippoRoot} (searched ${process.cwd()} and its parents up to your home directory). Run \`hippo init\` first.`);
+        printError(`No hippo store at ${hippoRoot} (searched ${process.cwd()} and its parents up to your home directory). Run ` +
+            `\`hippo init\` first.`);
         process.exit(1);
     }
 }
 /** Runs detectChurnStale against every store this repo's memories can live in. */
 export function runChurnStaleForRepo(hippoRoot, tenantId, dryRun) {
-    const repoRoot = execFileSync('git', ['rev-parse', '--show-toplevel'], { cwd: process.cwd(), encoding: 'utf8', timeout: 10_000, windowsHide: true }).trim();
+    const repoRoot = execFileSync('git', ['rev-parse', '--show-toplevel'], {
+        cwd: process.cwd(),
+        encoding: 'utf8',
+        timeout: 10_000,
+        windowsHide: true,
+    }).trim();
     const { name: projectName, legacyName } = resolveProjectIdentity(process.cwd());
     const globalRoot = getGlobalRoot();
     const roots = globalRoot !== hippoRoot && isInitialized(globalRoot) ? [hippoRoot, globalRoot] : [hippoRoot];
@@ -31,11 +37,16 @@ export function runChurnStaleForRepo(hippoRoot, tenantId, dryRun) {
         }
         catch (err) {
             const message = errorMessage(err);
-            return { root, result: { checked: 0, marked: 0, alreadyMarked: 0, skippedPinned: [], dryRun, preview: [], error: message } };
+            return {
+                root,
+                result: { checked: 0, marked: 0, alreadyMarked: 0, skippedPinned: [], dryRun, preview: [], error: message },
+            };
         }
     });
 }
-/** With HIPPO_REQUIRE_SERVER set, throw rather than fall back to direct DB mode, which would mask a misconfiguration and discard HIPPO_API_KEY.
+/**
+ * With HIPPO_REQUIRE_SERVER set, throw rather than fall back to direct DB mode, which would mask a misconfiguration and
+ * discard HIPPO_API_KEY.
  * Guards only the routed writes (remember, forget, archive, promote). */
 function failIfServerRequired(reason) {
     if (envRequireServer()) {
@@ -43,7 +54,9 @@ function failIfServerRequired(reason) {
             `Start \`hippo serve\`, or unset HIPPO_REQUIRE_SERVER to allow direct-mode fallback.`);
     }
 }
-/** Run an HTTP-routed command if a `hippo serve` is detected: true if it ran, false on no server or a stale pidfile (removed if it names the dead server).
+/**
+ * Run an HTTP-routed command if a `hippo serve` is detected: true if it ran, false on no server or a stale pidfile
+ * (removed if it names the dead server).
  * With HIPPO_REQUIRE_SERVER set both fallbacks throw; a stale pidfile must self-heal, not crash. */
 export async function runViaServerIfAvailable(hippoRoot, httpFn) {
     const info = await detectServer(hippoRoot);
@@ -60,16 +73,18 @@ export async function runViaServerIfAvailable(hippoRoot, httpFn) {
         const failure = err instanceof Error ? client.classifyTransportFailure(err) : 'none';
         if (failure === 'never-sent') {
             failIfServerRequired('the server pidfile was stale (connection refused)');
-            log.warn('stale server pidfile detected, falling back to direct mode');
+            log.warn('stale server pidfile detected, falling back to direct mode', errorFields(err));
             // Clear the pidfile only if it still names the dead server we just
             // probed — a newer server may have rewritten it (removePidfileIfOwned).
             removePidfileIfOwned(hippoRoot, { pid: info.pid, startedAt: info.started_at });
             return false;
         }
         if (failure === 'delivery-unknown') {
-            // Every caller is a non-idempotent write, so replaying on the direct path would store a row the server may already have committed;
+            // Every caller is a non-idempotent write, so replaying on the direct path would store a row the server may
+            // already have committed;
             // leave the pidfile alone: the next command's connect-phase failure heals it.
-            printError(`hippo: the connection to ${info.url} dropped or timed out mid-request, so the write may already have been applied. ` +
+            printError(`hippo: the connection to ${info.url} dropped or timed out mid-request, so the write may already have been ` +
+                `applied. ` +
                 'Not retrying locally. Check with `hippo recall` before running this again.');
             process.exit(1);
         }

package/dist/cli/slack.js

@@ -9,7 +9,8 @@ import { addWorkspace as addSlackWorkspace, listWorkspaces as listSlackWorkspace
 import { printError } from './output.js';
 import { printSlackBackfillUsage, printSlackWorkspacesUsage } from './usage.js';
 import { stringFlag } from './flag-values.js';
-import { CliExit } from './exit.js';
+import { cliApiContext } from './api-context.js';
+import { CliExit, fail } from './exit.js';
 // Slack subcommands (`hippo slack backfill` / `hippo slack dlq list`)
 function cmdSlackBackfill(hippoRoot, tenantId, flags) {
     const channel = stringFlag(flags, 'channel');
@@ -23,15 +24,12 @@ function cmdSlackBackfill(hippoRoot, tenantId, flags) {
         printError('SLACK_BOT_TOKEN is not set. Backfill requires a Slack bot token with channels:history scope.');
         throw new CliExit(2);
     }
-    // --since is advisory in V1: the slack_cursors row drives resume, so the backfill loop always continues where it left off (keeps idempotency clean).
+    // --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,
-        actor: api.adminActor('cli:slack-backfill'),
-    };
+    const ctx = { ...cliApiContext(hippoRoot, tenantId), actor: api.adminActor('cli:slack-backfill') };
     backfillChannel(ctx, {
         teamId: envSlackTeamId() ?? 'T_UNKNOWN',
         channel: { id: channel, is_private: false },
@@ -51,25 +49,22 @@ function cmdSlackDlqList(hippoRoot, tenantId, _flags) {
         console.log(`${it.id}\t${it.receivedAt}\t${it.error}`);
     }
 }
-async function cmdSlackDlqReplay(hippoRoot, args, flags) {
+async function cmdSlackDlqReplay(hippoRoot, tenantId, args, flags) {
     const idArg = args[2];
     if (!idArg) {
-        printError('Usage: hippo slack dlq replay <id> [--force]');
-        throw new CliExit(1);
+        fail('Usage: hippo slack dlq replay <id> [--force]');
     }
     const id = Number(idArg);
     if (!Number.isFinite(id) || !Number.isInteger(id) || id < 1) {
-        printError(`replay: invalid id ${idArg}`);
-        throw new CliExit(1);
+        fail(`replay: invalid id ${idArg}`);
     }
     const force = flags.force === true;
-    const result = await replayDlqEntry({ hippoRoot }, id, {
+    const result = await replayDlqEntry(cliApiContext(hippoRoot, tenantId), id, {
         force,
         signingSecret: envSlackSigningSecret(),
     });
     if (!result.ok) {
-        printError(`replay failed: status=${result.status} retry_count=${result.retryCount}${result.reason ? ` reason=${result.reason}` : ''}`);
-        throw new CliExit(1);
+        fail(`replay failed: status=${result.status} retry_count=${result.retryCount}${result.reason ? ` reason=${result.reason}` : ''}`);
     }
     console.log(`replay ok: status=${result.status} memory_id=${result.memoryId ?? '(none)'} retry_count=${result.retryCount}`);
 }
@@ -77,8 +72,7 @@ function cmdSlackWorkspacesAdd(hippoRoot, flags) {
     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>');
-        throw new CliExit(1);
+        fail('Usage: hippo slack workspaces add --team <T> --tenant <t>');
     }
     const ws = addSlackWorkspace(hippoRoot, { teamId, tenantId });
     console.log(`added: ${ws.teamId} -> ${ws.tenantId} (${ws.addedAt})`);
@@ -96,13 +90,11 @@ function cmdSlackWorkspacesList(hippoRoot) {
 function cmdSlackWorkspacesRemove(hippoRoot, flags) {
     const teamId = (stringFlag(flags, 'team') ?? '').trim();
     if (!teamId) {
-        printError('Usage: hippo slack workspaces remove --team <T>');
-        throw new CliExit(1);
+        fail('Usage: hippo slack workspaces remove --team <T>');
     }
     const removed = removeSlackWorkspace(hippoRoot, teamId);
     if (!removed) {
-        printError(`no workspace registered for team ${teamId}`);
-        throw new CliExit(1);
+        fail(`no workspace registered for team ${teamId}`);
     }
     console.log(`removed: ${teamId}`);
 }
@@ -117,7 +109,7 @@ export async function handleSlack({ hippoRoot, tenantId, args, flags }) {
         return;
     }
     if (sub === 'dlq' && args[1] === 'replay') {
-        await cmdSlackDlqReplay(hippoRoot, args, flags);
+        await cmdSlackDlqReplay(hippoRoot, tenantId, args, flags);
         return;
     }
     if (sub === 'workspaces') {
@@ -137,7 +129,6 @@ export async function handleSlack({ hippoRoot, tenantId, args, flags }) {
         printSlackWorkspacesUsage();
         throw new CliExit(1);
     }
-    printError('Usage: hippo slack <backfill|dlq list|dlq replay <id> [--force]|workspaces add|workspaces list|workspaces remove> [...]');
-    throw new CliExit(1);
+    fail('Usage: hippo slack <backfill|dlq list|dlq replay <id> [--force]|workspaces add|workspaces list|workspaces remove> [...]');
 }
 //# sourceMappingURL=slack.js.map

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

@@ -1,4 +1,6 @@
 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. */
+/**
+ * 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

@@ -1,6 +1,8 @@
 // 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. */
+/**
+ * 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)];
@@ -31,12 +33,12 @@ function sleepDedupeAndAuditLines(result) {
             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.`);
+        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).`);
+            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).`);
@@ -51,7 +53,8 @@ function sleepShareAndGraphLines(result) {
     }
     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).`);
+        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)}`);

package/dist/cli/sleep.js

@@ -17,7 +17,8 @@ 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, 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.
+    // 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) {
@@ -61,7 +62,9 @@ function repairProjectTagsOnce(hippoRoot, tenantId) {
         const parts = [
             r.copies.length > 0 ? `set aside ${r.copies.length} misfiled note imports` : '',
             r.folds.length > 0 ? `folded ${r.folds.map((f) => `${f.from} into ${f.into}`).join(', ')}` : '',
-            r.toProject.length + r.setAside.length > 0 ? `re-tagged ${r.toProject.length + r.setAside.length} merged memories` : '',
+            r.toProject.length + r.setAside.length > 0
+                ? `re-tagged ${r.toProject.length + r.setAside.length} merged memories`
+                : '',
         ].filter((p) => p !== '');
         console.log(`Repaired project tags once after the upgrade: ${parts.join('; ')} (backup: ${r.backup}).`);
     }
@@ -69,13 +72,13 @@ function repairProjectTagsOnce(hippoRoot, tenantId) {
         log.warn(`project tag repair skipped, retried next sleep: ${errorMessage(err)}`);
     }
 }
-async function cmdSleepCore(hippoRoot, tenantId, flags) {
-    requireInit(hippoRoot);
+async function learnBeforeSleep(hippoRoot, tenantId, flags) {
     // 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.
     const learn = !flags['no-learn'] && !skipLearnOnSharedStore(hippoRoot);
     if (learn && flags['dry-run']) {
-        console.log("Dry run: skipped learning from git commits and coding agents' own memories (`hippo import --agents --dry-run` previews those).");
+        console.log("Dry run: skipped learning from git commits and coding agents' own memories (`hippo import --agents --dry-run` " +
+            "previews those).");
     }
     else if (learn) {
         const config = loadConfig(hippoRoot);
@@ -95,11 +98,16 @@ async function cmdSleepCore(hippoRoot, tenantId, flags) {
         }
         printAgentImport(importForStore(hippoRoot, { machine: currentMachine() }), '');
     }
+}
+async function cmdSleepCore(hippoRoot, tenantId, flags) {
+    requireInit(hippoRoot);
+    await learnBeforeSleep(hippoRoot, tenantId, flags);
     // Finishes compactions a killed or busy post-compact hook left; never throws, and a dry run writes nothing.
     if (!flags['dry-run']) {
         const finished = replayCompactionsAt(hippoRoot, (message) => log.warn(`compaction replay: ${message}`));
-        if (finished > 0)
+        if (finished > 0) {
             console.log(`Finished saving ${finished} compaction${finished === 1 ? '' : 's'} left over from earlier sessions.`);
+        }
         repairProjectTagsOnce(hippoRoot, tenantId);
         await repairQualityOnceAt(hippoRoot, tenantId);
     }

package/dist/cli/status.d.ts

@@ -2,11 +2,11 @@ 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 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): Promise<void>;
 /** `hippo failures [--days <n>] [--json] [--global]`: failed tool calls by outcome, and repeats across sessions. */
-export declare function handleFailures({ hippoRoot, tenantId, flags }: CommandContext): void;
+export declare function handleFailures({ hippoRoot, tenantId, flags }: CommandContext): Promise<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;

package/dist/cli/status.js

@@ -15,10 +15,10 @@ import { PACKAGE_VERSION } from '../util/version.js';
 import { FAILURE_LOG_RETENTION_DAYS } from '../store/failure-log.js';
 import { getGlobalRoot } from '../sharing/global-store.js';
 import * as api from '../api/index.js';
-import { getMemory } from '../api/memories.js';
+import { getMemory } from '../api/memories/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 { errorMessage, log, errorFields } from '../util/log.js';
 import { printError } from './output.js';
 import { parseCountFlag, stringFlagOrExit, flagIsTrue } from './flag-values.js';
 import { requireInit, resolveAuthRoot } from './shared.js';
@@ -26,11 +26,12 @@ import { fmt } from './print.js';
 import { isJsonObject } from '../util/json.js';
 import { hookStoreRoot } from './hook-runtime.js';
 import { DAY_MS, HOUR_MS, MINUTE_MS } from '../util/time.js';
-import { CliExit } from './exit.js';
+import { CliExit, fail } from './exit.js';
+const AT_RISK_BELOW = 0.2;
 export function handleStatus({ hippoRoot, tenantId }) {
     requireInit(hippoRoot);
     const ctx = cliApiContext(hippoRoot, tenantId);
-    const { stats, counts } = storeStatus(ctx, evalNow(), 0.2);
+    const { stats, counts } = storeStatus(ctx, evalNow(), AT_RISK_BELOW);
     const { byLayer, byConfidence, pinned, atRisk, agedOut, avgStrength } = counts;
     console.log('Hippo Status');
     console.log('---------------------------');
@@ -40,7 +41,7 @@ export function handleStatus({ hippoRoot, tenantId }) {
     console.log(`  Semantic:        ${byLayer[Layer.Semantic]}`);
     console.log(`  Trace:           ${byLayer[Layer.Trace]}`);
     console.log(`Pinned:            ${pinned}`);
-    console.log(`At risk (<0.2):    ${atRisk}`);
+    console.log(`At risk (<${AT_RISK_BELOW}):    ${atRisk}`);
     console.log(`Open conflicts:    ${counts.openConflicts}`);
     console.log(`Avg strength:      ${fmt(avgStrength)}`);
     console.log('');
@@ -130,7 +131,7 @@ function printPhysicsStatus(ctx) {
     }
     catch (err) {
         // The physics table may not exist yet, so status prints without that line.
-        log.debug(`physics status skipped: ${errorMessage(err)}`);
+        log.debug(`physics status skipped: ${errorMessage(err)}`, errorFields(err));
     }
 }
 export function physicsEnergyText(particles, gMemory) {
@@ -143,8 +144,7 @@ async function cmdInspect(hippoRoot, tenantId, id) {
     requireInit(hippoRoot);
     const entry = await getMemory(cliApiContext(hippoRoot, tenantId), id);
     if (!entry) {
-        printError(`Memory not found: ${id}`);
-        throw new CliExit(1);
+        fail(`Memory not found: ${id}`);
     }
     const now = evalNow();
     const currentStrength = calculateStrength(entry, now, { ablation: strengthAblation() });
@@ -156,7 +156,8 @@ async function cmdInspect(hippoRoot, tenantId, id) {
     console.log(`Memory: ${entry.id}`);
     console.log('---------------------------');
     console.log(`Layer:            ${entry.layer}`);
-    console.log(`Confidence:       ${entry.confidence}${effectiveConfidence !== entry.confidence ? ` (effective: ${effectiveConfidence})` : ''}`);
+    const effective = effectiveConfidence !== entry.confidence ? ` (effective: ${effectiveConfidence})` : '';
+    console.log(`Confidence:       ${entry.confidence}${effective}`);
     console.log(`Created:          ${entry.created} (${fmt(ageDays, 1)}d ago)`);
     console.log(`Last retrieved:   ${entry.last_retrieved} (${fmt(daysSince, 1)}d ago)`);
     console.log(`Retrieval count:  ${entry.retrieval_count}`);
@@ -181,13 +182,13 @@ async function cmdInspect(hippoRoot, tenantId, id) {
     console.log('-'.repeat(40));
     console.log(entry.content);
 }
-/** `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 }) {
+/** `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 async function handleTokens({ hippoRoot, tenantId, flags }) {
     const root = resolveAuthRoot(hippoRoot, flags);
     const ctx = cliApiContext(root, tenantId);
     const days = parseCountFlag(flags['days']);
-    const summary = api.tokenSummary(ctx, { days: days > 0 ? days : undefined });
+    const summary = await api.tokenSummary(ctx, { days: days > 0 ? days : undefined });
     if (flags['json']) {
         console.log(JSON.stringify(summary, null, 2));
         return;
@@ -198,11 +199,13 @@ export function handleTokens({ hippoRoot, tenantId, flags }) {
         return;
     }
     console.log(`Memory text handed to agents, last ${windowDays} days (estimated tokens, characters / 4)\n`);
-    console.log(`  ${'surface'.padEnd(14)}${'sent'.padStart(8)}${'tokens'.padStart(12)}${'skipped'.padStart(10)}${'saved'.padStart(12)}`
+    console.log(`  ${'surface'.padEnd(14)}${'sent'.padStart(8)}${'tokens'.padStart(12)}${'skipped'.padStart(10)}` +
+        `${'saved'.padStart(12)}`
         + `${'re-read'.padStart(12)}`);
     for (const row of summary.surfaces) {
         console.log(`  ${row.surface.padEnd(14)}${String(row.injected).padStart(8)}${String(row.tokens).padStart(12)}`
-            + `${String(row.skipped).padStart(10)}${String(row.tokensAvoided).padStart(12)}${String(row.tokensReread).padStart(12)}`);
+            + `${String(row.skipped).padStart(10)}${String(row.tokensAvoided).padStart(12)}`
+            + `${String(row.tokensReread).padStart(12)}`);
     }
     console.log('');
     console.log(`  Total sent: ${summary.totalTokens} tokens. Saved by skipping unchanged blocks: ${summary.totalTokensAvoided}.`);
@@ -211,17 +214,18 @@ export function handleTokens({ hippoRoot, tenantId, flags }) {
     if (summary.meanTokensPerSession > 0) {
         console.log(`  Mean per session (rows with a session id): ${summary.meanTokensPerSession} tokens.`);
     }
-    console.log('  Re-reads are counted for hook and compact-resume blocks when a session ends; other surfaces, and open or crashed sessions, show sent only.');
+    console.log('  Re-reads are counted for hook and compact-resume blocks when a session ends; ' +
+        'other surfaces, and open or crashed sessions, show sent only.');
     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 handleFailures({ hippoRoot, tenantId, flags }) {
+export async 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 = cliApiContext(root, tenantId);
     const days = parseCountFlag(flags['days']);
-    const summary = api.failureSummary(ctx, { days: days > 0 ? days : undefined });
+    const summary = await api.failureSummary(ctx, { days: days > 0 ? days : undefined });
     if (flags['json']) {
         console.log(JSON.stringify(summary, null, 2));
         return;
@@ -305,8 +309,9 @@ export function handleProvenance({ hippoRoot, tenantId, flags }) {
     }
 }
 export function handleDoctor({ flags }) {
+    const pkgPath = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'package.json');
     // SAFETY: package.json always carries a string "version" (checked at release by check-manifest-versions).
-    const pkg = JSON.parse(fs.readFileSync(path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'package.json'), 'utf-8'));
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
     const report = runDoctor({ version: pkg.version });
     console.log(flags['json'] ? JSON.stringify(report, null, 2) : formatDoctor(report));
     if (!report.ok)
@@ -315,8 +320,7 @@ export function handleDoctor({ flags }) {
 export function handleSupportBundle({ flags }) {
     const outFlag = stringFlagOrExit(flags, 'out');
     if (outFlag === '') {
-        printError('--out requires a file path.');
-        throw new CliExit(1);
+        fail('--out requires a file path.');
     }
     const includeLogs = flagIsTrue(flags, 'include-logs');
     const home = envHomeDir() || os.homedir();
@@ -340,16 +344,17 @@ export function handleSupportBundle({ flags }) {
     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 async function handleInspect({ hippoRoot, tenantId, args }) {
     const id = args[0];
     if (!id) {
-        printError('Please provide a memory ID.');
-        throw new CliExit(1);
+        fail('Please provide a memory ID.');
     }
     await cmdInspect(hippoRoot, tenantId, id);
 }

package/dist/cli/stdin.d.ts

@@ -1,15 +1,22 @@
-/** `timedOut` means the window closed with stdin still open, so absent `text` is "unknown", not "none", and present `text` may be truncated;
+/**
+ * `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`),
+/**
+ * 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. */
 export declare function normaliseHookPayload(text: string | undefined): string | undefined;
-/** The stdin read every hook verb uses: {@link readStdinBounded}, with the payload passed through {@link normaliseHookPayload}. */
+/**
+ * The stdin read every hook verb uses: {@link readStdinBounded}, with the payload passed through {@link
+ * normaliseHookPayload}.
+ */
 export declare function readHookStdin(waitMs?: number): Promise<BoundedStdin>;
 //# sourceMappingURL=stdin.d.ts.map

package/dist/cli/stdin.js

@@ -4,7 +4,9 @@ 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`),
+/**
+ * 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;
@@ -48,7 +50,9 @@ const CAMEL_TO_SNAKE = [
     ['hookEventName', 'hook_event_name'],
     ['customInstructions', 'custom_instructions'],
 ];
-/** Copilot sends `toolArgs` as the model's raw JSON string; Claude Code and VS Code send `tool_input` already parsed. */
+/**
+ * Copilot sends `toolArgs` as the model's raw JSON string; Claude Code and VS Code send `tool_input` already parsed.
+ */
 function parsedToolArgs(value) {
     if (!isJsonString(value))
         return value;
@@ -95,7 +99,10 @@ export function normaliseHookPayload(text) {
     const added = snakeCaseFields(payload);
     return Object.keys(added).length === 0 ? text : JSON.stringify({ ...payload, ...added });
 }
-/** The stdin read every hook verb uses: {@link readStdinBounded}, with the payload passed through {@link normaliseHookPayload}. */
+/**
+ * The stdin read every hook verb uses: {@link readStdinBounded}, with the payload passed through {@link
+ * normaliseHookPayload}.
+ */
 export async function readHookStdin(waitMs) {
     const read = await readStdinBounded(waitMs);
     return { text: normaliseHookPayload(read.text), timedOut: read.timedOut };

package/dist/cli/transfer.d.ts

@@ -6,5 +6,5 @@ export declare function handleWatch({ hippoRoot, tenantId, args, flags }: Comman
 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;
+export declare function handleExport({ hippoRoot, tenantId, args, flags }: CommandContext): Promise<void>;
 //# sourceMappingURL=transfer.d.ts.map