hippo-memory 1.71.0 → 1.72.0

package/dist/cli/print.js

@@ -15,7 +15,8 @@ export function recallEntryText(r, query, showWhy, isGlobal) {
     const bars = Math.round(e.strength * 10);
     const graphMark = r.graphVia ? ` [graph: ${r.graphVia.hops}hop ${r.graphVia.relType}]` : '';
     const lines = [
-        `--- ${e.id} [${e.layer}] ${confLabel}${isGlobal ? ' [global]' : ''}${e.superseded_by ? ' [superseded]' : ''}${graphMark} score=${fmt(r.score, 3)} strength=${fmt(e.strength)}`,
+        `--- ${e.id} [${e.layer}] ${confLabel}${isGlobal ? ' [global]' : ''}${e.superseded_by ? ' [superseded]' : ''}${graphMark} ` +
+            `score=${fmt(r.score, 3)} strength=${fmt(e.strength)}`,
         `    [${'█'.repeat(bars)}${'░'.repeat(10 - bars)}] tags: ${e.tags.join(', ') || 'none'} | retrieved: ${e.retrieval_count}x`,
     ];
     if (showWhy) {

package/dist/cli/projects.js

@@ -1,8 +1,8 @@
 // The `hippo projects` verb: list a store's project names, fold an old worktree name into its repo, repair old tags in one pass.
 import * as path from 'path';
 import { execFileSync } from 'child_process';
-import { closeHippoDb, openHippoDb } from '../db/index.js';
-import { listProjects, mergeProjects, repairProjects } from '../sharing/project-merge.js';
+import * as api from '../api/index.js';
+import { cliApiContext } from './api-context.js';
 import { flagIsTrue } from './flag-values.js';
 import { resolveAuthRoot } from './shared.js';
 import { printError } from './output.js';
@@ -11,7 +11,12 @@ import { DATE_PREFIX_CHARS } from '../util/token-text.js';
 /** Old per-worktree project names of the repo at cwd, mapped to the repo's main checkout name; empty outside git. */
 function worktreeNames() {
     try {
-        const out = execFileSync('git', ['worktree', 'list', '--porcelain'], { encoding: 'utf8', timeout: 10_000, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
+        const out = execFileSync('git', ['worktree', 'list', '--porcelain'], {
+            encoding: 'utf8',
+            timeout: 10_000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+        });
         const paths = out.split(/\r?\n/).filter((l) => l.startsWith('worktree ')).map((l) => path.basename(l.slice('worktree '.length)));
         return new Map(paths.slice(1).map((name) => [name, paths[0]]));
     }
@@ -32,8 +37,9 @@ function hint(p, worktrees) {
 function count(n, one, many = `${one}s`) {
     return `${n} ${n === 1 ? one : many}`;
 }
-function projectsList(db, tenantId, root, flags) {
-    const projects = listProjects(db, tenantId);
+function projectsList(ctx, flags) {
+    const root = ctx.hippoRoot;
+    const projects = api.listProjectNames(ctx);
     if (flags['json']) {
         console.log(JSON.stringify({ store: root, projects }, null, 2));
         return;
@@ -41,51 +47,56 @@ function projectsList(db, tenantId, root, flags) {
     const worktrees = worktreeNames();
     console.log(`${count(projects.length, 'project name')} in ${root} (newest write first):\n`);
     for (const p of projects) {
-        console.log(`${label(p.origin)}  ${count(p.live, 'memory', 'memories')}, ${p.imported} imported from agent notes, newest ${p.newest.slice(0, DATE_PREFIX_CHARS)}${hint(p, worktrees)}`);
+        console.log(`${label(p.origin)}  ${count(p.live, 'memory', 'memories')}, ${p.imported} imported from agent notes, ` +
+            `newest ${p.newest.slice(0, DATE_PREFIX_CHARS)}${hint(p, worktrees)}`);
     }
 }
-function projectsMerge(db, tenantId, root, args, flags) {
+function projectsMerge(ctx, args, flags) {
     const apply = flagIsTrue(flags, 'apply');
     const [from, into] = [args[1] ?? '', args[2] ?? ''];
-    const r = mergeProjects(db, root, { tenantId, from, into, dryRun: !apply });
+    const r = api.mergeProjectNames(ctx, { from, into, dryRun: !apply });
     if (flags['json']) {
         console.log(JSON.stringify(r, null, 2));
         return;
     }
     console.log(`${apply ? 'Merged' : 'Dry run: would merge'} ${from} into ${into}:`);
-    console.log(`  ${count(r.setAside.length, 'imported note copy', 'imported note copies')} set aside (${into} already holds the same note; the rest move under ${into} on the next sync)`);
-    console.log(`  ${count(r.restamped.length, 'memory', 'memories')} re-tagged, plus ${r.dormantRestamped.length} dormant and ${count(r.compactions, 'compaction record')}`);
+    console.log(`  ${count(r.setAside.length, 'imported note ' +
+        'copy', 'imported note copies')} set aside (${into} already holds the same note; the rest move under ${into} on the next sync)`);
+    console.log(`  ${count(r.restamped.length, 'memory', 'memories')} re-tagged, plus ${r.dormantRestamped.length} dormant ` +
+        `and ${count(r.compactions, 'compaction record')}`);
     console.log(apply ? `Backup: ${r.backup}\nEvery id is in the audit log: hippo audit list --op project_merge` : 'Nothing written. Add --apply to run it.');
 }
-function projectsRepair(db, tenantId, root, flags) {
+function projectsRepair(ctx, flags) {
+    const root = ctx.hippoRoot;
     const apply = flagIsTrue(flags, 'apply');
-    const r = repairProjects(db, root, { tenantId, dryRun: !apply });
+    const r = api.repairProjectNames(ctx, { dryRun: !apply });
     if (flags['json']) {
         console.log(JSON.stringify(r, null, 2));
         return;
     }
     console.log(`${apply ? 'Repaired' : 'Dry run: would repair'} ${root}:`);
-    console.log(`  ${count(r.copies.length, 'imported note copy', 'imported note copies')} under the wrong project set aside (the note stays under its own, or user-global)`);
+    console.log(`  ${count(r.copies.length, 'imported note ' +
+        'copy', 'imported note copies')} under the wrong project set aside (the note stays under its own, or user-global)`);
     for (const f of r.folds)
         console.log(`  ${f.from} folded into ${f.into} (its sessions' folders resolve there now)`);
-    for (const c of r.collisions)
+    for (const c of r.collisions) {
         console.log(`  ${c.name} left as it is: its folders now resolve to ${c.ids.join(', ')}; fold it by hand with hippo projects merge`);
+    }
     console.log(`  sleep's user-global merged rows: ${r.toProject.length} re-tagged to their parents' project`);
     console.log(`  ${r.setAside.length} set aside (parents in two projects; sleep re-merges them per project)`);
     console.log(`  ${r.untraced.length} left as they are (no parent left to show which project; check them with hippo inspect <id>)`);
     console.log(apply ? `Backup: ${r.backup}\nEvery id is in the audit log: hippo audit list --op project_repair` : 'Nothing written. Add --apply to run it.');
 }
 export function handleProjects({ hippoRoot, tenantId, args, flags }) {
-    const root = resolveAuthRoot(hippoRoot, flags);
+    const ctx = cliApiContext(resolveAuthRoot(hippoRoot, flags), tenantId);
     const sub = args[0] ?? 'list';
-    const db = openHippoDb(root);
     try {
         if (sub === 'list')
-            return projectsList(db, tenantId, root, flags);
+            return projectsList(ctx, flags);
         if (sub === 'merge')
-            return projectsMerge(db, tenantId, root, args, flags);
+            return projectsMerge(ctx, args, flags);
         if (sub === 'repair')
-            return projectsRepair(db, tenantId, root, flags);
+            return projectsRepair(ctx, flags);
         printError('Usage: hippo projects [list] [--json] | merge <from> <into> [--apply] | repair [--apply]  [--global]');
         process.exitCode = 1;
     }
@@ -93,8 +104,5 @@ export function handleProjects({ hippoRoot, tenantId, args, flags }) {
         printError(errorMessage(err));
         process.exitCode = 1;
     }
-    finally {
-        closeHippoDb(db);
-    }
 }
 //# sourceMappingURL=projects.js.map

package/dist/cli/quality-repair-once.d.ts

@@ -1,3 +1,3 @@
 /** Fault-isolated like the project tag repair: a failure warns, leaves the store unmarked and runs again next time. */
-export declare function repairQualityOnceAt(root: string): void;
+export declare function repairQualityOnceAt(root: string, tenantId: string): void;
 //# sourceMappingURL=quality-repair-once.d.ts.map

package/dist/cli/quality-repair-once.js

@@ -1,13 +1,13 @@
 // Sleep and the daily runner clean a store's old automatic memories once, so an upgrade needs no command.
 import * as path from 'path';
 import { errorMessage, log } from '../util/log.js';
-import { repairQualityOnce } from '../store/quality-repair.js';
 import { getGlobalRoot } from '../sharing/global-store.js';
-import { resolveTenantId } from '../store/tenant.js';
+import { repairMemoryQualityOnce } from '../api/audit.js';
+import { cliApiContext } from './api-context.js';
 /** Fault-isolated like the project tag repair: a failure warns, leaves the store unmarked and runs again next time. */
-export function repairQualityOnceAt(root) {
+export function repairQualityOnceAt(root, tenantId) {
     try {
-        const result = repairQualityOnce(root, resolveTenantId({}));
+        const result = repairMemoryQualityOnce(cliApiContext(root, tenantId));
         if (result === null)
             return;
         if (!result.supported) {
@@ -18,7 +18,8 @@ export function repairQualityOnceAt(root) {
         const scope = path.resolve(root) === path.resolve(getGlobalRoot()) ? ' --global' : '';
         const moved = result.appliedIds.length;
         if (moved > 0) {
-            console.log(`Set aside ${moved} automatic ${moved === 1 ? 'memory' : 'memories'} with a certain defect, once after the upgrade (backup: ${result.backup}).`);
+            console.log(`Set aside ${moved} automatic ${moved === 1 ? 'memory' : 'memories'} with a certain defect, ` +
+                `once after the upgrade (backup: ${result.backup}).`);
             console.log(`  List them: hippo dormant${scope}   Bring one back: hippo dormant restore <id>${scope}`);
         }
         const review = result.issues.filter((issue) => issue.disposition === 'review').length;

package/dist/cli/recall.js

@@ -13,7 +13,7 @@ import { cliRecallOrigin, cliRecallReranker, cliRecallSetting, DEFAULT_MAX_NEIGH
 import { cliApiContext } from './api-context.js';
 import { handoffText, printedTokens, sessionTrailText, settleTokens, snapshotText } from '../api/context-render.js';
 import { printError } from './output.js';
-import { parseLimitFlag, parseBudgetFlag, parseAsOfFlag, engineFlags, boolFlag, flagIsTrue, isBooleanFlag, } from './flag-values.js';
+import { parseLimitFlag, parseBudgetFlag, parseAsOfFlag, engineFlags, boolFlag, flagIsTrue, isBooleanFlag, numberFlag, } from './flag-values.js';
 import { requireInit } from './shared.js';
 import { recallEntryText, recallHeading, printActiveTaskSnapshot, printSessionEvents, printHandoff, captureConsole } from './print.js';
 import { hostSessionId, hookStoreRoot } from './hook-runtime.js';
@@ -22,8 +22,10 @@ import { CliExit } from './exit.js';
 function planningLine(p) {
     if (p.hint)
         return `Planning fallacy hint (class: ${p.hint.classTag}): ${p.hint.baserateSummary} [detected: ${JSON.stringify(p.hint.detectedPhrase)}]`;
-    if (p.watching)
-        return `Planning fallacy: watching this query (reason: ${p.watching.reason}). ${p.watching.suggestion} [detected: ${JSON.stringify(p.watching.detectedPhrase)}]`;
+    if (p.watching) {
+        return `Planning fallacy: watching this query (reason: ${p.watching.reason}). ${p.watching.suggestion} ` +
+            `[detected: ${JSON.stringify(p.watching.detectedPhrase)}]`;
+    }
     return null;
 }
 function cutoffLine(shown, s) {
@@ -198,9 +200,7 @@ function parseRecallOptions(ctx, flags) {
     const explicitScope = flags['scope'] !== undefined ? String(flags['scope']).trim() : null;
     const setting = cliRecallSetting(ctx, explicitScope);
     const config = loadConfig(ctx.hippoRoot);
-    const minResults = flags['min-results'] !== undefined
-        ? parseInt(String(flags['min-results']), 10)
-        : undefined;
+    const minResults = numberFlag(flags, 'min-results');
     const graphStream = flagIsTrue(flags, 'graph-stream') ? parseGraphStreamFlags(flags) : undefined;
     const late = parseRecallLateFlags(flags);
     const goalTag = flags['goal'] !== undefined ? String(flags['goal']).trim() : '';
@@ -228,7 +228,13 @@ function rankOptions(query, flags, o, priced) {
     return {
         budget: entryBudget, cost: priced.printCost, limit: o.limit, why: o.showWhy, includeSuperseded: o.includeSuperseded, asOf: o.asOf,
         explicitScope: o.explicitScope, activeScope: o.setting.activeScope,
-        search: { ...engineFlags(flags, o.config), multihop: flagIsTrue(flags, 'multihop') || o.config.multihop.enabled, graphStream: o.graphStream, minResults: o.minResults, explain: false },
+        search: {
+            ...engineFlags(flags, o.config),
+            multihop: flagIsTrue(flags, 'multihop') || o.config.multihop.enabled,
+            graphStream: o.graphStream,
+            minResults: o.minResults,
+            explain: false,
+        },
         graphHops: o.late.graphHops,
         evcAdaptive: boolFlag(flags, 'evc-adaptive'),
         filterConflicts: boolFlag(flags, 'filter-conflicts'),

package/dist/cli/refine-llm.js

@@ -2,8 +2,9 @@
  * Uses fetch directly (no SDK dependency); on any failure the original memory is untouched. */
 import { Layer } from '../core/memory.js';
 import { REFINED_TAG, storeRefinement } from '../api/index.js';
+import { listMemories, listMemoriesByIds } from '../api/memories.js';
 import { cliApiContext } from './api-context.js';
-import { loadAllEntries, readEntry } from '../store/entry-reads.js';
+import { chunked } from '../util/chunked.js';
 import { redactSecretsStrict } from '../util/secret-detect.js';
 import { sendAnthropicMessage } from '../util/anthropic-messages.js';
 import { log } from '../util/log.js';
@@ -22,7 +23,9 @@ export async function refineSemanticMemory(merged, sources, opts) {
         .slice(0, MAX_REFINE_SOURCES)
         .map((s, i) => `[source ${i + 1}] ${redactSecretsStrict(s.content).slice(0, REFINE_SOURCE_CHARS)}`)
         .join('\n\n');
-    const prompt = `You are refining a semantic memory in an agent's memory store. The rule-based consolidator merged several related episodic memories into one, but the output is clumsy. Produce a single coherent semantic memory that captures the underlying principle.
+    const prompt = `You are refining a semantic memory in an agent's memory store. ` +
+        `The rule-based consolidator merged several related episodic memories into one, but the output is clumsy. ` +
+        `Produce a single coherent semantic memory that captures the underlying principle.
 
 Rules:
 - Output ONLY the refined content — no preamble, no quote marks, no "Here is...".
@@ -56,7 +59,7 @@ ${sourceBlock}`;
 function describeRefineFailure(failure) {
     switch (failure.kind) {
         case 'request': return `refine: request failed: ${failure.message}`;
-        case 'http': return `refine: API answered HTTP ${failure.status}`;
+        case 'http': return `refine: API answered HTTP ${failure.status}${failure.detail ? `: ${failure.detail}` : ''}`;
         case 'unreadable': return `refine: unreadable response: ${failure.message}`;
     }
 }
@@ -74,9 +77,10 @@ export async function refineStore(hippoRoot, opts) {
         failed: 0,
         details: [],
     };
-    // When opts.tenantId is provided, scope the top-level scan to this
-    // tenant's consolidated entries.
-    const entries = loadAllEntries(hippoRoot, opts.tenantId);
+    // No tenant means every tenant, so the ctx's own tenant is never read.
+    const ctx = cliApiContext(hippoRoot, opts.tenantId ?? '');
+    const reach = { everyTenant: opts.tenantId === undefined };
+    const entries = listMemories(ctx, reach);
     let processed = 0;
     for (const entry of entries) {
         if (!isConsolidated(entry))
@@ -90,22 +94,18 @@ export async function refineStore(hippoRoot, opts) {
         if (opts.limit !== undefined && processed >= opts.limit)
             break;
         processed++;
-        await refineOneEntry(hippoRoot, entry, opts, result);
+        await refineOneEntry(ctx, reach, entry, opts, result);
     }
     return result;
 }
-async function refineOneEntry(hippoRoot, entry, opts, result) {
+async function refineOneEntry(ctx, reach, entry, opts, result) {
     // Best-effort: walk parents_json (schema v9) to fetch originals. When
     // parents aren't recorded we still refine using just the merged content.
-    const sources = [];
     const parentIds = Array.isArray(entry.parents) ? entry.parents : [];
-    for (const pid of parentIds) {
-        // Parent lookup is tenant-scoped; cross-tenant parents return null and are skipped,
-        // so refine still works from the merged content alone.
-        const p = readEntry(hippoRoot, pid, opts.tenantId);
-        if (p)
-            sources.push(p);
-    }
+    // Parent lookup is tenant-scoped; cross-tenant parents are absent and skipped,
+    // so refine still works from the merged content alone.
+    const found = new Map(chunked(parentIds).flatMap((chunk) => listMemoriesByIds(ctx, chunk, reach)).map((p) => [p.id, p]));
+    const sources = parentIds.flatMap((pid) => found.get(pid) ?? []);
     const refined = await refineSemanticMemory(entry.content, sources, {
         apiKey: opts.apiKey,
         model: opts.model,
@@ -121,7 +121,7 @@ async function refineOneEntry(hippoRoot, entry, opts, result) {
         result.details.push({ id: entry.id, status: 'refined', reason: 'dry-run (no write)' });
         return;
     }
-    storeRefinement(cliApiContext(hippoRoot, entry.tenantId), entry, refined);
+    storeRefinement(cliApiContext(ctx.hippoRoot, entry.tenantId), entry, refined);
     result.refined++;
     result.details.push({ id: entry.id, status: 'refined' });
 }

package/dist/cli/remember.js

@@ -1,18 +1,17 @@
 // The write verbs: `hippo remember`, `hippo supersede` and `hippo trace`.
 import { envAnthropicApiKey } from '../util/env.js';
-import { evalNow } from '../core/ablation.js';
+import { evalNow, strengthAblation } from '../core/ablation.js';
 import * as fs from 'fs';
 import { calculateStrength, calculateRewardFactor, confidenceFacets, confidenceLabel, Layer, } from '../core/memory.js';
 import * as api from '../api/index.js';
 import { getMemory } from '../api/memories.js';
 import { ConflictError, NotFoundError } from '../core/api-errors.js';
-import { isInitialized } from '../store/open.js';
-import { listMemoryConflicts } from '../store/conflicts.js';
-import { RejectedValueError } from '../store/rejection.js';
+import { isInitialized } from '../core/project-identity.js';
+import { RejectedValueError } from '../core/api-errors.js';
 import { renderTraceContent, parseSteps } from '../consolidate/trace.js';
 import { extractPathTags } from '../search/path-context.js';
-import { detectScope } from '../sharing/scope.js';
-import { assertClientScope } from '../store/recall-scope.js';
+import { detectScope } from '../core/active-scope.js';
+import { assertClientScope } from '../core/recall-scope.js';
 import { getGlobalRoot, initGlobal } from '../sharing/global-store.js';
 import { vetSecrets } from '../util/secret-detect.js';
 import * as client from './client.js';
@@ -268,9 +267,9 @@ async function cmdTrace(hippoRoot, tenantId, id, flags) {
 }
 function traceStats(entry) {
     const now = evalNow();
-    const strength = calculateStrength(entry, now);
+    const strength = calculateStrength(entry, now, { ablation: strengthAblation() });
     const halfLife = entry.half_life_days;
-    const rewardFactor = calculateRewardFactor(entry);
+    const rewardFactor = calculateRewardFactor(entry, strengthAblation());
     const effHalfLife = halfLife * rewardFactor;
     const createdMs = new Date(entry.created).getTime();
     const ageDays = (now.getTime() - createdMs) / DAY_MS;
@@ -279,7 +278,7 @@ function traceStats(entry) {
     const facets = confidenceFacets(entry, now);
     const conf = confidenceLabel(entry, now).text;
     // Projected strength: same decay curve, just push `now` out.
-    const projectedAt = (days) => calculateStrength(entry, new Date(now.getTime() + days * DAY_MS));
+    const projectedAt = (days) => calculateStrength(entry, new Date(now.getTime() + days * DAY_MS), { ablation: strengthAblation() });
     return { strength, halfLife, rewardFactor, effHalfLife, ageDays, sinceLast, facets, conf, projectedAt };
 }
 async function traceLineage(hippoRoot, globalRoot, entry, id, tenantId) {
@@ -293,8 +292,8 @@ async function traceLineage(hippoRoot, globalRoot, entry, id, tenantId) {
     }
     // Open conflicts involving this memory.
     const allConflicts = [
-        ...listMemoryConflicts(hippoRoot, 'open', tenantId),
-        ...(isInitialized(globalRoot) ? listMemoryConflicts(globalRoot, 'open', tenantId) : []),
+        ...api.listConflicts(cliApiContext(hippoRoot, tenantId), 'open'),
+        ...(isInitialized(globalRoot) ? api.listConflicts(cliApiContext(globalRoot, tenantId), 'open') : []),
     ];
     const myConflicts = allConflicts.filter((c) => c.memory_a_id === id || c.memory_b_id === id);
     return { parentPreviews, myConflicts };
@@ -334,7 +333,8 @@ function printTraceText(t) {
     console.log(`Memory: ${entry.id}  [${sourceLabel}]`);
     console.log('='.repeat(50));
     console.log(`Content:   ${entry.content.replace(/\s+/g, ' ').slice(0, DETAIL_CONTENT_CHARS)}${entry.content.length > DETAIL_CONTENT_CHARS ? '...' : ''}`);
-    console.log(`Layer:     ${entry.layer.padEnd(10)} Confidence: ${conf.padEnd(14)} Pinned: ${entry.pinned ? 'yes' : 'no'}${entry.starred ? '  Starred: yes' : ''}`);
+    console.log(`Layer:     ${entry.layer.padEnd(10)} Confidence: ${conf.padEnd(14)} Pinned: ${entry.pinned ? 'yes' : 'no'}${entry.starred ? '  Starred: ' +
+        'yes' : ''}`);
     console.log(`Tags:      ${entry.tags.join(', ') || '(none)'}`);
     console.log(`Created:   ${entry.created}  (${fmt(ageDays, 1)} days ago)`);
     console.log();

package/dist/cli/scheduler.js

@@ -51,7 +51,8 @@ function setAsideCorruptRegistry(registryPath, err) {
         log.warn(`workspace registry ${registryPath} is corrupt (${reason}); moved it to ${aside} and starting with no workspaces`);
     }
     catch (renameErr) {
-        log.warn(`workspace registry ${registryPath} is corrupt (${reason}) and could not be moved aside (${errorMessage(renameErr)}); starting with no workspaces`);
+        log.warn(`workspace registry ${registryPath} is corrupt (${reason}) and could not be moved aside (${errorMessage(renameErr)}); ` +
+            `starting with no workspaces`);
     }
 }
 export function saveWorkspaceRegistry(globalRoot, registry) {

package/dist/cli/serve.js

@@ -4,14 +4,14 @@ import { envAllowKeylessLocal, envPort, envRequireAuth, envTlsCert, envTlsKey }
 import * as fs from 'fs';
 import * as path from 'path';
 import { printError } from './output.js';
-import { stringFlagOrExit, stringFlag } from './flag-values.js';
+import { stringFlagOrExit, stringFlag, numberFlag } from './flag-values.js';
 import { requireInit } from './shared.js';
 import { errorMessage } from '../util/log.js';
 import { CliExit } from './exit.js';
-import { DEFAULT_SERVER_HOST, DEFAULT_SERVER_PORT } from '../server/defaults.js';
+import { DEFAULT_DASHBOARD_PORT, DEFAULT_SERVER_HOST, DEFAULT_SERVER_PORT } from '../server/defaults.js';
 export async function handleDashboard({ hippoRoot, flags }) {
     requireInit(hippoRoot);
-    const port = parseInt(String(flags['port'] ?? '3333'), 10);
+    const port = numberFlag(flags, 'port') ?? DEFAULT_DASHBOARD_PORT;
     const { serveDashboard } = await import('../dashboard/dashboard.js');
     serveDashboard(hippoRoot, port, undefined, { handleSignals: true });
     // A later throw ends in one log line and exit 1, as it does for serve and mcp; a busy port is reported by the dashboard itself.

package/dist/cli/session-hooks.d.ts

@@ -10,7 +10,7 @@ export declare function cmdShimArgs(shimPath: string, forwardArgs: readonly stri
 export declare function handleCodexRun({ hippoRoot, tenantId, args }: CommandContext): void;
 export declare function cmdCodexSessionEndWorker(hippoRoot: string, tenantId: string, flags: CliFlags): Promise<void>;
 export declare function handleCodexSessionEndWorker({ hippoRoot, tenantId, flags }: CommandContext): Promise<void>;
-export declare function handlePreCompact({ hippoRoot, flags }: CommandContext): Promise<void>;
+export declare function handlePreCompact({ hippoRoot, tenantId, flags }: CommandContext): Promise<void>;
 export declare function handlePostCompact({ hippoRoot, flags }: CommandContext): Promise<void>;
 export declare function handleCaptureError({ hippoRoot, tenantId, flags }: CommandContext): Promise<void>;
 export declare function handleCompactResume({ hippoRoot, tenantId }: CommandContext): Promise<void>;