hippo-memory 1.68.0 → 1.70.0

package/dist/cli/setup.d.ts

@@ -1,4 +1,5 @@
+import { type CliFlags } from './flag-values.js';
 export declare function cmdHook(args: string[]): void;
-export declare function cmdSetup(flags: Record<string, string | boolean | string[]>): void;
+export declare function cmdSetup(flags: CliFlags): void;
 export declare function cmdDailyRunner(): void;
 //# sourceMappingURL=setup.d.ts.map

package/dist/cli/setup.js

@@ -2,22 +2,26 @@
 import * as path from 'path';
 import * as fs from 'fs';
 import { execFileSync } from 'child_process';
-import { installJsonHooks, uninstallJsonHooks, checkUninstallable, resolveJsonHookPaths } from '../hooks/json-hooks.js';
+import { installJsonHooks, uninstallJsonHooks, checkUninstallable, copilotHookEvents, resolveJsonHookPaths } from '../hooks/json-hooks.js';
 import { detectInstalledTools } from '../hooks/shared.js';
 import { ensureCodexWrapperInstalled, installCodexWrapper, detectRealCodexPath, uninstallCodexWrapper, } from '../hooks/codex-wrapper.js';
 import { installOpencodePlugin, uninstallOpencodePlugin, resolveOpencodePluginPath } from '../hooks/opencode.js';
-import { copilotMcpSnippet, copilotPaths, installCopilot, isMcpFailure, uninstallCopilot } from '../hooks/copilot.js';
+import { COPILOT_CLI_MCP, VSCODE_MCP, copilotMcpSnippet, copilotPaths, installCopilot, isCopilotCliPresent, isMcpFailure, uninstallCopilot, } from '../hooks/copilot.js';
 import { isInitialized } from '../store/open.js';
 import { currentMachine, importUserMemories } from '../agent-memories/sync.js';
-import { getGlobalRoot } from '../shared.js';
-import { listRegisteredWorkspaces, runDailyMaintenance } from '../scheduler.js';
-import { replayCompactionsAt } from '../compaction-record.js';
-import { log } from '../log.js';
+import { getGlobalRoot } from '../sharing/shared.js';
+import { listRegisteredWorkspaces, runDailyMaintenance } from './scheduler.js';
+import { replayCompactionsAt } from '../capture/compaction-record.js';
+import { errorMessage, log } from '../util/log.js';
+import { envDailyStepTimeoutMs } from '../util/env.js';
+import { writeFileAtomic } from '../util/atomic-write.js';
 import { printError } from './output.js';
-import { printAgentImport, installCodexMemoryHooks, setupDailySchedule, warnClaudeSettingsUnusable } from './shared.js';
+import { boolFlag } from './flag-values.js';
+import { printAgentImport } from './print.js';
+import { installCodexMemoryHooks, setupDailySchedule, warnClaudeSettingsUnusable } from './install-steps.js';
 import { repairQualityOnceAt } from './quality-repair-once.js';
-import { HOOK_MARKERS, HOOKS, hippoBlock, withoutHookBlock } from './hook-blocks.js';
-import { escapeRegex } from '../escape.js';
+import { HOOK_MARKERS, HOOKS, hippoBlock, withoutHookBlock } from '../hooks/hook-blocks.js';
+import { escapeRegex } from '../util/escape.js';
 // ---------------------------------------------------------------------------
 // Hook install/uninstall
 // ---------------------------------------------------------------------------
@@ -42,7 +46,7 @@ function hookList() {
     for (const [name, hook] of Object.entries(HOOKS)) {
         console.log(`  ${name.padEnd(15)} -> ${hook.file} (${hook.description})`);
     }
-    console.log(`  ${'copilot'.padEnd(15)} -> $COPILOT_HOME or ~/.copilot (GitHub Copilot: hooks, MCP server and instructions)`);
+    console.log(`  ${'copilot'.padEnd(15)} -> $COPILOT_HOME or ~/.copilot, and each VS Code User folder (GitHub Copilot: hooks, MCP server and instructions)`);
     console.log('\nUsage: hippo hook install <name>');
     console.log('       hippo hook uninstall <name>');
 }
