hippo-memory 1.72.0 → 2.1.0

package/dist/cli/session-hooks.js

@@ -16,26 +16,28 @@ import { cmdPreCompact, cmdPostCompact } from '../capture/compact.js';
 import { transcriptWorkingState } from '../capture/working-state.js';
 import { collectHandoffEvidence } from '../capture/handoff-evidence.js';
 import { copilotTranscriptFor, SESSION_ID_RE } from '../capture/copilot-transcript.js';
-import { loadTurnPosition, runSessionWorker, saveTurnPosition, turnsAfter } from '../capture/session-worker.js';
-import { isStringValue, readSessionEnd, readVscodeStop } from '../core/capture-contract.js';
+import { loadTurnPosition, runSessionWorker, saveTurnPosition, turnsAfter, } from '../capture/session-worker.js';
+import { isStringValue, readSessionEnd, readVscodeStop, } from '../core/capture-contract.js';
 import { loadConfig } from '../core/config.js';
-import { autoSleepDue } from '../api/auto-sleep.js';
+import { autoSleepDue } from '../api/sleep/auto-sleep.js';
 import { COMPACTION_DB_WAIT_MS } from '../core/compaction-timing.js';
-import { bookSessionRereads, closeEndedSession, compactResumeBlock } from '../api/session-end.js';
+import { compactResumeBlock, sessionEndWork as runSessionEnd } from '../api/session-end.js';
 import { normaliseHookPayload, readHookStdin, readStdinBounded } from './stdin.js';
-import { errorMessage, log } from '../util/log.js';
+import { errorMessage, log, errorFields } from '../util/log.js';
+import { cmdShimArgs } from '../util/spawn-argv.js';
 import { bookLedgerTurn } from '../api/ledger-db.js';
 import { flushDeliveryRecorder, startDeliveryRecorder, startToolFailureRecorder } from '../api/prompt-hook.js';
 import { printError } from './output.js';
 import { cmdLastSleep } from './last-sleep.js';
 import { readCompactResumePayload } from './compact-resume-payload.js';
-import { cliApiContext } from './api-context.js';
-import { boolFlag, flagIsTrue, stringFlag } from './flag-values.js';
+import { cliApiContext, cliLedgerReach } from './api-context.js';
+import { boolFlag, flagIsTrue, stringFlag, stringFlagOrExit, } from './flag-values.js';
 import { logSessionEndImport, appendSessionEndCloseLog, reportSessionEndFailure, resetHookInjection, hookStoreRoot, hookRuntime, payloadCwdRoot, runHookWithStores, inPilotHoldout, hostSessionId, } from './hook-runtime.js';
-import { CliExit } from './exit.js';
-/** SessionStart(compact) injector: prints the task snapshot and session trail lost to compaction; no pinned memories (UserPromptSubmit re-injects them).
- * Every path exits 0: a malformed payload or store read failure degrades to empty stdout, never a throw. */
-function cmdCompactResume(hippoRoot, tenantId, stdinText, stdinTimedOut) {
+import { CliExit, fail } from './exit.js';
+/** SessionStart(compact) injector: prints the task snapshot and session trail lost to compaction; no pinned memories
+ * (UserPromptSubmit re-injects them). Every path exits 0: a malformed payload or store read failure degrades to empty
+ * stdout, never a throw. */
+async function cmdCompactResume(hippoRoot, tenantId, stdinText, stdinTimedOut) {
     let rec = null;
     try {
         // Gate on the non-exiting isInitialized check first: the store reads below call initStore, which would
@@ -52,48 +54,57 @@ function cmdCompactResume(hippoRoot, tenantId, stdinText, stdinTimedOut) {
             });
         }
         // A compaction follows a prompt or SessionStart that booked the arm, so this only reads it.
-        if (!suppressOutput && payloadSessionId !== null && inPilotHoldout(hippoRoot, tenantId, payloadSessionId, false)) {
+        if (!suppressOutput && payloadSessionId !== null &&
+            inPilotHoldout(hippoRoot, tenantId, payloadSessionId, { write: false })) {
             suppressOutput = true;
             rec?.disabled();
         }
         if (!suppressOutput)
-            restoreCompactSnapshot(hippoRoot, tenantId, payloadSessionId, rec);
+            await restoreCompactSnapshot(hippoRoot, tenantId, payloadSessionId, rec);
     }
     catch (err) {
         if (err instanceof CliExit)
             throw err;
-        // Empty stdout on any store error, never a crashed SessionStart; the reason goes to stderr, which the model never sees.
-        log.warn(`hippo compact-resume: skipped: ${errorMessage(err)}`);
+        // Empty stdout on any store error, never a crashed SessionStart; the reason goes to stderr, which the model never
+        // sees.
+        log.warn(`hippo compact-resume: skipped: ${errorMessage(err)}`, errorFields(err));
     }
     // A no-op when the token ledger's handle already wrote the row; exit would drop it otherwise.
     flushDeliveryRecorder(rec);
     throw new CliExit(0);
 }
