hippo-memory 1.69.0 → 1.70.0

package/dist/cli/compact-resume-payload.d.ts

@@ -0,0 +1,8 @@
+export interface CompactResumePayload {
+    suppressOutput: boolean;
+    payloadSessionId: string | null;
+    boundary: boolean;
+}
+/** Fail-closed read of the SessionStart payload: only a manual run or a main-session `source: 'compact'` payload may print. */
+export declare function readCompactResumePayload(stdinText: string | undefined, stdinTimedOut: boolean): CompactResumePayload;
+//# sourceMappingURL=compact-resume-payload.d.ts.map

package/dist/cli/compact-resume-payload.js

@@ -0,0 +1,39 @@
+// The payload gate for `hippo compact-resume`.
+import { isSubagentPayload } from '../store/token-ledger.js';
+/** Fail-closed read of the SessionStart payload: only a manual run or a main-session `source: 'compact'` payload may print. */
+export function readCompactResumePayload(stdinText, stdinTimedOut) {
+    // An older Claude Code that ignores `matcher: 'compact'` runs this on every SessionStart, so a parsed payload with any other source stays silent.
+    const nonEmptyStdin = !!stdinText && stdinText.trim() !== '';
+    // Without a payload session_id the cross-restore guard can never fire, so a timed-out empty read must not reach the print path.
+    let suppressOutput = stdinTimedOut && !nonEmptyStdin;
+    let payloadSessionId = null;
+    // A boundary is a manual run or a payload that says it follows a compaction; anything else is not one.
+    let boundary = !nonEmptyStdin && !stdinTimedOut;
+    if (nonEmptyStdin) {
+        let payload = null;
+        try {
+            payload = JSON.parse(stdinText.trim());
+        }
+        catch {
+            // Malformed JSON is handled as a null payload by the fail-closed check below.
+            payload = null;
+        }
+        if (!payload || typeof payload !== 'object') {
+            // Fail closed on malformed non-empty stdin; only a TTY/no-stdin manual run, which never reaches here, prints.
+            suppressOutput = true;
+        }
+        else {
+            // Fail closed on structurally incomplete payloads too ({}, [], source missing/non-string): a real SessionStart payload always carries source.
+            // A sub-agent's payload carries its parent's session id, so the mismatch guard would pass and restore the parent's snapshot into it.
+            boundary = payload.source === 'compact';
+            if (payload.source !== 'compact' || isSubagentPayload(stdinText)) {
+                suppressOutput = true;
+            }
+            if (typeof payload.session_id === 'string') {
+                payloadSessionId = payload.session_id;
+            }
+        }
+    }
+    return { suppressOutput, payloadSessionId, boundary };
+}
+//# sourceMappingURL=compact-resume-payload.js.map

package/dist/cli/context.d.ts

@@ -1,15 +1,4 @@
-import { MemoryEntry } from '../memory.js';
-import { type CommandContext } from './shared.js';
-export declare function cmdContext(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>, stdinText?: string): Promise<void>;
-/** @internal Exported for the render snapshot test; not a stable public API. */
-export declare function printContextMarkdown(items: Array<{
-    entry: MemoryEntry;
-    score: number;
-    tokens: number;
-    isGlobal: boolean;
-}>, totalTokens: number, framing?: string, opts?: {
-    showStrength?: boolean;
-    heading?: string;
-}): void;
+import { type CliFlags, type CommandContext } from './flag-values.js';
+export declare function cmdContext(hippoRoot: string, args: string[], flags: CliFlags, stdinText?: string): Promise<void>;
 export declare function handleContext({ hippoRoot, args, flags }: CommandContext): Promise<void>;
 //# sourceMappingURL=context.d.ts.map

package/dist/cli/context.js

@@ -1,51 +1,25 @@
 // The `hippo context` verb, which the per-prompt hook also runs; main() loads it lazily from the command table.