@@ -89,12 +93,12 @@ function patchAgentFile(hook, target) {
         else if (existing.includes(HOOK_MARKERS.start)) {
             const re = new RegExp(`${escapeRegex(HOOK_MARKERS.start)}[\\s\\S]*?${escapeRegex(HOOK_MARKERS.end)}`, 'g');
             const updated = existing.replace(re, block);
-            fs.writeFileSync(filepath, updated, 'utf8');
+            writeFileAtomic(filepath, updated);
             console.log(`Updated Hippo hook in ${hook.file}`);
         }
         else {
             const sep = existing.endsWith('\n') ? '\n' : '\n\n';
-            fs.writeFileSync(filepath, existing + sep + block + '\n', 'utf8');
+            writeFileAtomic(filepath, existing + sep + block + '\n');
             console.log(`Installed Hippo hook in ${hook.file} (appended)`);
         }
     }
@@ -155,11 +159,12 @@ function installOpencodeHook() {
         console.log(`WARNING: opencode.json is unparseable; legacy hooks block could not be auto-removed. Fix the file manually.`);
     }
 }
+const addByHand = (host) => `add this under "${host.key}" by hand: ${copilotMcpSnippet(host)}`;
 const MCP_MERGE_LINES = {
     added: (file) => `Added the "hippo" MCP server -> ${file}`,
     present: (file) => `The "hippo" MCP server is already in ${file}`,
     'user-owned': (file) => `Left the "hippo" MCP server in ${file} as it is: hippo did not write it`,
-    unreadable: (file) => `WARNING: ${file} has comments or is not a JSON object hippo can merge into, so it was left unchanged; add this under "mcpServers" by hand: ${copilotMcpSnippet()}`,
+    unreadable: (file, host) => `WARNING: ${file} has comments or is not a JSON object hippo can merge into, so it was left unchanged; ${addByHand(host)}`,
 };
 const mcpFailureLine = (file, failure, fix) => `WARNING: hippo could not use ${file} (${failure.failed}), so it was left unchanged; ${fix}`;
 const unclosedLine = (file) => `WARNING: ${file} has ${HOOK_MARKERS.start} with no ${HOOK_MARKERS.end}, so hippo left it unchanged; fix the markers by hand`;
@@ -175,32 +180,74 @@ const INSTRUCTIONS_REMOVE_LINES = {
     kept: (file) => `Left the hippo block in ${file}: it is not the Copilot text hippo wrote. Delete it by hand if no agent needs it.`,
     unclosed: unclosedLine,
 };
+const VSCODE_INSTRUCTIONS_INSTALL_LINES = {
+    written: (file) => `Wrote the hippo instructions file -> ${file}`,
+    present: (file) => `The hippo instructions file is already at ${file}`,
+    kept: (file) => `Kept ${file} as it is: it is not the text hippo writes, so it was edited or is someone else's`,
+};
+const VSCODE_INSTRUCTIONS_REMOVE_LINES = {
+    removed: (file) => `Removed the hippo instructions file ${file}`,
+    absent: () => '',
+    kept: (file) => `Left ${file}: it is not the text hippo wrote. Delete it by hand if no agent needs it.`,
+};
+const VSCODE_HOOKS_LINE = 'VS Code: hooks need VS Code 1.109.3 or later with chat.useHooks on (the default); older versions get the MCP server and the instructions file only.';
+function mcpInstallLine(file, mcp, host) {
+    return isMcpFailure(mcp) ? mcpFailureLine(file, mcp, addByHand(host)) : MCP_MERGE_LINES[mcp](file, host);
+}
+function printVscodeInstall(result, indent) {
+    const { paths } = result;
+    console.log(`${indent}${mcpInstallLine(paths.mcpConfig, result.mcp, VSCODE_MCP)}`);
+    console.log(`${indent}${VSCODE_INSTRUCTIONS_INSTALL_LINES[result.instructions](paths.instructions)}`);
+    if (paths.profiles.length > 0) {
+        const names = paths.profiles.map((dir) => path.basename(dir)).join(', ');
+        console.log(`${indent}Found VS Code profiles (${names}) under ${path.join(paths.userDir, 'profiles')}: hippo set up the default profile only; copy the "hippo" server and prompts/hippo.instructions.md into a profile to use hippo there.`);
+    }
+}
 function printCopilotInstall(result, indent) {
-    const { paths, mcp } = result;
-    const hooks = result.hooks ? "Installed hippo's Copilot hooks (sessionStart, postToolUseFailure, preCompact, sessionEnd) ->" : "hippo's Copilot hooks are already in";
+    const { paths } = result;
+    const hooks = result.hooks ? `Installed hippo's Copilot hooks (${copilotHookEvents().join(', ')}) ->` : "hippo's Copilot hooks are already in";
     console.log(`${indent}${hooks} ${paths.hooks}`);
-    const mcpLine = isMcpFailure(mcp) ? mcpFailureLine(paths.mcpConfig, mcp, `add this under "mcpServers" by hand: ${copilotMcpSnippet()}`) : MCP_MERGE_LINES[mcp](paths.mcpConfig);
-    console.log(`${indent}${mcpLine}`);
-    console.log(`${indent}${INSTRUCTIONS_INSTALL_LINES[result.instructions](paths.instructions)}`);
+    if (result.mcp === null || result.instructions === null) {
+        console.log(`${indent}No Copilot CLI files in ${path.dirname(paths.mcpConfig)}, so hippo skipped mcp-config.json and copilot-instructions.md, which only the Copilot CLI reads`);
+    }
+    else {
+        console.log(`${indent}${mcpInstallLine(paths.mcpConfig, result.mcp, COPILOT_CLI_MCP)}`);
+        console.log(`${indent}${INSTRUCTIONS_INSTALL_LINES[result.instructions](paths.instructions)}`);
+    }
+    for (const vscode of result.vscode)
+        printVscodeInstall(vscode, indent);
+    if (result.vscode.length > 0)
+        console.log(`${indent}${VSCODE_HOOKS_LINE}`);
     console.log(`${indent}VS Code Copilot runs new hooks in a new chat session.`);
 }