-function restoreCompactSnapshot(hippoRoot, tenantId, payloadSessionId, rec) {
-    const text = compactResumeBlock(cliApiContext(hippoRoot, tenantId), payloadSessionId);
+async function restoreCompactSnapshot(hippoRoot, tenantId, payloadSessionId, rec) {
+    const text = await compactResumeBlock(cliApiContext(hippoRoot, tenantId), payloadSessionId);
     if (text === null)
         return;
     // Printed in one write so the ledger books exactly the text the model is handed.
     console.log(text);
-    rec?.delivered({ state: 'sent', emittedText: `${text}
-` });
+    rec?.delivered({ state: 'sent', emittedText: `${text}\n` });
     bookLedgerTurn(hippoRoot, {
         uses: [{
-                tenantId, sessionId: payloadSessionId, surface: 'compact_resume', event: 'inject', items: 1, tokens: estimateTokens(text),
+                tenantId,
+                sessionId: payloadSessionId,
+                surface: 'compact_resume',
+                event: 'inject',
+                items: 1,
+                tokens: estimateTokens(text),
             }],
         delivery: (write) => flushDeliveryRecorder(rec, write),
-    });
+    }, cliLedgerReach(hippoRoot));
 }
-/** SessionEnd entry: TUI teardown kills children still running, so read stdin inline, spawn a detached child that runs sleep then capture, and exit.
- * The child logs to a file that the next SessionStart reads via `hippo last-sleep`. */
+/** SessionEnd entry: TUI teardown kills children still running, so read stdin inline, spawn a detached child that runs
+ * sleep then capture, and exit. The child logs to a file that the next SessionStart reads via `hippo last-sleep`. */
 export async function handleSessionEnd({ hippoRoot, tenantId, flags }) {
     const runtime = hookRuntime(flags);
     const turn = flagIsTrue(flags, 'turn');
-    // Copilot's hook command carries no path, since one quoted into it would need escaping for each shell; the log goes where the hook table used to point.
-    const logFile = stringFlag(flags, 'log-file') ?? (runtime === 'copilot' ? resolveJsonHookPaths('copilot').logFile : null);
+    // Copilot's hook command carries no path, since one quoted into it would need escaping for each shell; the log goes
+    // where the hook table used to point.
+    const logFile = stringFlag(flags, 'log-file') ??
+        (runtime === 'copilot' ? resolveJsonHookPaths('copilot').logFile : null);
     // Bounded read: extracts transcript_path + session_id for the detached worker's argv.
     const raw = await readStdinBounded();
-    // Read before normalising: the Copilot CLI's agentStop shares this hook line, and camelCase keys would pass as VS Code's.
+    // Read before normalising: the Copilot CLI's agentStop shares this hook line, and camelCase keys would pass as VS
+    // Code's.
     const stop = turn ? vscodeStopInput(raw) : null;
     if (turn && !stop)
         return;
@@ -103,28 +114,24 @@ export async function handleSessionEnd({ hippoRoot, tenantId, flags }) {
     const input = stop ?? sessionEndInput(stdinText, raw.timedOut, runtime);
     // Only a host payload ends a session: a manual run and a reply's end (turn mode) are not boundaries.
     const rec = !turn && input !== null && !input.manual
-        ? startDeliveryRecorder(cliApiContext(hookStoreRoot(root), tenantId), { stdinText, runtime, eventType: 'session-end', envSessionId: hostSessionId() })
+        ? startSessionEndRecorder(root, tenantId, stdinText, runtime)
         : null;
     const sessionId = input?.sessionId ?? null;
-    // Resolved here because only this process saw the payload; the worker captures just the path it is handed.
-    // Always a hook, so never scan: an empty stdin here is not a manual run. The Copilot CLI's sessionEnd names no transcript, so its log is found by id.
+    // Resolved here because only this process saw the payload; the worker captures just the path it is handed. Always a
+    // hook, so never scan: an empty stdin here is not a manual run. The Copilot CLI's sessionEnd names no transcript, so
+    // its log is found by id.
     const named = input?.transcriptPath ?? null;
     const transcriptPath = (named !== null && fs.existsSync(named) ? named : null)
         ?? (runtime === 'copilot' && sessionId ? copilotTranscriptFor(sessionId) : null);
+    const worker = { logFile, transcriptPath, sessionId, turn };
     try {
-        spawnSessionEndWorker(sessionEndWorkerArgs(logFile, transcriptPath, sessionId, turn));
+        spawnSessionEndWorker(sessionEndWorkerArgs(worker));
     }
     catch (err) {
-        log.debug(`session-end: the worker did not spawn, running inline: ${errorMessage(err)}`);
+        log.debug(`session-end: the worker did not spawn, running inline: ${errorMessage(err)}`, errorFields(err));
         // Inline is the last resort, handed what the child's argv would have carried.
-        if (logFile)
-            flags['log-file'] = logFile;
-        if (transcriptPath)
-            flags['transcript'] = transcriptPath;
-        if (sessionId)
-            flags['session-id'] = sessionId;
         try {
-            await cmdSessionEndWorker(root, tenantId, flags);
+            await cmdSessionEndWorker(root, tenantId, inlineWorkerFlags(flags, worker));
         }
         finally {
             await runHookWithStores(() => flushDeliveryRecorder(rec));
@@ -134,7 +141,16 @@ export async function handleSessionEnd({ hippoRoot, tenantId, flags }) {
     // After the spawn, so a locked store delays only the row; the hook's short lock wait bounds it.
     await runHookWithStores(() => flushDeliveryRecorder(rec));
 }
-/** What the session-end payload named; null for one hippo refuses or one that never arrived, and the worker then runs with neither value. */
+function startSessionEndRecorder(root, tenantId, stdinText, runtime) {
+    return startDeliveryRecorder(cliApiContext(hookStoreRoot(root), tenantId), {
+        stdinText,
+        runtime,
+        eventType: 'session-end',
+        envSessionId: hostSessionId(),
+    });
+}
+/** What the session-end payload named; null for one hippo refuses or one that never arrived, and the worker then runs
+ * with neither value. */
 function sessionEndInput(stdinText, timedOut, runtime) {
     const receipt = readSessionEnd(stdinText, timedOut, runtime);
     if (receipt.status === 'received')
@@ -142,7 +158,8 @@ function sessionEndInput(stdinText, timedOut, runtime) {
     log.debug(`session-end: ${receipt.reason}`);
     return null;
 }
-function sessionEndWorkerArgs(logFile, transcriptPath, sessionId, turn) {
+function sessionEndWorkerArgs(o) {
+    const { logFile, transcriptPath, sessionId, turn } = o;
     const workerArgs = [process.argv[1], '__session-end-worker'];
     if (logFile)
         workerArgs.push('--log-file', logFile);
@@ -154,6 +171,27 @@ function sessionEndWorkerArgs(logFile, transcriptPath, sessionId, turn) {
         workerArgs.push('--turn');
     return workerArgs;
 }
+/** The flags the detached worker would parse from its argv, so the inline run sees what the child would have; the
+ * hook's own flags fill the gaps. */
+function inlineWorkerFlags(flags, w) {
+    const out = {};
+    const keep = (name, value) => {
+        if (value)
+            out[name] = value;
+    };
+    keep('log-file', w.logFile ?? flags['log-file']);
+    keep('transcript', w.transcriptPath ?? flags['transcript']);
+    keep('session-id', w.sessionId ?? flags['session-id']);
+    if (flagIsTrue(flags, 'turn'))
+        out['turn'] = true;
+    if (flagIsTrue(flags, 'dry-run'))
+        out['dry-run'] = true;
+    if (flagIsTrue(flags, 'no-learn'))
+        out['no-learn'] = true;
+    if (flagIsTrue(flags, 'no-share'))
+        out['no-share'] = true;
+    return out;
+}
 function spawnSessionEndWorker(workerArgs) {
     const child = spawn(process.execPath, workerArgs, {
         detached: true,
@@ -164,10 +202,12 @@ function spawnSessionEndWorker(workerArgs) {
     child.on('error', (err) => log.warn(`hippo session-end: the worker did not start: ${errorMessage(err)}`));
     child.unref();
 }
-/** The input of a VS Code Stop payload with a session id that can name the lock file; null makes turn mode a silent no-op. */
+/** The input of a VS Code Stop payload with a session id that can name the lock file; null makes turn mode a silent
+ * no-op. */
 function vscodeStopInput(raw) {
     const receipt = readVscodeStop(raw.text, raw.timedOut);
-    return receipt.status === 'received' && receipt.input.sessionId !== null && SESSION_ID_RE.test(receipt.input.sessionId) ? receipt.input : null;
+    return receipt.status === 'received' && receipt.input.sessionId !== null &&
+        SESSION_ID_RE.test(receipt.input.sessionId) ? receipt.input : null;
 }
 async function cmdSessionEndWorker(hippoRoot, tenantId, flags) {
     const sessionId = flags['session-id'];
@@ -176,48 +216,41 @@ async function cmdSessionEndWorker(hippoRoot, tenantId, flags) {
 export function handleSessionEndWorker({ hippoRoot, tenantId, flags }) {
     return cmdSessionEndWorker(hippoRoot, tenantId, flags);
 }
-async function sessionEndWork(hippoRoot, tenantId, flags, mode) {
+function sessionEndWork(hippoRoot, tenantId, flags, mode) {
     const transcriptPath = stringFlag(flags, 'transcript');
-    const closeLogFile = stringFlag(flags, 'log-file') ?? null;
-    const closeSessionId = stringFlag(flags, 'session-id') ?? null;
-    const rereadLog = await bookSessionRereads(cliApiContext(hippoRoot, tenantId), transcriptPath, closeSessionId)
-        .catch((err) => [`re-read count failed: ${errorMessage(err)}`]);
-    // Sleep starts the log file afresh, so the lines go in after it; on exit too, in case sleep exits the process.
-    const flushRereadLog = () => { for (const line of rereadLog.splice(0))
-        appendSessionEndCloseLog(closeLogFile, line); };
-    process.once('exit', flushRereadLog);
-    // Like the other hooks: project store, else global; a folder with neither must not get one made.
-    const store = hookStoreRoot(hippoRoot);
-    if (!isInitialized(store)) {
-        appendSessionEndCloseLog(closeLogFile, 'skip: no hippo store for this folder or globally', { startFresh: true });
-        flushRereadLog();
-        return;
-    }
-    if (mode === 'turn' && closeSessionId)
-        await sleepIfDue(hippoRoot, tenantId, flags, closeLogFile, transcriptPath, closeSessionId);
-    else
-        await sleepProjectStore(hippoRoot, tenantId, flags, closeLogFile, transcriptPath);
-    flushRereadLog();
-    const digestLog = (message) => appendSessionEndCloseLog(closeLogFile, message);
-    const scan = transcriptPath ? readSessionScan(transcriptPath, digestLog) : null;
-    const capture = (turns) => captureEndedSession(hippoRoot, tenantId, store, flags, transcriptPath, turns);
-    if (mode === 'turn')
-        captureNewTurns(transcriptPath, closeSessionId, scan, capture, digestLog);
-    else
-        capture(scan?.turns);
-    recordSessionDigest(hippoRoot, scan, {
-        key: closeSessionId || path.basename(transcriptPath ?? '', '.jsonl'),
+    const logFile = stringFlag(flags, 'log-file') ?? null;
+    const sessionId = stringFlag(flags, 'session-id') ?? null;
+    return runSessionEnd({
+        mode,
+        hippoRoot,
         tenantId,
-        log: digestLog,
-    });
-    // Only this session's snapshot, and only after sleep and capture.
-    const closeLog = (line) => appendSessionEndCloseLog(closeLogFile, line);
-    closeEndedSession(cliApiContext(store, tenantId), {
-        sessionId: closeSessionId,
-        turn: mode === 'turn',
-        workingState: () => (transcriptPath ? transcriptWorkingState(transcriptPath, closeLog) : null),
+        sessionId,
+        transcriptPath,
+        contextFor: (root) => cliApiContext(root, tenantId),
+        storeRoot: () => {
+            const root = hookStoreRoot(hippoRoot);
+            return isInitialized(root) ? root : null;
+        },
+        log: (line, opts) => appendSessionEndCloseLog(logFile, line, opts),
+        sleep: () => (mode === 'turn' && sessionId
+            ? sleepIfDue(hippoRoot, tenantId, flags, logFile, transcriptPath, sessionId)
+            : sleepProjectStore(hippoRoot, tenantId, flags, logFile, transcriptPath)),
+        readScan: (log) => (transcriptPath ? readSessionScan(transcriptPath, log) : null),
+        capture: (store, scan) => {
+            const capture = (turns) => captureEndedSession(hippoRoot, tenantId, store, flags, transcriptPath, turns);
+            if (mode === 'turn') {
+                captureNewTurns(transcriptPath, sessionId, scan, capture, (line) => appendSessionEndCloseLog(logFile, line));
+            }
+            else
+                capture(scan?.turns);
+        },
+        digest: (scan, log) => recordSessionDigest(hippoRoot, scan, {
+            key: sessionId || path.basename(transcriptPath ?? '', '.jsonl'),
+            tenantId,
+            log,
+        }),
+        workingState: (log) => (transcriptPath ? transcriptWorkingState(transcriptPath, log) : null),
         evidence: () => collectHandoffEvidence(process.cwd(), 'unknown'),
-        log: closeLog,
     });
 }
 async function sleepProjectStore(hippoRoot, tenantId, flags, closeLogFile, transcriptPath) {
@@ -236,7 +269,8 @@ async function sleepProjectStore(hippoRoot, tenantId, flags, closeLogFile, trans
         logSessionEndImport(closeLogFile, transcriptPath);
     }
 }
-/** A close after every reply sleeps only at the MCP server's auto-sleep threshold; each line starts the log afresh, as a sleep does. */
+/** A close after every reply sleeps only at the MCP server's auto-sleep threshold; each line starts the log afresh, as
+ * a sleep does. */
 async function sleepIfDue(hippoRoot, tenantId, flags, closeLogFile, transcriptPath, sessionId) {
     if (!isInitialized(hippoRoot))
         return sleepProjectStore(hippoRoot, tenantId, flags, closeLogFile, transcriptPath);
@@ -304,20 +338,6 @@ function loadCodexWrapperMetadata() {
     // SAFETY: the file is the one installCodexWrapper wrote; handleCodexRun reads only logFile and realCodexPath from it.
     return JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
 }
-/** Quotes one cmd.exe argument; each `%` leaves the quotes as `^%`, so no %NAME% pair can expand. */
-export function quoteCmdArg(arg) {
-    if (arg.length === 0)
-        return '""';
-    if (!/[ \t"&()^<>|%!]/.test(arg))
-        return arg;
-    return `"${arg.replace(/"/g, '""').replace(/%/g, '"^%"')}"`;
-}
-/** cmd.exe arguments that run a .cmd or .bat shim with every forwarded argument delivered verbatim. */
-export function cmdShimArgs(shimPath, forwardArgs) {
-    const command = `"${shimPath}"${forwardArgs.length > 0 ? ` ${forwardArgs.map(quoteCmdArg).join(' ')}` : ''}`;
-    // The line is already quoted for cmd.exe, so Node must not quote it again; /s strips the outer pair.
-    return ['/d', '/v:off', '/s', '/c', `"${command}"`];
-}
 function spawnRealCodex(realCodexPath, forwardArgs, cwd) {
     const ext = path.extname(realCodexPath).toLowerCase();
     if (process.platform === 'win32' && ext === '.ps1') {
@@ -338,7 +358,7 @@ export function handleCodexRun({ hippoRoot, tenantId, args }) {
         cmdLastSleep(hippoRoot, { path: metadata.logFile }, 'terminal');
     }
     catch (err) {
-        log.debug(`codex run: the last sleep summary was not shown: ${errorMessage(err)}`);
+        log.debug(`codex run: the last sleep summary was not shown: ${errorMessage(err)}`, errorFields(err));
     }
     const child = spawnRealCodex(metadata.realCodexPath, args, process.cwd());
     child.on('error', (err) => {
@@ -378,10 +398,11 @@ async function launchCodexSessionEndWorker(hippoRoot, tenantId, historyPath, sta
         });
     }
     catch (inlineErr) {
-        log.debug(`codex run: the inline session-end failed: ${errorMessage(inlineErr)}`);
+        log.debug(`codex run: the inline session-end failed: ${errorMessage(inlineErr)}`, errorFields(inlineErr));
     }
 }
-/** Resolves true once the detached worker is running, false when the spawn fails, whether it throws or reports later. */
+/** Resolves true once the detached worker is running, false when the spawn fails, whether it throws or reports
+ * later. */
 function detachedWorkerStarted(workerArgs) {
     return new Promise((resolve) => {
         const failed = (reason) => {
@@ -446,8 +467,8 @@ function captureCodexTranscript(hippoRoot, tenantId, store, flags, logFile) {
     try {
         const codexHome = stringFlag(flags, 'codex-home') ?? resolveCodexWrapperPaths().codexHome;
         const historyPath = stringFlag(flags, 'history-path') ?? path.join(codexHome, 'history.jsonl');
-        const startOffsetBytes = parseInt(String(flags['start-offset'] ?? '0'), 10) || 0;
-        const startedAtMs = parseInt(String(flags['started-at'] ?? Date.now()), 10) || Date.now();
+        const startOffsetBytes = parseInt(stringFlag(flags, 'start-offset') ?? '', 10) || 0;
+        const startedAtMs = parseInt(stringFlag(flags, 'started-at') ?? '', 10) || Date.now();
         const transcriptPath = resolveCodexSessionTranscript({
             codexHome,
             historyPath,
@@ -508,8 +529,8 @@ export async function handlePreCompact({ hippoRoot, tenantId, flags }) {
     });
 }
 export async function handlePostCompact({ hippoRoot, flags }) {
-    // PostCompact hook: saves the compaction summary and its memories, then prints one plain line, because Claude Code shows this hook's
-    // stdout as-is. Always exits 0.
+    // PostCompact hook: saves the compaction summary and its memories, then prints one plain line, because Claude Code
+    // shows this hook's stdout as-is. Always exits 0.
     const { text, timedOut } = await readHookStdin();
     const logFlag = flags['log-file'];
     const store = hookStoreRoot(hippoRoot);
@@ -519,7 +540,10 @@ export async function handlePostCompact({ hippoRoot, flags }) {
         logFile: logFlag === true || logFlag === false || Array.isArray(logFlag) ? undefined : logFlag,
         // Passed in, since src/capture/ importing the sync would close an import cycle.
         afterSave: (transcriptPath, cwd, log) => {
-            const report = importSessionFolder(store, transcriptPath, cwd, { machine: currentMachine(), busyWaitMs: COMPACTION_DB_WAIT_MS });
+            const report = importSessionFolder(store, transcriptPath, cwd, {
+                machine: currentMachine(),
+                busyWaitMs: COMPACTION_DB_WAIT_MS,
+            });
             const summary = summaryLine(report);
             if (summary !== null)
                 log(summary);
@@ -540,7 +564,11 @@ export async function handleCaptureError({ hippoRoot, tenantId, flags }) {
         if (isInitialized(root) && payload) {
             // SAFETY: JSON.parse returns a JSON value by definition.
             const failure = JSON.parse(payload);
-            const rec = startToolFailureRecorder(cliApiContext(root, tenantId), { stdinText: text, runtime: hookRuntime(flags), envSessionId: hostSessionId() });
+            const rec = startToolFailureRecorder(cliApiContext(root, tenantId), {
+                stdinText: text,
+                runtime: hookRuntime(flags),
+                envSessionId: hostSessionId(),
+            });
             await runHookWithStores(() => {
                 try {
                     return captureToolFailure(root, tenantId, failure, (id) => rec?.logged(id));
@@ -553,14 +581,14 @@ export async function handleCaptureError({ hippoRoot, tenantId, flags }) {
     }
     catch (err) {
         // A malformed payload or store error must never fail the agent's tool call, so it is reported and dropped.
-        log.warn(`failure capture skipped: ${errorMessage(err)}`);
+        log.warn(`failure capture skipped: ${errorMessage(err)}`, errorFields(err));
     }
 }
 export async function handleCompactResume({ hippoRoot, tenantId }) {
     const { text: stdinText, timedOut: stdinTimedOut } = await readHookStdin();
-    await runHookWithStores(() => {
+    await runHookWithStores(async () => {
         resetHookInjection(hippoRoot, tenantId, stdinText, 'compact');
-        cmdCompactResume(hookStoreRoot(hippoRoot), tenantId, stdinText, stdinTimedOut);
+        await cmdCompactResume(hookStoreRoot(hippoRoot), tenantId, stdinText, stdinTimedOut);
     });
 }
 export async function handleCapture({ hippoRoot, tenantId, flags }) {
@@ -572,19 +600,19 @@ export async function handleCapture({ hippoRoot, tenantId, flags }) {
     }
     else if (flags['file']) {
         captureSource = 'file';
-        captureFile = String(flags['file']);
+        captureFile = stringFlagOrExit(flags, 'file');
     }
     else if (flags['last-session']) {
         captureSource = 'last-session';
     }
     if (flags['transcript']) {
-        transcriptPath = String(flags['transcript']);
+        transcriptPath = stringFlagOrExit(flags, 'transcript');
         if (!captureSource)
             captureSource = 'last-session';
     }
     if (!captureSource) {
-        printError('Usage: hippo capture --stdin|--file <path>|--last-session [--transcript <path>] [--log-file <path>] [--dry-run] [--global]');
-        throw new CliExit(1);
+        fail('Usage: hippo capture --stdin|--file <path>|--last-session [--transcript <path>] [--log-file <path>] ' +
+            '[--dry-run] [--global]');
     }
     // Bounded, and only when last-session has no explicit path: the
     // --stdin source keeps its own blocking read in src/capture/ by design.

package/dist/cli/setup.d.ts

@@ -1,5 +1,5 @@
 import { type CommandContext } from './flag-values.js';
 export declare function handleHook({ args }: CommandContext): void;
 export declare function handleSetup({ flags }: CommandContext): void;
-export declare function handleDailyRunner({ tenantId }: CommandContext): void;
+export declare function handleDailyRunner({ tenantId }: CommandContext): Promise<void>;
 //# sourceMappingURL=setup.d.ts.map