hippo-memory 1.69.0 → 1.70.0

package/dist/capture/session-texts.d.ts

@@ -1,5 +1,5 @@
 import type { Context } from '../api/types.js';
-import { type CallerProject } from '../prompt-hook.js';
+import { type CallerProject } from '../api/prompt-hook.js';
 import { type CaptureTally } from './command.js';
 export interface SessionCaptureRequest {
     readonly sessionId: string;

package/dist/capture/session-texts.js

@@ -1,9 +1,9 @@
 // `hippo capture --last-session` for a caller whose transcript was read on another machine: its project names the rows, never the store's folder.
-import { BadRequestError } from '../api-errors.js';
-import { assertCallerIds } from '../prompt-hook.js';
-import { assertCallerProject, projectNames } from '../project-identity.js';
-import { longestWord, storedTextKeys } from '../same-text.js';
-import { scrubForSharing } from '../share-scrub.js';
+import { BadRequestError } from '../core/api-errors.js';
+import { assertCallerIds } from '../api/prompt-hook.js';
+import { assertCallerProject, projectNames } from '../core/project-identity.js';
+import { longestWord, storedTextKeys } from '../util/same-text.js';
+import { scrubForSharing } from './share-scrub.js';
 import { loadTextsHoldingWords } from '../store/candidates.js';
 import { captureExtractedItems } from './command.js';
 import { extractFromTexts } from './extract.js';

package/dist/capture/session-worker.js

@@ -4,9 +4,10 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { createHash } from 'node:crypto';
 import { homeDir } from '../hooks/shared.js';
-import { errorMessage } from '../log.js';
-import { isObjectLike, isStringValue } from '../capture-contract.js';
+import { errorMessage, log as logger } from '../util/log.js';
+import { isObjectLike, isStringValue } from '../core/capture-contract.js';
 import { SESSION_ID_RE } from './copilot-transcript.js';
+import { FINGERPRINT_HEX_CHARS } from '../util/token-text.js';
 /** Null for a missing id or one that could climb out of the sessions folder. */
 function sessionStateFiles(sessionId) {
     if (sessionId === null || !SESSION_ID_RE.test(sessionId))
@@ -73,8 +74,9 @@ function releaseSessionLock(lock) {
     try {
         fs.rmSync(lock, { force: true });
     }
-    catch {
+    catch (err) {
         // A lock left behind names this pid, which is dead once the worker exits, so the next taker clears it.
+        logger.debug(`session lock not removed: ${errorMessage(err)}`);
     }
 }
 /** False when the sessions folder cannot be written, so the caller runs unlocked as before. */
@@ -133,7 +135,7 @@ export async function runSessionWorker(sessionId, mode, work) {
     }
 }
 function turnKey(turn) {
-    return createHash('sha256').update(`${turn.role}\n${turn.text}`).digest('hex').slice(0, 16);
+    return createHash('sha256').update(`${turn.role}\n${turn.text}`).digest('hex').slice(0, FINGERPRINT_HEX_CHARS);
 }
 /** The cursor position after `turns`: how many there were and a hash of the last. */
 export function turnPosition(turns) {

package/dist/{share-scrub.js → capture/share-scrub.js}

@@ -1,6 +1,6 @@
 // The scrub for transcript text that leaves the machine it was typed on.
-import { maskHomePaths } from './home-path.js';
-import { maskEmails, redactSecretsStrict } from './secret-detect.js';
+import { maskHomePaths } from '../util/home-path.js';
+import { maskEmails, redactSecretsStrict } from '../util/secret-detect.js';
 /** Secrets first, then emails, then home paths: a home-path mask could split a secret so that no pattern matches it. */
 export function scrubForSharing(text) {
     return maskHomePaths(maskEmails(redactSecretsStrict(text)));

package/dist/capture/transcript.js

@@ -1,9 +1,11 @@
-import { envHomeDir, processEnv } from '../env.js';
+import { envHomeDir, processEnv } from '../util/env.js';
 import { claudeConfigDir } from '../hooks/shared.js';
 import * as fs from 'fs';
 import * as path from 'path';
-import { isObjectLike, isStringValue } from '../capture-contract.js';
+import { isObjectLike, isStringValue, readSessionEnd } from '../core/capture-contract.js';
 import { copilotTurn } from './copilot-transcript.js';
+const RECENT_USER_TURNS = 20;
+const RECENT_ASSISTANT_TURNS = 10;
 /**
  * Build a compact text summary from a Claude Code / OpenCode / Copilot JSONL transcript.
  * Keeps plain user messages and the final chunk of assistant text, drops
@@ -54,69 +56,69 @@ export function collectSessionTurns(jsonl, visit) {
         if (!isObjectLike(entry) || !('type' in entry))
             continue;
         visit?.(entry);
-        const copilot = copilotTurn(entry);
-        if (copilot !== null) {
-            turns.push(copilot);
-            continue;
-        }
-        if (entry.type === 'user' || entry.type === 'assistant') {
-            const message = 'message' in entry && isObjectLike(entry.message) ? entry.message : undefined;
-            if (!message)
-                continue;
-            const content = 'content' in message ? message.content : undefined;
-            if (entry.type === 'user') {
-                const text = humanUserText(entry, message);
-                if (text)
-                    turns.push({ role: 'user', text });
-            }
-            else if (Array.isArray(content)) {
-                // Keep assistant text blocks; drop thinking + tool_use
-                const chunks = [];
-                for (const block of content) {
-                    if (isObjectLike(block)) {
-                        const blockText = 'type' in block && block.type === 'text' && 'text' in block ? block.text : undefined;
-                        if (isStringValue(blockText) && blockText.trim()) {
-                            chunks.push(blockText.trim());
-                        }
-                    }
-                }
-                if (chunks.length > 0) {
-                    turns.push({ role: 'assistant', text: chunks.join('\n') });
-                }
+        const turn = copilotTurn(entry) ?? claudeCodeTurn(entry) ?? codexTurn(entry);
+        if (turn !== null)
+            turns.push(turn);
+    }
+    return turns;
+}
+/** The turn a Claude Code `user` or `assistant` line carries; null for any other line or one with no human or reply text. */
+function claudeCodeTurn(entry) {
+    if (entry.type !== 'user' && entry.type !== 'assistant')
+        return null;
+    const message = 'message' in entry && isObjectLike(entry.message) ? entry.message : undefined;
+    if (!message)
+        return null;
+    const content = 'content' in message ? message.content : undefined;
+    if (entry.type === 'user') {
+        const text = humanUserText(entry, message);
+        return text ? { role: 'user', text } : null;
+    }
+    if (!Array.isArray(content))
+        return null;
+    // Keep assistant text blocks; drop thinking + tool_use
+    const chunks = [];
+    for (const block of content) {
+        if (isObjectLike(block)) {
+            const blockText = 'type' in block && block.type === 'text' && 'text' in block ? block.text : undefined;
+            if (isStringValue(blockText) && blockText.trim()) {
+                chunks.push(blockText.trim());
             }
+        }
+    }
+    return chunks.length > 0 ? { role: 'assistant', text: chunks.join('\n') } : null;
+}
+// Codex rollout transcript shape: response_item -> payload.message
+function codexTurn(entry) {
+    if (entry.type !== 'response_item')
+        return null;
+    const payload = 'payload' in entry && isObjectLike(entry.payload) ? entry.payload : undefined;
+    if (!payload || !('type' in payload) || payload.type !== 'message')
+        return null;
+    const role = 'role' in payload ? payload.role : undefined;
+    const content = 'content' in payload ? payload.content : undefined;
+    if (!Array.isArray(content))
+        return null;
+    const chunks = [];
+    for (const block of content) {
+        if (!isObjectLike(block))
             continue;
+        const blockType = 'type' in block ? block.type : undefined;
+        const blockText = 'text' in block ? block.text : undefined;
+        if (role === 'user' && blockType === 'input_text' && isStringValue(blockText) && blockText.trim()) {
+            chunks.push(blockText.trim());
         }
-        // Codex rollout transcript shape: response_item -> payload.message
-        if (entry.type === 'response_item') {
-            const payload = 'payload' in entry && isObjectLike(entry.payload) ? entry.payload : undefined;
-            if (!payload || !('type' in payload) || payload.type !== 'message')
-                continue;
-            const role = 'role' in payload ? payload.role : undefined;
-            const content = 'content' in payload ? payload.content : undefined;
-            if (!Array.isArray(content))
-                continue;
-            const chunks = [];
-            for (const block of content) {
-                if (!isObjectLike(block))
-                    continue;
-                const blockType = 'type' in block ? block.type : undefined;
-                const blockText = 'text' in block ? block.text : undefined;
-                if (role === 'user' && blockType === 'input_text' && isStringValue(blockText) && blockText.trim()) {
-                    chunks.push(blockText.trim());
-                }
-                if (role === 'assistant' && blockType === 'output_text' && isStringValue(blockText) && blockText.trim()) {
-                    chunks.push(blockText.trim());
-                }
-            }
-            if (chunks.length === 0)
-                continue;
-            if (role === 'user')
-                turns.push({ role: 'user', text: chunks.join('\n') });
-            if (role === 'assistant')
-                turns.push({ role: 'assistant', text: chunks.join('\n') });
+        if (role === 'assistant' && blockType === 'output_text' && isStringValue(blockText) && blockText.trim()) {
+            chunks.push(blockText.trim());
         }
     }
-    return turns;
+    if (chunks.length === 0)
+        return null;
+    if (role === 'user')
+        return { role: 'user', text: chunks.join('\n') };
+    if (role === 'assistant')
+        return { role: 'assistant', text: chunks.join('\n') };
+    return null;
 }
 export function summariseTranscript(jsonl) {
     return summariseSessionTurns(collectSessionTurns(jsonl));
@@ -124,8 +126,8 @@ export function summariseTranscript(jsonl) {
 /** The last 20 user turns and last 10 replies: session-end is about what was decided near the end, not at the start. */
 export function sessionTail(turns) {
     return {
-        users: turns.filter((t) => t.role === 'user').map((t) => t.text).slice(-20),
-        assistants: turns.filter((t) => t.role === 'assistant').map((t) => t.text).slice(-10),
+        users: turns.filter((t) => t.role === 'user').map((t) => t.text).slice(-RECENT_USER_TURNS),
+        assistants: turns.filter((t) => t.role === 'assistant').map((t) => t.text).slice(-RECENT_ASSISTANT_TURNS),
     };
 }
 export function summariseSessionTurns(turns) {
@@ -157,18 +159,10 @@ export function resolveLastSessionTranscript(explicit, stdinText, opts) {
     if (explicit)
         return fs.existsSync(explicit) ? explicit : null;
     if (stdinText && stdinText.trim() !== '') {
-        try {
-            const payload = JSON.parse(stdinText);
-            if (isObjectLike(payload) && 'transcript_path' in payload) {
-                const tp = payload.transcript_path;
-                if (isStringValue(tp) && fs.existsSync(tp))
-                    return tp;
-            }
-        }
-        catch {
-            // not JSON, but still a payload, so no scan
-        }
-        return null;
+        const receipt = readSessionEnd(stdinText, false);
+        // A refused payload is still a payload, so no scan.
+        const tp = receipt.status === 'received' ? receipt.input.transcriptPath : null;
+        return tp !== null && fs.existsSync(tp) ? tp : null;
     }
     if (!opts.mayScan)
         return null;

package/dist/capture/working-state.d.ts

@@ -1,7 +1,4 @@
 import type { TaskSnapshot } from '../store/rows.js';
-export declare const PRE_COMPACT_TASK_CAP = 200;
-export declare const PRE_COMPACT_SUMMARY_CAP = 2000;
-export declare const PRE_COMPACT_NEXT_STEP_CAP = 500;
 /** The longest each field of {@link transcriptWorkingState} can be, so a check of a sent working state imports these instead of copying them. */
 export declare const WORKING_STATE_CAPS: {
     readonly task: 200;

package/dist/capture/working-state.js

@@ -1,14 +1,14 @@
 // A session's working state read from its transcript tail, with no store in the imports, so a hook with no store can derive it.
 import * as fs from 'fs';
-import { maskEmails, redactSecretsStrict } from '../secret-detect.js';
-import { isObjectLike, isStringValue } from '../capture-contract.js';
-import { errorMessage } from '../log.js';
-import { PRE_COMPACT_TAIL_BYTES, readTranscriptTail, truncateCodePointSafe } from '../transcript-tail.js';
+import { maskEmails, redactSecretsStrict } from '../util/secret-detect.js';
+import { isObjectLike, isStringValue } from '../core/capture-contract.js';
+import { errorMessage } from '../util/log.js';
+import { PRE_COMPACT_TAIL_BYTES, readTranscriptTail, truncateCodePointSafe } from '../util/transcript-tail.js';
 import { humanUserText, summariseTranscript } from './transcript.js';
 import { copilotTurn } from './copilot-transcript.js';
-export const PRE_COMPACT_TASK_CAP = 200;
-export const PRE_COMPACT_SUMMARY_CAP = 2000;
-export const PRE_COMPACT_NEXT_STEP_CAP = 500;
+const PRE_COMPACT_TASK_CAP = 200;
+const PRE_COMPACT_SUMMARY_CAP = 2000;
+const PRE_COMPACT_NEXT_STEP_CAP = 500;
 const TRIM_MARKER = '[...earlier turns trimmed]\n';
 /** The longest each field of {@link transcriptWorkingState} can be, so a check of a sent working state imports these instead of copying them. */
 export const WORKING_STATE_CAPS = {

package/dist/{audit-prune.d.ts → cli/audit-prune.d.ts}

@@ -23,7 +23,6 @@
  *   - The audit_prune row itself is NEVER pruned by the same call (it's
  *     written AFTER the DELETE WHERE ts < cutoff, so ts > cutoff).
  */
-import type { DatabaseSyncLike } from './db.js';
 export interface PruneAuditOpts {
     /** Cutoff in days. Rows with `ts < (now - N days)` are deleted. */
     olderThanDays: number;
@@ -53,7 +52,7 @@ export declare function computeCutoff(days: number, now?: Date): string;
  *
  * Throws on invalid inputs (non-positive days, missing tenantId).
  */
-export declare function pruneAuditLog(db: DatabaseSyncLike, opts: PruneAuditOpts): PruneAuditResult;
+export declare function pruneAuditLog(hippoRoot: string, opts: PruneAuditOpts): PruneAuditResult;
 /**
  * Parse the `--older-than <value>` flag. Accepts either bare integer days
  * (`30`) or integer with `d` suffix (`30d`). Throws on invalid format.

package/dist/{audit-prune.js → cli/audit-prune.js}

@@ -23,13 +23,14 @@
  *   - The audit_prune row itself is NEVER pruned by the same call (it's
  *     written AFTER the DELETE WHERE ts < cutoff, so ts > cutoff).
  */
-import { appendAuditEvent } from './audit.js';
+import { pruneAuditRows } from '../store/audit.js';
+import { DAY_MS } from '../util/time.js';
 /**
  * Compute the cutoff ISO timestamp for an N-days-ago cutoff. Exported for
  * testability so tests can pin "now" without mocking Date.
  */
 export function computeCutoff(days, now = new Date()) {
-    const cutoff = new Date(now.getTime() - days * 24 * 60 * 60 * 1000);
+    const cutoff = new Date(now.getTime() - days * DAY_MS);
     return cutoff.toISOString();
 }
 function isTenantIdString(value) {
@@ -41,7 +42,7 @@ function isTenantIdString(value) {
  *
  * Throws on invalid inputs (non-positive days, missing tenantId).
  */
-export function pruneAuditLog(db, opts) {
+export function pruneAuditLog(hippoRoot, opts) {
     if (!Number.isFinite(opts.olderThanDays) || opts.olderThanDays <= 0) {
         throw new Error(`pruneAuditLog: olderThanDays must be a positive number, got ${opts.olderThanDays}`);
     }
@@ -51,42 +52,7 @@ export function pruneAuditLog(db, opts) {
     const dryRun = opts.dryRun === true;
     const actor = opts.actor ?? 'cli';
     const cutoff = computeCutoff(opts.olderThanDays);
-    let count = 0;
-    if (dryRun) {
-        // Dry-run: just count, no DELETE.
-        // SAFETY: row comes from `SELECT COUNT(*) AS c` above; COUNT(*) always
-        // yields exactly one row with a numeric `c` column (number or bigint
-        // depending on the node:sqlite driver's integer handling).
-        const row = db
-            .prepare(`SELECT COUNT(*) AS c FROM audit_log WHERE tenant_id = ? AND ts < ?`)
-            .get(opts.tenantId, cutoff);
-        count = Number(row.c);
-    }
-    else {
-        db.exec('BEGIN IMMEDIATE');
-        try {
-            const result = db
-                .prepare(`DELETE FROM audit_log WHERE tenant_id = ? AND ts < ?`)
-                .run(opts.tenantId, cutoff);
-            count = Number(result.changes ?? 0);
-            // Record the prune itself in the audit trail. This row has ts = now,
-            // so it's not eligible for the cutoff that was just applied.
-            appendAuditEvent(db, {
-                tenantId: opts.tenantId,
-                actor,
-                op: 'audit_prune',
-                metadata: { cutoff, count, dryRun: false, olderThanDays: opts.olderThanDays },
-            });
-            db.exec('COMMIT');
-        }
-        catch (e) {
-            try {
-                db.exec('ROLLBACK');
-            }
-            catch { /* already rolled back; keep the original error */ }
-            throw e;
-        }
-    }
+    const count = pruneAuditRows(hippoRoot, { tenantId: opts.tenantId, cutoff, actor, olderThanDays: opts.olderThanDays, dryRun });
     return { cutoff, count, dryRun };
 }
 /**

package/dist/cli/audit.d.ts

@@ -1,3 +1,3 @@
-import { type CommandContext } from './shared.js';
-export declare function handleAudit({ hippoRoot, args, flags }: CommandContext): void;
+import { type CommandContext } from './flag-values.js';
+export declare function handleAudit({ hippoRoot, args, flags }: CommandContext): Promise<void>;
 //# sourceMappingURL=audit.d.ts.map

package/dist/cli/audit.js

@@ -1,15 +1,16 @@
 // `hippo audit`: list and prune the audit log.
 import { loadAllEntries } from '../store/entry-reads.js';
 import { deleteEntry, memoriesBackingObjects } from '../store/delete-and-batch.js';
-import { openHippoDb, closeHippoDb } from '../db.js';
-import { auditMemories, AUDIT_OPS } from '../audit.js';
-import * as api from '../api.js';
-import { resolveTenantId } from '../tenant.js';
-import { pruneAuditLog, parseOlderThanFlag } from '../audit-prune.js';
+import { auditMemories, AUDIT_OPS } from '../store/audit.js';
+import * as api from '../api/index.js';
+import { resolveTenantId } from '../store/tenant.js';
+import { pruneAuditLog, parseOlderThanFlag } from './audit-prune.js';
 import { printError } from './output.js';
+import { boolFlag, flagIsTrue, stringFlag } from './flag-values.js';
 import { requireInit, resolveAuthRoot } from './shared.js';
-import { repairAutomaticMemories } from '../quality-repair.js';
-import { getGlobalRoot } from '../shared.js';
+import { repairAutomaticMemories } from './quality-repair.js';
+import { getGlobalRoot } from '../sharing/shared.js';
+import { errorMessage } from '../util/log.js';
 // ---------------------------------------------------------------------------
 // Audit log subcommands (`hippo audit list`)
 // ---------------------------------------------------------------------------
@@ -19,23 +20,17 @@ function formatAuditRow(ev) {
     const meta = JSON.stringify(ev.metadata ?? {});
     return `${ev.ts}  ${ev.actor}  ${ev.op}  ${target}  ${meta}`;
 }
-function cmdAuditList(hippoRoot, flags) {
-    const root = resolveAuthRoot(hippoRoot, flags);
-    const asJson = Boolean(flags['json']);
-    const tenantId = resolveTenantId({});
-    const opFlag = typeof flags['op'] === 'string' ? flags['op'] : undefined;
+function readAuditOp(flags) {
+    const opFlag = stringFlag(flags, 'op');
     if (opFlag && !VALID_AUDIT_OPS.has(opFlag)) {
         // Built from the Set so the message cannot drift from the valid ops.
         const expected = Array.from(VALID_AUDIT_OPS).join(' | ');
         printError(`Unknown --op value: ${opFlag}. Expected one of: ${expected}.`);
         process.exit(1);
     }
-    const op = opFlag;
-    const since = typeof flags['since'] === 'string' ? flags['since'] : undefined;
-    if (since !== undefined && !Number.isFinite(new Date(since).getTime())) {
-        printError(`Invalid --since: ${since} (expected an ISO timestamp like 2026-04-22 or 2026-04-22T12:00:00Z).`);
-        process.exit(1);
-    }
+    return opFlag;
+}
+function readAuditLimit(flags) {
     const limitRaw = flags['limit'];
     let limit = 100;
     if (limitRaw !== undefined && typeof limitRaw !== 'boolean') {
@@ -50,8 +45,21 @@ function cmdAuditList(hippoRoot, flags) {
         printError(`--limit must be between 1 and 10000 (got ${limit}).`);
         process.exit(1);
     }
+    return limit;
+}
+async function cmdAuditList(hippoRoot, flags) {
+    const root = resolveAuthRoot(hippoRoot, flags);
+    const asJson = boolFlag(flags, 'json');
+    const tenantId = resolveTenantId({});
+    const op = readAuditOp(flags);
+    const since = stringFlag(flags, 'since');
+    if (since !== undefined && !Number.isFinite(new Date(since).getTime())) {
+        printError(`Invalid --since: ${since} (expected an ISO timestamp like 2026-04-22 or 2026-04-22T12:00:00Z).`);
+        process.exit(1);
+    }
+    const limit = readAuditLimit(flags);
     const ctx = { hippoRoot: root, tenantId, actor: { subject: 'cli', role: 'admin' } };
-    const events = api.auditList(ctx, { op, since, limit });
+    const events = await api.auditList(ctx, { op, since, limit });
     if (asJson) {
         console.log(JSON.stringify(events));
         return;
@@ -66,7 +74,7 @@ function cmdAuditList(hippoRoot, flags) {
     }
 }
 function cmdAuditPrune(hippoRoot, flags) {
-    const olderThanRaw = typeof flags['older-than'] === 'string' ? flags['older-than'] : '';
+    const olderThanRaw = stringFlag(flags, 'older-than') ?? '';
     if (!olderThanRaw) {
         printError('Usage: hippo audit prune --older-than <Nd> [--dry-run] [--tenant <t>]');
         process.exit(1);
@@ -76,22 +84,13 @@ function cmdAuditPrune(hippoRoot, flags) {
         olderThanDays = parseOlderThanFlag(olderThanRaw);
     }
     catch (e) {
-        printError(e.message);
+        printError(errorMessage(e));
         process.exit(1);
     }
-    const tenantId = typeof flags['tenant'] === 'string'
-        ? flags['tenant'].trim() || resolveTenantId({})
-        : resolveTenantId({});
-    const dryRun = flags['dry-run'] === true;
-    const asJson = Boolean(flags['json']);
-    const db = openHippoDb(hippoRoot);
-    let result;
-    try {
-        result = pruneAuditLog(db, { olderThanDays, tenantId, dryRun, actor: 'cli' });
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    const tenantId = stringFlag(flags, 'tenant')?.trim() || resolveTenantId({});
+    const dryRun = flagIsTrue(flags, 'dry-run');
+    const asJson = boolFlag(flags, 'json');
+    const result = pruneAuditLog(hippoRoot, { olderThanDays, tenantId, dryRun, actor: 'cli' });
     if (asJson) {
         console.log(JSON.stringify(result));
         return;
@@ -102,10 +101,10 @@ function cmdAuditPrune(hippoRoot, flags) {
         console.log('(dry-run; re-run without --dry-run to actually delete)');
     }
 }
-function cmdAuditLog(hippoRoot, args, flags) {
+async function cmdAuditLog(hippoRoot, args, flags) {
     const sub = args[0];
     if (sub === 'list') {
-        cmdAuditList(hippoRoot, flags);
+        await cmdAuditList(hippoRoot, flags);
         return;
     }
     if (sub === 'prune') {
@@ -115,41 +114,59 @@ function cmdAuditLog(hippoRoot, args, flags) {
     printError(`Unknown audit subcommand: ${sub}. Expected: list | prune.`);
     process.exit(1);
 }
-export function handleAudit({ hippoRoot, args, flags }) {
+function auditRepair(hippoRoot, flags) {
+    const apply = flagIsTrue(flags, 'apply') && flags['dry-run'] !== true;
+    const result = repairAutomaticMemories(flags['global'] ? getGlobalRoot() : hippoRoot, { tenantId: resolveTenantId({}), apply });
+    if (flags['json']) {
+        console.log(JSON.stringify(result));
+        return;
+    }
+    console.log(`Quality repair ${apply ? 'apply' : 'preview'}: ${result.issues.length} issue(s) across ${result.total} memories.`);
+    for (const issue of result.issues)
+        console.log(`  [${issue.disposition}] ${issue.id}: ${issue.reason}${issue.protection ? ` (${issue.protection})` : ''}`);
+    for (const blocker of result.blockers)
+        console.log(`  Blocked: ${blocker}. Repair never upgrades a store; any other hippo command does, then run repair again.`);
+    const restore = `hippo dormant restore <id>${flags['global'] ? ' --global' : ''}`;
+    if (result.backup)
+        console.log(`Backup: ${result.backup}\nMoved ${result.appliedIds.length} memories to dormant storage. Recovery: ${restore}.`);
+    else if (apply && result.supported)
+        console.log('Nothing moved: no unprotected memory has a certain defect.');
+    for (const warning of result.warnings)
+        console.log(`Warning: ${warning}`);
+    if (!apply)
+        console.log('Preview only. Add --apply to move set-aside memories to dormant storage. Pin a review memory to keep it.');
+}
+function fixAuditErrors(hippoRoot, result, flags) {
+    const errors = result.issues.filter(i => i.severity === 'error');
+    if (errors.length > 0 && flagIsTrue(flags, 'dry-run')) {
+        console.log(`\nWould remove ${errors.length} error-severity memories (dry run, nothing deleted).`);
+        console.log(`${result.issues.length - errors.length} warnings would remain (review manually).`);
+    }
+    else if (errors.length > 0) {
+        const removedCount = errors.filter((issue) => deleteEntry(hippoRoot, issue.memoryId, { reason: `audit --fix: ${issue.reason}`, automatic: true })).length;
+        console.log(`\nRemoved ${removedCount} error-severity memories.`);
+        console.log(`${result.issues.length - errors.length} warnings remain (review manually).`);
+    }
+    else {
+        console.log(`\nNo error-severity issues. Warnings require manual review.`);
+    }
+}
+export async function handleAudit({ hippoRoot, args, flags }) {
     if (args[0] === 'repair') {
-        const apply = flags['apply'] === true && flags['dry-run'] !== true;
-        const result = repairAutomaticMemories(flags['global'] ? getGlobalRoot() : hippoRoot, { tenantId: resolveTenantId({}), apply });
-        if (flags['json']) {
-            console.log(JSON.stringify(result));
-            return;
-        }
-        console.log(`Quality repair ${apply ? 'apply' : 'preview'}: ${result.issues.length} issue(s) across ${result.total} memories.`);
-        for (const issue of result.issues)
-            console.log(`  [${issue.disposition}] ${issue.id}: ${issue.reason}${issue.protection ? ` (${issue.protection})` : ''}`);
-        for (const blocker of result.blockers)
-            console.log(`  Blocked: ${blocker}. Repair never upgrades a store; any other hippo command does, then run repair again.`);
-        const restore = `hippo dormant restore <id>${flags['global'] ? ' --global' : ''}`;
-        if (result.backup)
-            console.log(`Backup: ${result.backup}\nMoved ${result.appliedIds.length} memories to dormant storage. Recovery: ${restore}.`);
-        else if (apply && result.supported)
-            console.log('Nothing moved: no unprotected memory has a certain defect.');
-        for (const warning of result.warnings)
-            console.log(`Warning: ${warning}`);
-        if (!apply)
-            console.log('Preview only. Add --apply to move set-aside memories to dormant storage. Pin a review memory to keep it.');
+        auditRepair(hippoRoot, flags);
         return;
     }
     // `audit list` and `audit prune` -> audit-log subcommands.
     // Other forms (no sub, --fix) keep the existing memory-quality auditor
     // for backwards compatibility.
     if (args[0] === 'list' || args[0] === 'prune') {
-        cmdAuditLog(hippoRoot, args, flags);
+        await cmdAuditLog(hippoRoot, args, flags);
         return;
     }
     requireInit(hippoRoot);
     const entries = loadAllEntries(hippoRoot, resolveTenantId({}));
     const result = auditMemories(entries, memoriesBackingObjects(hippoRoot));
-    const shouldFix = Boolean(flags['fix']);
+    const shouldFix = boolFlag(flags, 'fix');
     if (result.issues.length === 0) {
         console.log(`All ${result.total} memories passed quality checks.`);
     }
@@ -161,19 +178,7 @@ export function handleAudit({ hippoRoot, args, flags }) {
             console.log(`         "${issue.content.slice(0, 80)}${issue.content.length > 80 ? '...' : ''}"`);
         }
         if (shouldFix) {
-            const errors = result.issues.filter(i => i.severity === 'error');
-            if (errors.length > 0 && flags['dry-run'] === true) {
-                console.log(`\nWould remove ${errors.length} error-severity memories (dry run, nothing deleted).`);
-                console.log(`${result.issues.length - errors.length} warnings would remain (review manually).`);
-            }
-            else if (errors.length > 0) {
-                const removedCount = errors.filter((issue) => deleteEntry(hippoRoot, issue.memoryId, { reason: `audit --fix: ${issue.reason}`, automatic: true })).length;
-                console.log(`\nRemoved ${removedCount} error-severity memories.`);
-                console.log(`${result.issues.length - errors.length} warnings remain (review manually).`);
-            }
-            else {
-                console.log(`\nNo error-severity issues. Warnings require manual review.`);
-            }
+            fixAuditErrors(hippoRoot, result, flags);
         }
         else {
             console.log(`\nRun with --fix to auto-remove error-severity issues.`);

package/dist/cli/auth.d.ts

@@ -1,2 +1,3 @@
-export declare function cmdAuth(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
+import { type CliFlags } from './flag-values.js';
+export declare function cmdAuth(hippoRoot: string, args: string[], flags: CliFlags): void;
 //# sourceMappingURL=auth.d.ts.map