-function printCopilotUninstall(result) {
-    const { paths, mcp } = result;
-    if (result.hooks)
-        console.log(`Removed hippo's Copilot hooks file ${paths.hooks}`);
+/** The lines for one MCP config file; empty when hippo's server was not there. */
+function mcpRemoveLines(file, mcp) {
     if (isMcpFailure(mcp))
-        console.log(mcpFailureLine(paths.mcpConfig, mcp, 'remove the "hippo" server by hand if hippo added it'));
+        return [mcpFailureLine(file, mcp, 'remove the "hippo" server by hand if hippo added it')];
     if (mcp === 'removed')
-        console.log(`Removed the "hippo" MCP server from ${paths.mcpConfig}`);
+        return [`Removed the "hippo" MCP server from ${file}`];
     if (mcp === 'user-owned')
-        console.log(`Left the "hippo" MCP server in ${paths.mcpConfig}: hippo did not write it`);
+        return [`Left the "hippo" MCP server in ${file}: hippo did not write it`];
     if (mcp === 'unreadable')
-        console.log(`WARNING: ${paths.mcpConfig} has comments or is not a JSON object hippo can edit, so it was left unchanged; remove the "hippo" server by hand if hippo added it`);
-    const instructions = INSTRUCTIONS_REMOVE_LINES[result.instructions](paths.instructions);
-    if (instructions)
-        console.log(instructions);
-    if (!result.hooks && mcp === 'absent' && result.instructions === 'absent')
-        console.log('No hippo Copilot hooks, MCP server or instructions block found.');
+        return [`WARNING: ${file} has comments or is not a JSON object hippo can edit, so it was left unchanged; remove the "hippo" server by hand if hippo added it`];
+    return [];
+}
+function printCopilotUninstall(result) {
+    const { paths, mcp } = result;
+    const lines = [];
+    if (result.hooks)
+        lines.push(`Removed hippo's Copilot hooks file ${paths.hooks}`);
+    lines.push(...mcpRemoveLines(paths.mcpConfig, mcp));
+    lines.push(INSTRUCTIONS_REMOVE_LINES[result.instructions](paths.instructions));
+    for (const vscode of result.vscode) {
+        lines.push(...mcpRemoveLines(vscode.paths.mcpConfig, vscode.mcp));
+        lines.push(VSCODE_INSTRUCTIONS_REMOVE_LINES[vscode.instructions](vscode.paths.instructions));
+    }
+    const printed = lines.filter((line) => line !== '');
+    for (const line of printed)
+        console.log(line);
+    if (printed.length === 0)
+        console.log('No hippo Copilot hooks, MCP server or instructions found.');
 }
 function hookUninstall(target) {
     if (target === 'copilot')
@@ -252,7 +299,7 @@ function unpatchAgentFile(hook, target) {
         console.log(`Left the hippo block in ${hook.file}: ${whose}. Delete it by hand if no agent needs it.`);
     }
     else if (existing.includes(HOOK_MARKERS.start)) {
-        fs.writeFileSync(filepath, withoutHookBlock(existing) + '\n', 'utf8');
+        writeFileAtomic(filepath, withoutHookBlock(existing) + '\n');
         console.log(`Removed Hippo hook from ${hook.file}`);
     }
     else {
@@ -266,21 +313,13 @@ function removeLegacyCursorRules() {
     if (old.includes(HOOK_MARKERS.start)) {
         const left = withoutHookBlock(old);
         if (left)
-            fs.writeFileSync(legacy, left + '\n', 'utf8');
+            writeFileAtomic(legacy, left + '\n');
         else
             fs.unlinkSync(legacy);
         console.log(left ? 'Removed the old Hippo hook from .cursorrules' : 'Deleted .cursorrules, which held only the old Hippo hook');
     }
 }
-// `hippo setup` -- one-shot configuration for every AI coding tool on the box.
-// Detection and install logic live in ./hooks.ts.
-export function cmdSetup(flags) {
-    const dryRun = Boolean(flags['dry-run']);
-    const forceAll = Boolean(flags['all']);
-    const tools = detectInstalledTools();
-    const globalRoot = getGlobalRoot();
-    console.log('Hippo setup -- configuring SessionEnd + SessionStart hooks');
-    console.log('');
+function setupDetectedTools(tools, forceAll, dryRun) {
     const jsonTools = tools.filter((t) => t.kind === 'json-hook' && (t.detected || forceAll));
     const wrapperTools = tools.filter((t) => t.kind === 'wrapper' && (t.detected || forceAll));
     const skipped = tools.filter((t) => t.kind === 'json-hook' && !t.detected && !forceAll);
@@ -310,6 +349,17 @@ export function cmdSetup(flags) {
             console.log(`  ${tool.name.padEnd(14)} ${tool.notes}`);
         }
     }
+}
+// `hippo setup` -- one-shot configuration for every AI coding tool on the box.
+// Detection and install logic live in ./hooks.ts.
+export function cmdSetup(flags) {
+    const dryRun = boolFlag(flags, 'dry-run');
+    const forceAll = boolFlag(flags, 'all');
+    const tools = detectInstalledTools();
+    const globalRoot = getGlobalRoot();
+    console.log('Hippo setup -- configuring SessionEnd + SessionStart hooks');
+    console.log('');
+    setupDetectedTools(tools, forceAll, dryRun);
     if (!flags['no-schedule']) {
         console.log('');
         if (dryRun) {
@@ -330,8 +380,11 @@ function setupCopilot(dryRun) {
     const indent = `  ${'copilot'.padEnd(14)} `;
     if (!dryRun)
         return printCopilotInstall(installCopilot(), indent);
-    const { hooks, mcpConfig, instructions } = copilotPaths();
-    console.log(`[dry-run] would install hooks in ${hooks}, the MCP server in ${mcpConfig} and the hippo block in ${instructions}`);
+    const { hooks, mcpConfig, instructions, vscode } = copilotPaths();
+    const cliFiles = isCopilotCliPresent() ? `, the MCP server in ${mcpConfig} and the hippo block in ${instructions}` : '';
+    console.log(`[dry-run] would install hooks in ${hooks}${cliFiles}`);
+    for (const dir of vscode)
+        console.log(`[dry-run] would add the MCP server to ${dir.mcpConfig} and write ${dir.instructions}`);
 }
 function setupJsonTool(tool, dryRun) {
     if (tool.name === 'copilot')
@@ -421,6 +474,14 @@ function setupPluginTool(tool, dryRun) {
         console.log(`  ${tool.name.padEnd(14)} ${bits.join(', ')} -> ${result.pluginPath}`);
     }
 }
+// Three times the 10 minutes POST /v1/sleep allows a consolidation, so a slow real sleep fits and a hung child cannot stall every later workspace.
+const DAILY_STEP_TIMEOUT_MS = 30 * 60_000;
+/** Why a child step failed; a child killed at the deadline says so, since its own message is only the spawn error code. */
+function dailyStepFailure(err, timeoutMs) {
+    if (err instanceof Error && 'code' in err && err.code === 'ETIMEDOUT')
+        return `timed out after ${timeoutMs} ms and was stopped`;
+    return errorMessage(err);
+}
 export function cmdDailyRunner() {
     const globalRoot = getGlobalRoot();
     // No workspace sleep ever opens the global store, yet hooks in folders without a store compact into it.
@@ -439,12 +500,14 @@ export function cmdDailyRunner() {
     console.log(`Running daily maintenance across ${workspaces.length} registered workspace${workspaces.length === 1 ? '' : 's'}...`);
     let processed = 0;
     let failed = 0;
+    const timeout = envDailyStepTimeoutMs() ?? DAILY_STEP_TIMEOUT_MS;
     runDailyMaintenance(workspaces, (cwd, args) => {
         try {
             execFileSync(process.execPath, [process.argv[1], ...args], {
                 cwd,
                 stdio: 'inherit',
                 windowsHide: true,
+                timeout,
             });
             if (args[0] === 'sleep')
                 processed++;
@@ -452,9 +515,12 @@ export function cmdDailyRunner() {
         catch (err) {
             failed++;
             const action = args.join(' ');
-            log.error(`daily-runner failed in ${cwd} during \`${action}\`: ${err.message}`);
+            log.error(`daily-runner failed in ${cwd} during \`${action}\`: ${dailyStepFailure(err, timeout)}`, { workspace: cwd });
         }
     });
     console.log(`Daily maintenance complete: ${processed} workspace${processed === 1 ? '' : 's'} processed, ${failed} command failure${failed === 1 ? '' : 's'}.`);
+    // The scheduler that runs this only sees the exit code, so a failed workspace must not read as a clean run.
+    if (failed > 0)
+        process.exitCode = 1;
 }
 //# sourceMappingURL=setup.js.map

package/dist/cli/shared.d.ts

@@ -1,17 +1,7 @@
-import { type InstallResult } from '../hooks/json-hooks.js';
-import { TaskSnapshot, SessionEvent } from '../store/rows.js';
-import type { HookRuntime } from '../capture-contract.js';
-import type { SessionHandoff } from '../handoff.js';
-import type { SearchResult } from '../search/types.js';
-import { type HippoConfig } from '../config.js';
-import { type ImportReport } from '../agent-memories/report.js';
-import { type ChurnStaleResult } from '../invalidation.js';
-import { type AuditOp } from '../audit.js';
-import { type ServerInfo } from '../server-detect.js';
-import type { RecallSearchOpts } from '../recall-pipeline.js';
-export declare function parseLimitFlag(value: string | boolean | string[] | undefined): number;
-export declare function parseCountFlag(value: string | boolean | string[] | undefined): number;
-export declare function parseBudgetFlag(value: string | boolean | string[] | undefined, fallback: number): number;
+import { type ChurnStaleResult } from '../learn/invalidation.js';
+import { type AuditOp } from '../store/audit.js';
+import { type ServerInfo } from '../server/server-detect.js';
+import type { CliFlags } from './flag-values.js';
 /**
  * Emit an audit event against `hippoRoot`'s db. Opens its own short-lived
  * connection so callers don't have to thread a db handle. Swallows all errors
@@ -40,92 +30,12 @@ export declare function runChurnStaleForRepo(hippoRoot: string, dryRun: boolean)
  * degrading to direct mode.
  */
 export declare function runViaServerIfAvailable(hippoRoot: string, httpFn: (info: ServerInfo, apiKey: string | undefined) => Promise<void>): Promise<boolean>;
-export declare function fmt(n: number, digits?: number): string;
-export declare function recallEntryText(r: SearchResult, query: string, showWhy: boolean, isGlobal: boolean): string;
-export declare function recallHeading(entries: number, tokens: number, query: string): string;
-/** One line when an agent memory import moved anything; its warnings go to stderr. */
-export declare function printAgentImport(report: ImportReport, indent?: string): void;
 /** True, after one line, on a shared store: this account's commits and agent notes are not its members' memories. */
 export declare function skipLearnOnSharedStore(hippoRoot: string): boolean;
-/** Adds hippo's two Codex hooks and says what changed; each install ends on the trust reminder, since Codex skips an untrusted hook. */
-export declare function installCodexMemoryHooks(indent: string): void;
-/** The one line init, hook install, hook uninstall and setup print when Claude Code's settings.json is not JSON hippo can edit and so was left unchanged; true when it printed. */
-export declare function warnClaudeSettingsUnusable(result: Pick<InstallResult, 'settingsPath' | 'invalidJson'>, indent: string, action?: 'install' | 'uninstall'): boolean;
-/**
- * Set up a machine-level daily runner that sweeps all registered Hippo
- * workspaces.
- * Linux/macOS: writes to user crontab.
- * Windows: creates a scheduled task.
- * Skips if already installed.
- */
-export declare function setupDailySchedule(globalRoot: string): void;
-export type CliFlags = Record<string, string | boolean | string[]>;
-/** What the command table hands each verb's run(). */
-export interface CommandContext {
-    readonly hippoRoot: string;
-    readonly args: string[];
-    readonly flags: CliFlags;
-}
-export type EngineFlags = Pick<RecallSearchOpts, 'usePhysics' | 'physicsConfig' | 'mmr' | 'mmrLambda' | 'localBump'>;
-export declare function parseAsOfFlag(flags: CliFlags): string | undefined;
-/** --physics forces physics, --classic forces BM25+cosine, else physics unless the config turns it off. */
-export declare function engineFlags(flags: CliFlags, config: HippoConfig): EngineFlags;
-/**
- * Detached worker that counts re-reads, runs sleep, then capture. Invoked via the internal
- * `__session-end-worker` subcommand (not user-facing). Failures in one stage
- * do not block the other.
- */
-/** A folder without its own store never sleeps at session end, so its project's agent notes go to the global store here. */
-export declare function logSessionEndImport(logFile: string | null, transcriptPath: string | undefined): void;
-/**
- * Best-effort log line for the snapshot-close step in
- * `cmdSessionEndWorker`. `cmdSleep`/`cmdCapture` each tee console output to
- * `logFile` only for their own duration (the tee is restored before this
- * runs), so a plain `console.log` here would be silently discarded under
- * the detached worker's `stdio: 'ignore'` — write straight to the file
- * instead, matching capture.ts's `appendPreCompactLog` convention.
- */
-export declare function appendSessionEndCloseLog(logFile: string | null, message: string, opts?: {
-    startFresh?: boolean;
-}): void;
-export declare function printActiveTaskSnapshot(snapshot: TaskSnapshot): void;
-export declare function printSessionEvents(events: SessionEvent[]): void;
-export declare function printHandoff(handoff: SessionHandoff): void;
-export declare function cardStringFlag(flags: Record<string, string | boolean | string[]>, key: string): string | undefined;
-export declare function hostSessionId(): string | undefined;
-/**
- * Compaction drops the pinned blocks the per-prompt hook injected
- * earlier, so record a `reset` for the payload's session and the next prompt
- * injects again even if nothing changed. `requiredSource` limits it to hook
- * payloads with that `source` (SessionStart fires for other reasons too).
- * Best-effort and silent: a malformed payload records nothing.
- */
-export declare function resetHookInjection(hippoRoot: string, stdinText: string | undefined, requiredSource: string | null): void;
-/**
- * Run `fn` with console.log captured; returns the captured lines joined by
- * newlines (what the same calls would have printed, minus the final newline).
- */
-export declare function captureConsole(fn: () => void): string;
-/**
- * The store a Claude Code hook writes to: the project store when there is
- * one, else an existing global store, else the project path (which the hook
- * then skips, since hooks fire in every directory and must not create one).
- * Pre-compact and compact-resume must agree, or a snapshot saved to one store
- * is looked for in the other.
- */
-export declare function hookStoreRoot(hippoRoot: string): string;
-/** `--runtime copilot`, or `--format copilot` on `hippo context`, marks a Copilot hook: the flag decides, never the payload. */
-export declare function hookRuntime(flags: CliFlags): HookRuntime;
-/** A Copilot hook's project root, from the payload's `cwd`, since VS Code runs user-level hooks in the home folder; other runtimes keep `hippoRoot`. */
-export declare function payloadCwdRoot(hippoRoot: string, stdinText: string | undefined, runtime: HookRuntime): string;
 export declare function learnFromRepo(hippoRoot: string, repoPath: string, days: number, label?: string): {
     added: number;
     skipped: number;
     lowInfo: number;
 };
-export declare function resolveAuthRoot(hippoRoot: string, flags: Record<string, string | boolean | string[]>): string;
-/** Hook commands share one handle per store and wait at most HOOK_DB_WAIT_MS for a lock; a store still busy after that skips the hook's work with one warning, exit 0. */
-export declare function runHookWithStores<T>(fn: () => T | Promise<T>): Promise<T | undefined>;
-/** Whether this session sits in the pilot's holdout arm; off at rate 0 and with no session id. */
-export declare function inPilotHoldout(hippoRoot: string, tenantId: string, sessionId: string | undefined, write: boolean): boolean;
+export declare function resolveAuthRoot(hippoRoot: string, flags: CliFlags): string;
 //# sourceMappingURL=shared.d.ts.map