-import * as path from 'path';
-import { createDeliveryRecorder } from '../delivery-recorder.js';
-import { loadConfig } from '../config.js';
-import { blockHash, estimateTokens, isSubagentPayload, recordTokenUse } from '../token-ledger.js';
-import { isGlobalStoreRoot } from '../project-identity.js';
-import { autoDetectContext } from '../context-auto.js';
-import { detectScope } from '../scope.js';
-import { ledgerRoot, withLedgerDb } from '../ledger-db.js';
-import { readHookStdin } from '../stdin.js';
-import * as api from '../api.js';
-import { resolveTenantId } from '../tenant.js';
-import { renderAmbientSummary } from '../ambient.js';
-import { contextBlockLines, contextCost, crossProjectLines, settleTokens } from '../context-render.js';
-import { additionalContextOutput, flushDeliveryRecorder, hasContextData, sessionStartEnvelope, toRenderItems, } from '../prompt-hook.js';
-import { printError } from './output.js';
-import { parseLimitFlag, parseCountFlag, parseBudgetFlag, requireInit, printActiveTaskSnapshot, printSessionEvents, printHandoff, hostSessionId, captureConsole, hookStoreRoot, hookRuntime, payloadCwdRoot, runHookWithStores, inPilotHoldout, } from './shared.js';
+import { isSubagentPayload } from '../store/token-ledger.js';
+import { estimateTokens } from '../util/token-text.js';
+import { autoDetectContext } from '../api/context-auto.js';
+import { detectScope } from '../sharing/scope.js';
+import { bookLedgerTurn } from '../api/ledger-db.js';
+import { readHookStdin } from './stdin.js';
+import * as api from '../api/index.js';
+import { resolveTenantId } from '../store/tenant.js';
+import { renderAmbientSummary } from '../core/ambient.js';
+import { contextBlockLines, contextCost, crossProjectLines, settleTokens } from '../api/context-render.js';
+import { additionalContextOutput, flushDeliveryRecorder, hasContextData, sessionStartEnvelope, toRenderItems, } from '../api/prompt-hook.js';
+import { parseLimitFlag, parseCountFlag, parseBudgetFlag, flagIsTrue } from './flag-values.js';
+import { requireInit } from './shared.js';
+import { printActiveTaskSnapshot, printSessionEvents, printHandoff, captureConsole } from './print.js';
+import { hostSessionId, hookStoreRoot, hookRuntime, payloadCwdRoot, runHookWithStores, inPilotHoldout, startDeliveryRecorder } from './hook-runtime.js';
 export async function cmdContext(hippoRoot, args, flags, stdinText) {
-    const rec = startDeliveryRecorder(hippoRoot, flags, stdinText);
+    const rec = flagIsTrue(flags, 'pinned-only') ? startDeliveryRecorder(hippoRoot, stdinText, hookRuntime(flags)) : null;
     // No try/finally: a render throw keeps its own exit code and writes no event.
     await renderContext(hippoRoot, args, flags, stdinText, rec);
     flushDeliveryRecorder(rec);
 }
