hippo-memory 1.59.0 → 1.60.0

package/dist/api.d.ts

@@ -95,6 +95,8 @@ export { classifyOriginProject } from './project-identity.js';
  * flagged rows with no project origin never ambient-inject.
  */
 export declare function ambientSecretAdmit(e: MemoryEntry, currentProjectName: string): boolean;
+/** Most rows per store a no-query context reads; past it, ranking and ambientState see the strongest by decay. */
+export declare const CONTEXT_CANDIDATE_CAP = 2000;
 export declare function oneCopyPerMemory(local: readonly MemoryEntry[], global: readonly MemoryEntry[], now: Date): [MemoryEntry[], MemoryEntry[]];
 export interface RememberOpts {
     content: string;

package/dist/api.js

@@ -9,7 +9,7 @@
 import { openHippoDb, closeHippoDb } from './db.js';
 import { BadRequestError, ConflictError, ForbiddenError, NotFoundError } from './api-errors.js';
 export { ApiError, BadRequestError, ConflictError, ForbiddenError, NotFoundError } from './api-errors.js';
-import { writeEntry, writeEntryDbOnly, strengthenRetrieved, stampOriginProject, writeEntryMirrors, readEntry, deleteEntry, loadRecallSearchEntries, loadEntriesByIds, loadChildrenOf, loadFreshRawMemories, loadSessionRawMemories, countSessionRawMemories, DEFAULT_SEARCH_CANDIDATE_LIMIT, removeEntryMirrors, loadActiveTaskSnapshot, loadFreshActiveTaskSnapshot, loadLatestHandoff, listSessionEvents, SNAPSHOT_AMBIENT_MAX_AGE_MS, loadIndex, saveIndex, loadAllEntries, loadAmbientCandidates, updateStats, isInitialized, markSummaryDirtyInTx, auditRejectionRefusal, memoriesBackingObjects, } from './store.js';
+import { writeEntry, writeEntryDbOnly, strengthenRetrieved, stampOriginProject, writeEntryMirrors, readEntry, deleteEntry, loadRecallSearchEntries, loadEntriesByIds, loadChildrenOf, loadFreshRawMemories, loadSessionRawMemories, countSessionRawMemories, DEFAULT_SEARCH_CANDIDATE_LIMIT, removeEntryMirrors, loadActiveTaskSnapshot, loadFreshActiveTaskSnapshot, loadLatestHandoff, listSessionEvents, SNAPSHOT_AMBIENT_MAX_AGE_MS, loadIndex, saveIndex, loadAllEntries, loadAmbientCandidates, loadContextCandidates, updateStats, isInitialized, markSummaryDirtyInTx, auditRejectionRefusal, memoriesBackingObjects, } from './store.js';
 import { RejectedValueError } from './rejection.js';
 import { rejectValue, unrejectValue, listRejectionsForTenant } from './reject-flow.js';
 import { listDormantRows, readDormantSnapshot, deleteDormantRow, hasDormantRow, } from './dormant.js';
@@ -17,6 +17,7 @@ import { recordTokenUse, summarizeTokenUse } from './token-ledger.js';
 import { detectInstruction } from './instruction-detect.js';
 import { quarantineScopeFor, recordQuarantine, getQuarantineRow, listQuarantineRows, approveQuarantineRow, rejectQuarantineRow, } from './quarantine.js';
 import { summarizeFailures } from './failure-log.js';
+import { log } from './log.js';
 import { formatHandoffEvidenceLine } from './handoff.js';
 import { createMemory, createSuccessor, applyOutcome, calculateStrength, markRetrieved, CHURN_STALE_TAG, COMPACTION_MEMORY_TAG, } from './memory.js';
 import { appendAuditEvent, reportAuditWriteFailure, auditQueryFields, queryAuditEvents, auditMemories, isContentWorthStoring, } from './audit.js';
@@ -128,10 +129,15 @@ export function ambientSecretAdmit(e, currentProjectName) {
         return false;
     return origin === currentProjectName;
 }
+/** Most rows per store a no-query context reads; past it, ranking and ambientState see the strongest by decay. */
+export const CONTEXT_CANDIDATE_CAP = 2000;
 // The pinned-only branch needs pins and recent-N candidates, not the corpus; `recall` applies there only.
-function loadAmbientEntries(hippoRoot, tenantId, pinnedOnly, includeRecent, admit, recall, onQualityDrop) {
-    if (!pinnedOnly)
-        return { entries: loadAllEntries(hippoRoot, tenantId).filter(admit) };
+// Without `window` the whole store loads: a local-only query searches every local row.
+function loadAmbientEntries(hippoRoot, tenantId, pinnedOnly, includeRecent, admit, recall, onQualityDrop, window) {
+    if (!pinnedOnly) {
+        const rows = window ? loadContextCandidates(hippoRoot, tenantId, window) : loadAllEntries(hippoRoot, tenantId);
+        return { entries: rows.filter(admit) };
+    }
     // DF3's quality floor runs on the recent-N slice AFTER this load, so the load
     // counts by it too, or it stops short of a store whose newest rows are junk.
     const admitAmbient = (e) => {
@@ -1314,7 +1320,7 @@ export function supersede(ctx, oldId, newContent) {
             writeEntryMirrors(ctx.hippoRoot, newEntry);
         }
         catch (mirrorErr) {
-            console.error('supersede: mirror write failed (non-fatal, will self-heal):', mirrorErr);
+            log.error(`supersede: mirror write failed (non-fatal, will self-heal): ${mirrorErr instanceof Error ? mirrorErr.message : String(mirrorErr)}`);
         }
     }
     finally {
@@ -1359,7 +1365,7 @@ export function archiveRaw(ctx, id, reason, opts = {}) {
             mirrorOk = true;
         }
         catch (mirrorErr) {
-            console.error(`archiveRaw: mirror cleanup failed for ${id} (will retry via reaper on next openHippoDb):`, mirrorErr);
+            log.error(`archiveRaw: mirror cleanup failed for ${id} (will retry via reaper on next openHippoDb): ${mirrorErr instanceof Error ? mirrorErr.message : String(mirrorErr)}`);
         }
         if (mirrorOk) {
             // Stamp mirror_cleaned_at now so the next openHippoDb reaper SELECT
@@ -1694,12 +1700,22 @@ export async function getContext(ctx, opts = {}) {
     const admit = (e) => !e.superseded_by && !isOwnCompactionItem(e) && ambientAdmit(e);
     const loadAdmit = obs ? obs.watchAdmit(admit) : admit;
     const qualityDrop = (isGlobal) => obs && !promptRecallPending ? (e) => obs.qualityDropped(e, isGlobal) : undefined;
+    // The window's predicates are ones admit applies anyway, so below the cap the admitted rows are unchanged.
+    const searchesLocalRows = query !== '*' && !(hasGlobal && !primaryIsGlobal);
+    const window = pinnedOnly || searchesLocalRows
+        ? undefined
+        : {
+            exactScope,
+            project: includeCrossProject || currentProjectName === '' ? undefined : currentProjectName,
+            cap: CONTEXT_CANDIDATE_CAP,
+            now: evalNow(),
+        };
     // Tenant-scoped loads (v1.11.1 lesson: NEVER resolveTenantId({}) here).
     const localLoad = hasLocal
-        ? loadAmbientEntries(ctx.hippoRoot, ctx.tenantId, pinnedOnly, includeRecent, loadAdmit, recallRequest, qualityDrop(primaryIsGlobal))
+        ? loadAmbientEntries(ctx.hippoRoot, ctx.tenantId, pinnedOnly, includeRecent, loadAdmit, recallRequest, qualityDrop(primaryIsGlobal), window)
         : { entries: [] };
     const globalLoad = hasGlobal && !primaryIsGlobal
-        ? loadAmbientEntries(globalRoot, ctx.tenantId, pinnedOnly, includeRecent, loadAdmit, recallRequest, qualityDrop(true))
+        ? loadAmbientEntries(globalRoot, ctx.tenantId, pinnedOnly, includeRecent, loadAdmit, recallRequest, qualityDrop(true), window)
         : { entries: [] };
     let localEntries = localLoad.entries;
     let globalEntries = globalLoad.entries;
@@ -2402,7 +2418,7 @@ export function quarantineApprove(ctx, id) {
             writeEntryMirrors(ctx.hippoRoot, restored);
     }
     catch (err) {
-        console.error(`quarantine: mirror rewrite failed for ${id}: ${err instanceof Error ? err.message : String(err)}`);
+        log.error(`quarantine: mirror rewrite failed for ${id}: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
 /** Keep a quarantined memory hidden for good. Admin only; the raw row is untouched (append-only). */

package/dist/audit.js

@@ -330,6 +330,7 @@ function safeJsonParse(raw) {
         return v instanceof Object ? v : {};
     }
     catch {
+        // Malformed metadata reads as empty so the audit row itself stays listable.
         return {};
     }
 }

package/dist/autolearn.js

@@ -8,6 +8,7 @@ import { loadAllEntries } from './store.js';
 import { textOverlap } from './search.js';
 import { isContentWorthStoring } from './audit.js';
 import { redactSecretsStrict } from './secret-detect.js';
+import { log } from './log.js';
 /** A memory of a failed command, "Command '<cmd>' failed: <truncated stderr>"; no store is in reach, so `hippo watch` re-derives its half-life from the store's config. */
 export function captureError(exitCode, stderr, command, tenantId) {
     // Truncate to first 500 chars to avoid storing megabytes of build logs
@@ -154,7 +155,8 @@ export function isGitRepo(cwd) {
         });
         return raw.trim() === 'true';
     }
-    catch {
+    catch (err) {
+        log.debug(`autolearn: not a git repo: ${err instanceof Error ? err.message : String(err)}`);
         return false;
     }
 }
@@ -169,7 +171,8 @@ export function fetchGitLog(cwd, days) {
         ], { encoding: 'utf8', cwd, timeout: 10000, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
         return raw;
     }
-    catch {
+    catch (err) {
+        log.debug(`autolearn: git log unavailable: ${err instanceof Error ? err.message : String(err)}`);
         return '';
     }
 }

package/dist/capture.js

@@ -26,6 +26,7 @@ import { openHippoDb, closeHippoDb } from './db.js';
 import { loadConfig } from './config.js';
 import { classifyOriginProject } from './project-identity.js';
 import { isObjectLike, isStringValue, readClaudeCodePreCompact } from './capture-contract.js';
+import { log } from './log.js';
 // Sentence-level patterns
 //
 // T1 (DF2): each pattern now carries TWO capture groups — group 1 is the
@@ -521,7 +522,7 @@ export function collectSessionTurns(jsonl, visit) {
             entry = JSON.parse(line);
         }
         catch {
-            continue;
+            continue; // a torn or partial transcript line carries no turn
         }
         if (!isObjectLike(entry) || !('type' in entry))
             continue;
@@ -660,7 +661,7 @@ export function resolveLastSessionTranscript(explicit, stdinText, opts) {
         }
     }
     catch {
-        return null;
+        return null; // an unlistable projects dir means no transcript to find; the caller prints that
     }
     return newest?.path ?? null;
 }
@@ -698,7 +699,7 @@ function beginLogTee(logFile) {
         fs.appendFileSync(logFile, `[hippo] ${new Date().toISOString()} capturing session...\n`, 'utf8');
     }
     catch (err) {
-        console.error(`[hippo] warning: could not open log file ${logFile}: ${errorMessage(err)}`);
+        log.warn(`could not open log file ${logFile}: ${errorMessage(err)}`);
         return () => { };
     }
     const origStdoutWrite = process.stdout.write.bind(process.stdout);
@@ -734,6 +735,7 @@ function beginLogTee(logFile) {
         process.stderr.write = origStderrWrite;
     };
 }
+// Console lines here are the `hippo capture` command's printed result, so they stay off the logger.
 function cmdCaptureCore(hippoRoot, options) {
     const useGlobal = options.global;
     const targetRoot = useGlobal ? getGlobalRoot() : hippoRoot;
@@ -993,7 +995,7 @@ function lastPlainUserMessage(jsonl) {
             entry = JSON.parse(lines[i]);
         }
         catch {
-            continue;
+            continue; // the tail read can start mid-line; skip the torn fragment
         }
         if (!isObjectLike(entry))
             continue;
@@ -1023,7 +1025,7 @@ function lastAssistantTextBlock(jsonl) {
             entry = JSON.parse(lines[i]);
         }
         catch {
-            continue;
+            continue; // the tail read can start mid-line; skip the torn fragment
         }
         if (!isObjectLike(entry))
             continue;
@@ -1085,7 +1087,7 @@ function isReadableFile(filePath) {
         return true;
     }
     catch {
-        return false;
+        return false; // missing and unreadable both mean "no file" to the caller
     }
 }
 /** PreCompact stdout is the summariser's instructions; sent before the snapshot work because a locked store can run the hook past its 30 s limit, and via writeSync because process.exit drops buffered pipe output. */

package/dist/cli.d.ts

@@ -36,6 +36,7 @@
 import { MemoryEntry } from './memory.js';
 /** Test-only: reset the module-level recall-history Map. Call from beforeEach. */
 export declare function __resetSessionRecallHistoryCli(): void;
+import { type CliFlags } from './cli/shared.js';
 export declare const BOOLEAN_FLAGS: ReadonlySet<string>;
 export declare const KNOWN_FLAGS: ReadonlySet<string>;
 export declare function parseArgs(argv: string[]): {
@@ -54,7 +55,361 @@ export declare function printContextMarkdown(items: Array<{
     showStrength?: boolean;
     heading?: string;
 }): void;
+interface CommandContext {
+    readonly hippoRoot: string;
+    readonly args: string[];
+    readonly flags: CliFlags;
+}
+declare function handleRemember({ hippoRoot, args, flags }: CommandContext): Promise<void>;
+declare function handleRecall({ hippoRoot, args, flags }: CommandContext): Promise<void>;
+declare function handleDrill({ hippoRoot, args, flags }: CommandContext): void;
+declare function handleAssemble({ hippoRoot, args, flags }: CommandContext): void;
+declare function handleSupersede({ hippoRoot, args, flags }: CommandContext): void;
+declare function handleExplain({ hippoRoot, args, flags }: CommandContext): Promise<void>;
+declare function handleEval({ hippoRoot, args, flags }: CommandContext): Promise<void>;
+declare function handleTrace({ hippoRoot, args, flags }: CommandContext): void;
+declare function handlePreCompact({ hippoRoot, flags }: CommandContext): Promise<void>;
+declare function handlePostCompact({ hippoRoot, flags }: CommandContext): Promise<void>;
+declare function handleCaptureError({ hippoRoot }: CommandContext): Promise<void>;
+declare function handleCompactResume({ hippoRoot }: CommandContext): Promise<void>;
+declare function handleAudit({ hippoRoot, args, flags }: CommandContext): void;
+declare function handleCorrectionLatency({ hippoRoot, flags }: CommandContext): void;
+declare function handleProvenance({ hippoRoot, flags }: CommandContext): void;
+declare function handleDoctor({ flags }: CommandContext): void;
+declare function handleSupportBundle({ flags }: CommandContext): void;
+declare function handleForget({ hippoRoot, args, flags }: CommandContext): Promise<void>;
+declare function handleInspect({ hippoRoot, args }: CommandContext): void;
+declare function handleContext({ hippoRoot, args, flags }: CommandContext): Promise<void>;
+declare function handleWatch({ hippoRoot, args }: CommandContext): Promise<void>;
+declare function handlePromote({ hippoRoot, args }: CommandContext): Promise<void>;
+declare function handleShare({ hippoRoot, args, flags }: CommandContext): void;
+declare function handlePeers({ flags }: CommandContext): void;
+declare function handleExport({ hippoRoot, args, flags }: CommandContext): void;
+declare function handleCapture({ hippoRoot, flags }: CommandContext): Promise<void>;
+declare function handleDashboard({ hippoRoot, flags }: CommandContext): Promise<void>;
+declare function handleMcp(): Promise<void>;
+declare function handleServe({ hippoRoot, flags }: CommandContext): Promise<void>;
+declare function handleInvalidate({ hippoRoot, args, flags }: CommandContext): void;
+/** Every verb main() dispatches, keyed by name, with its handler, aliases and help blocks. */
+export declare const COMMANDS: {
+    init: {
+        run: ({ hippoRoot, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    remember: {
+        run: typeof handleRemember;
+        usage: string[];
+    };
+    recall: {
+        run: typeof handleRecall;
+        usage: string[];
+    };
+    drill: {
+        run: typeof handleDrill;
+        usage: string[];
+    };
+    assemble: {
+        run: typeof handleAssemble;
+        usage: string[];
+    };
+    supersede: {
+        run: typeof handleSupersede;
+        usage: string[];
+    };
+    explain: {
+        run: typeof handleExplain;
+        usage: string[];
+    };
+    eval: {
+        run: typeof handleEval;
+        usage: string[];
+    };
+    trace: {
+        run: typeof handleTrace;
+        usage: string[];
+    };
+    refine: {
+        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
+        usage: string[];
+    };
+    sleep: {
+        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
+        usage: string[];
+    };
+    'last-sleep': {
+        run: ({ flags }: CommandContext) => void;
+        usage: string[];
+    };
+    'session-end': {
+        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
+        usage: string[];
+    };
+    '__session-end-worker': {
+        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
+        usage: never[];
+    };
+    'pre-compact': {
+        run: typeof handlePreCompact;
+        usage: string[];
+    };
+    'post-compact': {
+        run: typeof handlePostCompact;
+        usage: string[];
+    };
+    'capture-error': {
+        run: typeof handleCaptureError;
+        usage: string[];
+    };
+    'compact-resume': {
+        run: typeof handleCompactResume;
+        usage: string[];
+    };
+    'codex-run': {
+        run: ({ hippoRoot, args }: CommandContext) => void;
+        usage: string[];
+    };
+    '__codex-session-end-worker': {
+        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
+        usage: never[];
+    };
+    dedup: {
+        run: ({ hippoRoot, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    dag: {
+        run: ({ hippoRoot, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    auth: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    goal: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    slack: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    github: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
+        usage: string[];
+    };
+    audit: {
+        run: typeof handleAudit;
+        usage: string[];
+    };
+    'correction-latency': {
+        run: typeof handleCorrectionLatency;
+        usage: string[];
+    };
+    provenance: {
+        run: typeof handleProvenance;
+        usage: string[];
+    };
+    status: {
+        run: ({ hippoRoot }: CommandContext) => void;
+        usage: string[];
+    };
+    outcome: {
+        run: ({ hippoRoot, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    conflicts: {
+        run: ({ hippoRoot, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    resolve: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    reject: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    rejections: {
+        run: ({ hippoRoot, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    unreject: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    dormant: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    projects: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
+        usage: string[];
+    };
+    quarantine: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    tokens: {
+        run: ({ hippoRoot, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    failures: {
+        run: ({ hippoRoot, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    doctor: {
+        run: typeof handleDoctor;
+        usage: string[];
+    };
+    'support-bundle': {
+        run: typeof handleSupportBundle;
+        usage: string[];
+    };
+    snapshot: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    session: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    handoff: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    card: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    predict: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    current: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    forget: {
+        run: typeof handleForget;
+        usage: string[];
+    };
+    inspect: {
+        run: typeof handleInspect;
+        usage: string[];
+    };
+    context: {
+        run: typeof handleContext;
+        usage: string[];
+    };
+    hook: {
+        run: ({ args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    setup: {
+        run: ({ flags }: CommandContext) => void;
+        usage: string[];
+    };
+    'daily-runner': {
+        run: () => void;
+        usage: string[];
+    };
+    embed: {
+        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
+        usage: string[];
+    };
+    watch: {
+        run: typeof handleWatch;
+        usage: string[];
+    };
+    learn: {
+        run: ({ hippoRoot, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    promote: {
+        run: typeof handlePromote;
+        usage: string[];
+    };
+    sync: {
+        run: ({ hippoRoot, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    share: {
+        run: typeof handleShare;
+        usage: string[];
+    };
+    peers: {
+        run: typeof handlePeers;
+        usage: string[];
+    };
+    import: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    export: {
+        run: typeof handleExport;
+        usage: string[];
+    };
+    capture: {
+        run: typeof handleCapture;
+        usage: string[];
+    };
+    dashboard: {
+        run: typeof handleDashboard;
+        usage: string[];
+    };
+    wm: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    mcp: {
+        run: typeof handleMcp;
+        usage: string[];
+    };
+    serve: {
+        run: typeof handleServe;
+        usage: string[];
+    };
+    invalidate: {
+        run: typeof handleInvalidate;
+        usage: string[];
+    };
+    decide: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    incident: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    process: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    policy: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    skill: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    brief: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        aliases: string[];
+        usage: string[];
+    };
+    note: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        aliases: string[];
+        usage: string[];
+    };
+    graph: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+};
 export declare function usageText(): string;
+/** One verb's help blocks as `hippo <verb> --help` prints them, or null for a verb with none. */
 export declare function verbUsage(verb: string): string | null;
 export declare function runCli(argv?: string[]): Promise<void>;
+export {};
 //# sourceMappingURL=cli.d.ts.map