-/** A delivery recorder for a pinned-only call when its ledger store enables one, else null; never throws. */
-function startDeliveryRecorder(hippoRoot, flags, stdinText) {
-    if (flags['pinned-only'] !== true)
-        return null;
-    try {
-        // The same store withLedgerDb writes the token ledger to, so its config governs both.
-        const root = ledgerRoot(hippoRoot);
-        if (root === null || !loadConfig(root).deliveryLedger.enabled)
-            return null;
-        return createDeliveryRecorder({
-            root,
-            storeHash: blockHash(path.resolve(root)),
-            writeStore: isGlobalStoreRoot(root) ? 'global' : 'local',
-            tenantId: resolveTenantId({}),
-            stdinText,
-            envSessionId: hostSessionId(),
-            runtime: hookRuntime(flags) === 'copilot' ? 'copilot' : undefined,
-        });
-    }
-    catch (error) {
-        // The hook's one-line stderr contract pins this exact text, so it bypasses the leveled logger.
-        printError(`[hippo] delivery ledger skipped:${error instanceof Error ? error.message : String(error)}`);
-        return null;
-    }
-}
 /** The hook payload's session id and raw prompt; a malformed or empty payload yields neither. */
 function readHookPayload(stdinText) {
     let sessionId;
@@ -68,7 +42,7 @@ function readHookPayload(stdinText) {
 async function renderContext(hippoRoot, args, flags, stdinText, rec) {
     // --pinned-only fires on every prompt, even where no local .hippo exists, so it skips requireInit
     // and api.getContext falls back to global-only.
-    const pinnedOnly = flags['pinned-only'] === true;
+    const pinnedOnly = flagIsTrue(flags, 'pinned-only');
     if (!pinnedOnly) {
         requireInit(hippoRoot);
     }
@@ -86,15 +60,8 @@ async function renderContext(hippoRoot, args, flags, stdinText, rec) {
         return;
     }
     // --auto shells out to git, so it stays CLI-side; api.getContext stays host-agnostic and falls back to '*'.
-    let query = args.join(' ').trim();
-    if (!query && flags['auto']) {
-        query = autoDetectContext();
-    }
-    const ctx = {
-        hippoRoot,
-        tenantId: resolvedTenant,
-        actor: api.adminActor('cli'),
-    };
+    const query = contextQuery(args, flags);
+    const ctx = { hippoRoot, tenantId: resolvedTenant, actor: api.adminActor('cli') };
     const format = String(flags['format'] ?? 'markdown');
     const framing = String(flags['framing'] ?? 'observe');
     const opts = buildContextOpts(flags, { query, budget, pinnedOnly, format, framing, session, rec });
@@ -105,6 +72,13 @@ async function renderContext(hippoRoot, args, flags, stdinText, rec) {
     }
     const envelope = format === 'copilot' ? sessionStartEnvelope(stdinText) : undefined;
     const view = { hippoRoot, tenantId: ctx.tenantId, ledgerSessionId, payloadSessionId, pinnedOnly, framing, rec, result, envelope };
+    renderContextView(view, format, query);
+}
+function contextQuery(args, flags) {
+    const query = args.join(' ').trim();
+    return !query && flags['auto'] ? autoDetectContext() : query;
+}
+function renderContextView(view, format, query) {
     if (format === 'json') {
         renderContextJson(view, query);
     }
@@ -135,7 +109,7 @@ function buildContextOpts(flags, input) {
     const ctxExplicitScope = flags['scope'] !== undefined ? String(flags['scope']).trim() : null;
     const ctxActiveScope = ctxExplicitScope || detectScope();
     // --cross-project re-includes other-project memories, rendered under their own section.
-    const crossProject = flags['cross-project'] === true;
+    const crossProject = flagIsTrue(flags, 'cross-project');
     return {
         q: input.query,
         budget: input.budget,
@@ -174,12 +148,12 @@ function renderContextJson(view, query) {
     });
     console.log(jsonText);
     rec?.delivered({ state: 'sent', emittedText: `${jsonText}\n` });
-    withLedgerDb(view.hippoRoot, (db) => {
-        recordTokenUse(db, {
-            tenantId: view.tenantId, sessionId: view.ledgerSessionId, surface: view.pinnedOnly ? 'hook' : 'context',
-            event: 'inject', items: output.length, tokens: estimateTokens(jsonText),
-        });
-        flushDeliveryRecorder(rec, db);
+    bookLedgerTurn(view.hippoRoot, {
+        uses: [{
+                tenantId: view.tenantId, sessionId: view.ledgerSessionId, surface: view.pinnedOnly ? 'hook' : 'context',
+                event: 'inject', items: output.length, tokens: estimateTokens(jsonText),
+            }],
+        delivery: (write) => flushDeliveryRecorder(rec, write),
     });
 }
 /** The default format; the header figure counts the whole block, sections included, as the ledger does. */
@@ -199,7 +173,8 @@ function renderContextMarkdown(view) {
             printSessionEvents(result.recentEvents);
         }
         if (renderItems.length > 0)
-            printContextMarkdown(renderItems, t, framing);
+            for (const line of contextBlockLines(renderItems, t, framing))
+                console.log(line);
         printCrossProjectSection(crossEntries);
         if (result.ambientState) {
             console.log(`\n${renderAmbientSummary(result.ambientState)}`);
@@ -208,23 +183,18 @@ function renderContextMarkdown(view) {
     if (text.length > 0)
         console.log(text);
     rec?.delivered(text.length > 0 ? { state: 'sent', emittedText: `${text}\n` } : { state: 'empty' });
-    withLedgerDb(view.hippoRoot, (db) => {
-        recordTokenUse(db, {
-            tenantId: view.tenantId, sessionId: view.ledgerSessionId, surface: view.pinnedOnly ? 'hook' : 'context',
-            event: 'inject', items: renderItems.length, tokens: estimateTokens(text),
-        });
-        flushDeliveryRecorder(rec, db);
+    bookLedgerTurn(view.hippoRoot, {
+        uses: [{
+                tenantId: view.tenantId, sessionId: view.ledgerSessionId, surface: view.pinnedOnly ? 'hook' : 'context',
+                event: 'inject', items: renderItems.length, tokens: estimateTokens(text),
+            }],
+        delivery: (write) => flushDeliveryRecorder(rec, write),
     });
 }
 function printCrossProjectSection(items) {
     for (const line of crossProjectLines(items))
         console.log(line);
 }
-/** @internal Exported for the render snapshot test; not a stable public API. */
-export function printContextMarkdown(items, totalTokens, framing = 'observe', opts = {}) {
-    for (const line of contextBlockLines(items, totalTokens, framing, opts))
-        console.log(line);
-}
 export async function handleContext({ hippoRoot, args, flags }) {
     // Bounded, not a TTY guard: the hot stdin path and a manual run share this one command.
     const { text: stdinText } = await readHookStdin();

package/dist/cli/continuity.d.ts

@@ -1,6 +1,7 @@
-export declare function cmdSnapshot(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
-export declare function cmdSession(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
-export declare function cmdHandoff(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
-export declare function cmdCurrent(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
-export declare function cmdWm(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
+import { type CliFlags } from './flag-values.js';
+export declare function cmdSnapshot(hippoRoot: string, args: string[], flags: CliFlags): void;
+export declare function cmdSession(hippoRoot: string, args: string[], flags: CliFlags): void;
+export declare function cmdHandoff(hippoRoot: string, args: string[], flags: CliFlags): void;
+export declare function cmdCurrent(hippoRoot: string, args: string[], flags: CliFlags): void;
+export declare function cmdWm(hippoRoot: string, args: string[], flags: CliFlags): void;
 //# sourceMappingURL=continuity.d.ts.map

package/dist/cli/continuity.js

@@ -1,66 +1,72 @@
 // Where-you-left-off verbs: snapshot, session, handoff, current and working memory.
 import { saveActiveTaskSnapshot, loadActiveTaskSnapshot, clearActiveTaskSnapshot, appendSessionEvent, listSessionEvents, } from '../store/sessions.js';
 import { saveSessionHandoff, loadLatestHandoff, loadHandoffById, stampHandoffOutcome } from '../store/handoffs.js';
-import { isHandoffOutcome, formatHandoffEvidenceLine } from '../handoff.js';
-import { resolveTenantId } from '../tenant.js';
-import { wmPush, wmRead, wmClear, wmFlush } from '../working-memory.js';
-import { collectHandoffEvidence } from '../handoff-evidence.js';
+import { isHandoffOutcome, formatHandoffEvidenceLine } from '../core/handoff.js';
+import { resolveTenantId } from '../store/tenant.js';
+import { wmPush, wmRead, wmClear, wmFlush } from '../store/working-memory.js';
+import { collectHandoffEvidence } from '../capture/handoff-evidence.js';
 import { printError } from './output.js';
-import { requireInit, printActiveTaskSnapshot, printSessionEvents, printHandoff, } from './shared.js';
-export function cmdSnapshot(hippoRoot, args, flags) {
-    requireInit(hippoRoot);
-    const subcommand = args[0] ?? 'show';
-    if (subcommand === 'save') {
-        const task = String(flags['task'] ?? '').trim();
-        const summary = String(flags['summary'] ?? '').trim();
-        const nextStep = String(flags['next-step'] ?? '').trim();
-        const sessionId = String(flags['session'] ?? flags['id'] ?? '').trim();
-        if (!task || !summary || !nextStep) {
-            printError('Usage: hippo snapshot save --task <task> --summary <summary> --next-step <step> [--source <source>] [--session <session-id>]');
-            process.exit(1);
-        }
-        const snapshot = saveActiveTaskSnapshot(hippoRoot, resolveTenantId({}), {
-            task,
-            summary,
-            next_step: nextStep,
-            source: String(flags['source'] ?? 'cli'),
-            session_id: sessionId || null,
-        });
-        console.log(`Saved active task snapshot #${snapshot.id}`);
-        console.log(`   Task: ${snapshot.task}`);
-        console.log(`   Next: ${snapshot.next_step}`);
-        if (snapshot.session_id) {
-            console.log(`   Session: ${snapshot.session_id}`);
-        }
-        return;
+import { requireInit } from './shared.js';
+import { printActiveTaskSnapshot, printSessionEvents, printHandoff } from './print.js';
+import { boolFlag } from './flag-values.js';
+const ISO_DATETIME_CHARS = 19;
+function snapshotSave(hippoRoot, flags) {
+    const task = String(flags['task'] ?? '').trim();
+    const summary = String(flags['summary'] ?? '').trim();
+    const nextStep = String(flags['next-step'] ?? '').trim();
+    const sessionId = String(flags['session'] ?? flags['id'] ?? '').trim();
+    if (!task || !summary || !nextStep) {
+        printError('Usage: hippo snapshot save --task <task> --summary <summary> --next-step <step> [--source <source>] [--session <session-id>]');
+        process.exit(1);
     }
-    if (subcommand === 'clear') {
-        const cleared = clearActiveTaskSnapshot(hippoRoot, resolveTenantId({}), String(flags['status'] ?? 'cleared'));
-        if (!cleared) {
-            console.log('No active task snapshot to clear.');
-            return;
-        }
-        console.log('Cleared active task snapshot.');
+    const snapshot = saveActiveTaskSnapshot(hippoRoot, resolveTenantId({}), {
+        task,
+        summary,
+        next_step: nextStep,
+        source: String(flags['source'] ?? 'cli'),
+        session_id: sessionId || null,
+    });
+    console.log(`Saved active task snapshot #${snapshot.id}`);
+    console.log(`   Task: ${snapshot.task}`);
+    console.log(`   Next: ${snapshot.next_step}`);
+    if (snapshot.session_id) {
+        console.log(`   Session: ${snapshot.session_id}`);
+    }
+}
+function snapshotClear(hippoRoot, flags) {
+    const cleared = clearActiveTaskSnapshot(hippoRoot, resolveTenantId({}), String(flags['status'] ?? 'cleared'));
+    if (!cleared) {
+        console.log('No active task snapshot to clear.');
         return;
     }
-    if (subcommand === 'show') {
-        const snapshot = loadActiveTaskSnapshot(hippoRoot, resolveTenantId({}));
-        if (!snapshot) {
-            if (flags['json']) {
-                console.log(JSON.stringify({ snapshot: null }));
-            }
-            else {
-                console.log('No active task snapshot saved.');
-            }
-            return;
-        }
+    console.log('Cleared active task snapshot.');
+}
+function snapshotShow(hippoRoot, flags) {
+    const snapshot = loadActiveTaskSnapshot(hippoRoot, resolveTenantId({}));
+    if (!snapshot) {
         if (flags['json']) {
-            console.log(JSON.stringify({ snapshot }, null, 2));
-            return;
+            console.log(JSON.stringify({ snapshot: null }));
         }
-        printActiveTaskSnapshot(snapshot);
+        else {
+            console.log('No active task snapshot saved.');
+        }
+        return;
+    }
+    if (flags['json']) {
+        console.log(JSON.stringify({ snapshot }, null, 2));
         return;
     }
+    printActiveTaskSnapshot(snapshot);
+}
+export function cmdSnapshot(hippoRoot, args, flags) {
+    requireInit(hippoRoot);
+    const subcommand = args[0] ?? 'show';
+    if (subcommand === 'save')
+        return snapshotSave(hippoRoot, flags);
+    if (subcommand === 'clear')
+        return snapshotClear(hippoRoot, flags);
+    if (subcommand === 'show')
+        return snapshotShow(hippoRoot, flags);
     printError('Usage: hippo snapshot <save|show|clear>');
     process.exit(1);
 }
@@ -332,57 +338,61 @@ export function cmdHandoff(hippoRoot, args, flags) {
     printError('Usage: hippo handoff <create|latest|show>');
     process.exit(1);
 }
-export function cmdCurrent(hippoRoot, args, flags) {
-    requireInit(hippoRoot);
-    const subcommand = args[0] ?? 'show';
-    if (subcommand === 'show') {
-        const asJson = Boolean(flags['json']);
-        const snapshot = loadActiveTaskSnapshot(hippoRoot, resolveTenantId({}));
-        const sessionId = snapshot?.session_id ?? undefined;
-        const events = listSessionEvents(hippoRoot, resolveTenantId({}), {
-            session_id: sessionId,
-            limit: 5,
-        });
-        if (asJson) {
-            console.log(JSON.stringify({
-                snapshot: snapshot ?? null,
-                events: events.map((ev) => ({
-                    id: ev.id,
-                    session_id: ev.session_id,
-                    event_type: ev.event_type,
-                    content: ev.content,
-                    created_at: ev.created_at,
-                })),
-            }));
-            return;
-        }
-        if (!snapshot && events.length === 0) {
-            console.log('No active task or recent session events.');
-            return;
-        }
-        console.log('# Current State\n');
-        if (snapshot) {
-            console.log(`Task: ${snapshot.task}`);
-            console.log(`Status: ${snapshot.status} | Source: ${snapshot.source} | Updated: ${snapshot.updated_at}`);
-            if (snapshot.session_id) {
-                console.log(`Session: ${snapshot.session_id}`);
-            }
-            console.log(`Summary: ${snapshot.summary}`);
-            console.log(`Next: ${snapshot.next_step}`);
-        }
-        else {
-            console.log('No active task snapshot.');
+function printCurrentState(snapshot, events) {
+    console.log('# Current State\n');
+    if (snapshot) {
+        console.log(`Task: ${snapshot.task}`);
+        console.log(`Status: ${snapshot.status} | Source: ${snapshot.source} | Updated: ${snapshot.updated_at}`);
+        if (snapshot.session_id) {
+            console.log(`Session: ${snapshot.session_id}`);
         }
-        if (events.length > 0) {
-            console.log('');
-            console.log('Recent events:');
-            for (const ev of events) {
-                const ts = ev.created_at.slice(0, 19).replace('T', ' ');
-                console.log(`  [${ts}] (${ev.event_type}) ${ev.content}`);
-            }
+        console.log(`Summary: ${snapshot.summary}`);
+        console.log(`Next: ${snapshot.next_step}`);
+    }
+    else {
+        console.log('No active task snapshot.');
+    }
+    if (events.length > 0) {
+        console.log('');
+        console.log('Recent events:');
+        for (const ev of events) {
+            const ts = ev.created_at.slice(0, ISO_DATETIME_CHARS).replace('T', ' ');
+            console.log(`  [${ts}] (${ev.event_type}) ${ev.content}`);
         }
+    }
+}
+function currentShow(hippoRoot, flags) {
+    const asJson = boolFlag(flags, 'json');
+    const snapshot = loadActiveTaskSnapshot(hippoRoot, resolveTenantId({}));
+    const sessionId = snapshot?.session_id ?? undefined;
+    const events = listSessionEvents(hippoRoot, resolveTenantId({}), {
+        session_id: sessionId,
+        limit: 5,
+    });
+    if (asJson) {
+        console.log(JSON.stringify({
+            snapshot: snapshot ?? null,
+            events: events.map((ev) => ({
+                id: ev.id,
+                session_id: ev.session_id,
+                event_type: ev.event_type,
+                content: ev.content,
+                created_at: ev.created_at,
+            })),
+        }));
         return;
     }
+    if (!snapshot && events.length === 0) {
+        console.log('No active task or recent session events.');
+        return;
+    }
+    printCurrentState(snapshot, events);
+}
+export function cmdCurrent(hippoRoot, args, flags) {
+    requireInit(hippoRoot);
+    const subcommand = args[0] ?? 'show';
+    if (subcommand === 'show')
+        return currentShow(hippoRoot, flags);
     printError('Usage: hippo current <show>');
     process.exit(1);
 }

package/dist/{correction-latency.d.ts → cli/correction-latency.d.ts}

@@ -1,4 +1,4 @@
-import { MemoryEntry } from './memory.js';
+import { MemoryEntry } from '../core/memory.js';
 export interface CorrectionPair {
     oldId: string;
     newId: string;

package/dist/cli/curate.d.ts

@@ -1,19 +1,19 @@
-import { type CommandContext } from './shared.js';
-export declare function cmdOutcome(hippoRoot: string, flags: Record<string, string | boolean | string[]>): void;
-export declare function cmdConflicts(hippoRoot: string, flags: Record<string, string | boolean | string[]>): void;
-export declare function cmdResolve(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
-export declare function cmdReject(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
-export declare function cmdRejections(hippoRoot: string, flags: Record<string, string | boolean | string[]>): void;
-export declare function cmdUnreject(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
+import { type CliFlags, type CommandContext } from './flag-values.js';
+export declare function cmdOutcome(hippoRoot: string, flags: CliFlags): void;
+export declare function cmdConflicts(hippoRoot: string, flags: CliFlags): void;
+export declare function cmdResolve(hippoRoot: string, args: string[], flags: CliFlags): void;
+export declare function cmdReject(hippoRoot: string, args: string[], flags: CliFlags): void;
+export declare function cmdRejections(hippoRoot: string, flags: CliFlags): void;
+export declare function cmdUnreject(hippoRoot: string, args: string[], flags: CliFlags): void;
 /**
  * `hippo dormant [list] [<query>...] [--limit <n>] [--json] [--global]`,
  * `hippo dormant restore <id>`, `hippo dormant forget <id>`.
  * Dormant memories are what sleep keeps instead of deleting (on by default;
  * `"dormant": { "enabled": false }` in .hippo/config.json deletes instead).
  */
-export declare function cmdDormant(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
+export declare function cmdDormant(hippoRoot: string, args: string[], flags: CliFlags): void;
 /** `hippo quarantine [list] [--all] [--json] [--global]`, `quarantine approve <id>`, `quarantine reject <id>` (poisoning defence). */
-export declare function cmdQuarantine(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
+export declare function cmdQuarantine(hippoRoot: string, args: string[], flags: CliFlags): Promise<void>;
 export declare function handleForget({ hippoRoot, args, flags }: CommandContext): Promise<void>;
 export declare function handleInvalidate({ hippoRoot, args, flags }: CommandContext): void;
 //# sourceMappingURL=curate.d.ts.map