hippo-memory 1.71.0 → 2.0.0

package/dist/capture/session-worker.js

@@ -2,12 +2,11 @@
 // Two fast replies would otherwise start two workers that both read the dedupe keys before either writes.
 import * as fs from 'fs';
 import * as path from 'path';
-import { createHash } from 'node:crypto';
-import { homeDir } from '../hooks/shared.js';
-import { errorMessage, log as logger } from '../util/log.js';
+import { homeDir } from '../util/agent-homes.js';
+import { errorCode, 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';
+import { blockHash } 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))
@@ -79,10 +78,16 @@ function releaseSessionLock(lock) {
         logger.debug(`session lock not removed: ${errorMessage(err)}`);
     }
 }
-/** False when the sessions folder cannot be written, so the caller runs unlocked as before. */
+/** False when the request could not be queued; the caller then refuses the run, since an unlocked worker could race a live one. */
 function queueRun(files, mode) {
     try {
         fs.mkdirSync(path.dirname(files.queued), { recursive: true });
+    }
+    catch (err) {
+        logger.warn(`session worker: cannot create ${path.dirname(files.queued)}, so the ${mode} close is not run: ${errorMessage(err)}`);
+        return false;
+    }
+    try {
         // A full close outranks a turn close: it overwrites a queued turn, and a turn never replaces a queued full close.
         if (mode === 'full')
             fs.writeFileSync(files.queued, 'full');
@@ -91,7 +96,10 @@ function queueRun(files, mode) {
         return true;
     }
     catch (err) {
-        return err instanceof Error && 'code' in err && err.code === 'EEXIST';
+        if (errorCode(err) === 'EEXIST')
+            return true;
+        logger.warn(`session worker: cannot queue the ${mode} close in ${files.queued}, so it is not run: ${errorMessage(err)}`);
+        return false;
     }
 }
 /** Takes the queued request by renaming it, so one queued while this reads it lands in a fresh file. */
@@ -100,8 +108,10 @@ function takeQueued(queued) {
     try {
         fs.renameSync(queued, taken);
     }
-    catch {
-        // Nothing queued, or a rename refused for a moment; the request stays queued for the next round.
+    catch (err) {
+        // ENOENT means nothing is queued; any other refusal leaves the request queued for the next round, but is told.
+        if (errorCode(err) !== 'ENOENT')
+            logger.warn(`session worker: cannot take the queued request ${queued}: ${errorMessage(err)}`);
         return null;
     }
     try {
@@ -114,8 +124,10 @@ function takeQueued(queued) {
 /** Runs `work` unless a live worker holds this session, which then runs the request after its own so the last reply is never dropped. */
 export async function runSessionWorker(sessionId, mode, work) {
     const files = sessionStateFiles(sessionId);
-    if (files === null || !queueRun(files, mode))
+    if (files === null)
         return work(mode);
+    if (!queueRun(files, mode))
+        return;
     for (let take = takeSessionLock(files.lock); take !== 'held'; take = takeSessionLock(files.lock)) {
         if (take === 'unusable')
             return work(mode);
@@ -135,7 +147,7 @@ export async function runSessionWorker(sessionId, mode, work) {
     }
 }
 function turnKey(turn) {
-    return createHash('sha256').update(`${turn.role}\n${turn.text}`).digest('hex').slice(0, FINGERPRINT_HEX_CHARS);
+    return blockHash(`${turn.role}\n${turn.text}`);
 }
 /** The cursor position after `turns`: how many there were and a hash of the last. */
 export function turnPosition(turns) {

package/dist/capture/transcript.d.ts

@@ -9,7 +9,8 @@ interface TranscriptLineFlags {
 interface TranscriptMessage {
     content?: unknown;
 }
-/** The human's words on a Claude Code user line, '' when none; VS Code stores prompts as text blocks, beside its own open-file, selection and interrupt blocks. */
+/** The human's words on a Claude Code user line, '' when none; VS Code stores prompts as text blocks, beside its own open-file, selection
+ * and interrupt blocks. */
 export declare function humanUserText(entry: TranscriptLineFlags, message: TranscriptMessage): string;
 export interface SessionTurn {
     role: 'user' | 'assistant';

package/dist/capture/transcript.js

@@ -1,5 +1,5 @@
 import { envHomeDir, processEnv } from '../util/env.js';
-import { claudeConfigDir } from '../hooks/shared.js';
+import { claudeConfigDir } from '../util/agent-homes.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import { isObjectLike, isStringValue, readSessionEnd } from '../core/capture-contract.js';
@@ -17,7 +17,8 @@ function isNonHumanUserLine(entry, content) {
     return CLAUDE_CODE_COMMAND_PREFIXES.some((p) => head.startsWith(p));
 }
 const NON_HUMAN_BLOCK_PREFIXES = ['<ide_', '[Request interrupted by user'];
-/** The human's words on a Claude Code user line, '' when none; VS Code stores prompts as text blocks, beside its own open-file, selection and interrupt blocks. */
+/** The human's words on a Claude Code user line, '' when none; VS Code stores prompts as text blocks, beside its own open-file, selection
+ * and interrupt blocks. */
 export function humanUserText(entry, message) {
     const content = message.content;
     let text = '';
@@ -82,6 +83,8 @@ function claudeCodeTurn(entry) {
     }
     return chunks.length > 0 ? { role: 'assistant', text: chunks.join('\n') } : null;
 }
+// Codex stores its own context as user messages: the AGENTS.md text, and one tagged block each for the environment and app state.
+const CODEX_INJECTED_USER_TEXT = /^(?:# AGENTS\.md instructions\b|<([A-Za-z][\w-]*)(?:\s[^>]*)?>[\s\S]*<\/\1>$)/;
 // Codex rollout transcript shape: response_item -> payload.message
 function codexTurn(entry) {
     if (entry.type !== 'response_item')
@@ -99,7 +102,7 @@ function codexTurn(entry) {
             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()) {
+        if (role === 'user' && blockType === 'input_text' && isStringValue(blockText) && blockText.trim() && !CODEX_INJECTED_USER_TEXT.test(blockText.trim())) {
             chunks.push(blockText.trim());
         }
         if (role === 'assistant' && blockType === 'output_text' && isStringValue(blockText) && blockText.trim()) {

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

@@ -11,8 +11,10 @@ export declare function fitWorkingState(state: WorkingState): WorkingState;
 /** Each empty field falls back to `existing`'s, since a tool-heavy tail derives no task; null when all are empty, so blanks never replace a snapshot.
  *  Never across sessions: another session's task saved under this id would pass compact-resume's session check. */
 export declare function mergeWorkingState(derived: WorkingState, existing: TaskSnapshot | null, sessionId: string | null): WorkingState | null;
-/** Keeps the LAST maxChars behind a trim marker, aligned to a nearby line start: the summary runs oldest first, so a head cap would drop the newest working state. */
+/** Keeps the LAST maxChars behind a trim marker, aligned to a nearby line start: the summary runs oldest first, so a head cap would drop
+ * the newest working state. */
 export declare function truncateKeepNewest(text: string, maxChars: number): string;
-/** A session's task, summary and next step from its transcript tail, secrets scrubbed and capped, '' where none; null with a logged reason when nothing is derivable. */
+/** A session's task, summary and next step from its transcript tail, secrets scrubbed and capped, '' where none; null with a logged
+ * reason when nothing is derivable. */
 export declare function transcriptWorkingState(transcriptPath: string, log: (message: string) => void): Pick<TaskSnapshot, 'task' | 'summary' | 'next_step'> | null;
 //# sourceMappingURL=working-state.d.ts.map

package/dist/capture/working-state.js

@@ -36,7 +36,8 @@ export function mergeWorkingState(derived, existing, sessionId) {
     };
     return merged.task || merged.summary || merged.next_step ? merged : null;
 }
-/** Keeps the LAST maxChars behind a trim marker, aligned to a nearby line start: the summary runs oldest first, so a head cap would drop the newest working state. */
+/** Keeps the LAST maxChars behind a trim marker, aligned to a nearby line start: the summary runs oldest first, so a head cap would drop
+ * the newest working state. */
 export function truncateKeepNewest(text, maxChars) {
     if (text.length <= maxChars)
         return text;
@@ -123,7 +124,8 @@ function lastAssistantTextBlock(jsonl) {
     }
     return '';
 }
-/** A session's task, summary and next step from its transcript tail, secrets scrubbed and capped, '' where none; null with a logged reason when nothing is derivable. */
+/** A session's task, summary and next step from its transcript tail, secrets scrubbed and capped, '' where none; null with a logged
+ * reason when nothing is derivable. */
 export function transcriptWorkingState(transcriptPath, log) {
     let tail = '';
     let rawTask = '';

package/dist/cli/audit-prune.d.ts

@@ -1,28 +1,3 @@
-/** Audit log retention pruning: opt-in per tenant because retention floors (HIPAA, SOX, GDPR) apply.
- * The audit_prune row is written after the DELETE, so a call never prunes its own record. */
-export interface PruneAuditOpts {
-    /** Cutoff in days. Rows with `ts < (now - N days)` are deleted. */
-    olderThanDays: number;
-    /** Tenant scope. Required: prune is always tenant-scoped. */
-    tenantId: string;
-    /** When true, count matching rows but do NOT delete. Default false. */
-    dryRun?: boolean;
-    /** Actor recording the prune in the audit trail. Default 'cli'. */
-    actor?: string;
-}
-export interface PruneAuditResult {
-    /** ISO timestamp of the cutoff. Rows with ts strictly less than this were deleted. */
-    cutoff: string;
-    /** Number of audit_log rows deleted (or that would be deleted, if dryRun). */
-    count: number;
-    /** Echo back whether this was a dry run. */
-    dryRun: boolean;
-}
-/** Cutoff ISO timestamp for N days ago; exported so tests can pin "now" without mocking Date. */
-export declare function computeCutoff(days: number, now?: Date): string;
-/** Delete audit_log rows older than `olderThanDays` for `tenantId`, emitting an `audit_prune` event.
- * Throws on non-positive days or a missing tenantId. */
-export declare function pruneAuditLog(hippoRoot: string, opts: PruneAuditOpts): PruneAuditResult;
 /** Parse `--older-than`: bare integer days (`30`) or with a `d` suffix (`30d`); throws on any other format. */
 export declare function parseOlderThanFlag(raw: string): number;
 //# sourceMappingURL=audit-prune.d.ts.map

package/dist/cli/audit-prune.js

@@ -1,30 +1,4 @@
-/** Audit log retention pruning: opt-in per tenant because retention floors (HIPAA, SOX, GDPR) apply.
- * The audit_prune row is written after the DELETE, so a call never prunes its own record. */
-import { pruneAuditRows } from '../store/audit.js';
-import { DAY_MS } from '../util/time.js';
-/** Cutoff ISO timestamp for N days ago; exported so tests can pin "now" without mocking Date. */
-export function computeCutoff(days, now = new Date()) {
-    const cutoff = new Date(now.getTime() - days * DAY_MS);
-    return cutoff.toISOString();
-}
-function isTenantIdString(value) {
-    return typeof value === 'string';
-}
-/** Delete audit_log rows older than `olderThanDays` for `tenantId`, emitting an `audit_prune` event.
- * Throws on non-positive days or a missing tenantId. */
-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}`);
-    }
-    if (!opts.tenantId || !isTenantIdString(opts.tenantId)) {
-        throw new Error('pruneAuditLog: tenantId is required');
-    }
-    const dryRun = opts.dryRun === true;
-    const actor = opts.actor ?? 'cli';
-    const cutoff = computeCutoff(opts.olderThanDays);
-    const count = pruneAuditRows(hippoRoot, { tenantId: opts.tenantId, cutoff, actor, olderThanDays: opts.olderThanDays, dryRun });
-    return { cutoff, count, dryRun };
-}
+// The `--older-than` flag of `hippo audit prune`; the prune itself is api.pruneAuditLog.
 /** Parse `--older-than`: bare integer days (`30`) or with a `d` suffix (`30d`); throws on any other format. */
 export function parseOlderThanFlag(raw) {
     const m = raw.match(/^(\d+)(d)?$/i);

package/dist/cli/audit.js

@@ -1,14 +1,13 @@
 // `hippo audit`: list and prune the audit log.
-import { loadAllEntries } from '../store/entry-reads.js';
-import { memoriesBackingObjects } from '../store/delete-and-batch.js';
-import { auditMemories, AUDIT_OPS } from '../store/audit.js';
+import { truncateWithEllipsis } from '../util/ellipsize.js';
+import { DEFAULT_LIST_LIMIT } from '../util/limits.js';
+import { AUDIT_OPS } from '../store/audit.js';
 import * as api from '../api/index.js';
-import { pruneAuditLog, parseOlderThanFlag } from './audit-prune.js';
+import { parseOlderThanFlag } from './audit-prune.js';
 import { printError } from './output.js';
 import { cliApiContext } from './api-context.js';
 import { boolFlag, flagIsTrue, isBooleanFlag, stringFlag } from './flag-values.js';
 import { requireInit, resolveAuthRoot } from './shared.js';
-import { repairAutomaticMemories } from '../store/quality-repair.js';
 import { getGlobalRoot } from '../sharing/global-store.js';
 import { errorMessage } from '../util/log.js';
 import { CliExit } from './exit.js';
@@ -33,7 +32,7 @@ function readAuditOp(flags) {
 }
 function readAuditLimit(flags) {
     const limitRaw = flags['limit'];
-    let limit = 100;
+    let limit = DEFAULT_LIST_LIMIT;
     if (limitRaw !== undefined && !isBooleanFlag(limitRaw)) {
         const parsed = parseInt(String(limitRaw), 10);
         if (!Number.isFinite(parsed)) {
@@ -73,7 +72,7 @@ async function cmdAuditList(hippoRoot, tenantId, flags) {
         console.log(formatAuditRow(ev));
     }
 }
-function cmdAuditPrune(hippoRoot, ctxTenantId, flags) {
+async function cmdAuditPrune(hippoRoot, ctxTenantId, flags) {
     const olderThanRaw = stringFlag(flags, 'older-than') ?? '';
     if (!olderThanRaw) {
         printError('Usage: hippo audit prune --older-than <Nd> [--dry-run] [--tenant <t>]');
@@ -90,7 +89,7 @@ function cmdAuditPrune(hippoRoot, ctxTenantId, flags) {
     const tenantId = stringFlag(flags, 'tenant')?.trim() || ctxTenantId;
     const dryRun = flagIsTrue(flags, 'dry-run');
     const asJson = boolFlag(flags, 'json');
-    const result = pruneAuditLog(hippoRoot, { olderThanDays, tenantId, dryRun, actor: 'cli' });
+    const result = await api.pruneAuditLog(cliApiContext(hippoRoot, tenantId), { olderThanDays, dryRun });
     if (asJson) {
         console.log(JSON.stringify(result));
         return;
@@ -108,15 +107,15 @@ async function cmdAuditLog(hippoRoot, tenantId, args, flags) {
         return;
     }
     if (sub === 'prune') {
-        cmdAuditPrune(hippoRoot, tenantId, flags);
+        await cmdAuditPrune(hippoRoot, tenantId, flags);
         return;
     }
     printError(`Unknown audit subcommand: ${sub}. Expected: list | prune.`);
     throw new CliExit(1);
 }
-function auditRepair(hippoRoot, tenantId, flags) {
+async function auditRepair(hippoRoot, tenantId, flags) {
     const apply = flagIsTrue(flags, 'apply') && flags['dry-run'] !== true;
-    const result = repairAutomaticMemories(flags['global'] ? getGlobalRoot() : hippoRoot, { tenantId, apply });
+    const result = await api.repairMemoryQuality(cliApiContext(flags['global'] ? getGlobalRoot() : hippoRoot, tenantId), apply);
     if (flags['json']) {
         console.log(JSON.stringify(result));
         return;
@@ -124,8 +123,10 @@ function auditRepair(hippoRoot, tenantId, flags) {
     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.`);
+    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}.`);
@@ -136,7 +137,7 @@ function auditRepair(hippoRoot, tenantId, flags) {
     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, tenantId, result, flags) {
+async function fixAuditErrors(hippoRoot, tenantId, 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).`);
@@ -144,7 +145,7 @@ function fixAuditErrors(hippoRoot, tenantId, result, flags) {
     }
     else if (errors.length > 0) {
         const ctx = cliApiContext(hippoRoot, tenantId);
-        const removedCount = api.removeAuditErrors(ctx, 'audit --fix', errors).length;
+        const removedCount = (await api.removeAuditErrors(ctx, 'audit --fix', errors)).length;
         console.log(`\nRemoved ${removedCount} error-severity memories.`);
         console.log(`${result.issues.length - errors.length} warnings remain (review manually).`);
     }
@@ -154,7 +155,7 @@ function fixAuditErrors(hippoRoot, tenantId, result, flags) {
 }
 export async function handleAudit({ hippoRoot, tenantId, args, flags }) {
     if (args[0] === 'repair') {
-        auditRepair(hippoRoot, tenantId, flags);
+        await auditRepair(hippoRoot, tenantId, flags);
         return;
     }
     // `audit list` and `audit prune` are the audit-log subcommands; other forms (no sub, --fix) keep the memory-quality auditor.
@@ -163,8 +164,7 @@ export async function handleAudit({ hippoRoot, tenantId, args, flags }) {
         return;
     }
     requireInit(hippoRoot);
-    const entries = loadAllEntries(hippoRoot, tenantId);
-    const result = auditMemories(entries, memoriesBackingObjects(hippoRoot));
+    const result = await api.auditMemoryQuality(cliApiContext(hippoRoot, tenantId));
     const shouldFix = boolFlag(flags, 'fix');
     if (result.issues.length === 0) {
         console.log(`All ${result.total} memories passed quality checks.`);
@@ -174,10 +174,10 @@ export async function handleAudit({ hippoRoot, tenantId, args, flags }) {
         for (const issue of result.issues) {
             const icon = issue.severity === 'error' ? 'ERR' : 'WARN';
             console.log(`  [${icon}] ${issue.memoryId}: ${issue.reason}`);
-            console.log(`         "${issue.content.slice(0, 80)}${issue.content.length > 80 ? '...' : ''}"`);
+            console.log(`         "${truncateWithEllipsis(issue.content, 80)}"`);
         }
         if (shouldFix) {
-            fixAuditErrors(hippoRoot, tenantId, result, flags);
+            await fixAuditErrors(hippoRoot, tenantId, result, flags);
         }
         else {
             console.log(`\nRun with --fix to auto-remove error-severity issues.`);

package/dist/cli/auth.d.ts

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

package/dist/cli/auth.js

@@ -1,5 +1,4 @@
 // `hippo auth`: create, list, revoke and scope API keys.
-import { listApiKeys } from '../store/auth.js';
 import * as api from '../api/index.js';
 import { cliApiContext } from './api-context.js';
 import { printError } from './output.js';
@@ -29,7 +28,7 @@ function noteMintDefaults(roleGiven, expiryGiven) {
     if (notes.length > 0)
         printError(`hippo auth create: ${notes.join('; ')}.`);
 }
-function cmdAuthCreate(hippoRoot, defaultTenantId, flags) {
+async function cmdAuthCreate(hippoRoot, defaultTenantId, flags) {
     const root = resolveAuthRoot(hippoRoot, flags);
     const tenantFlag = stringFlag(flags, 'tenant');
     const labelFlag = stringFlag(flags, 'label');
@@ -46,7 +45,7 @@ function cmdAuthCreate(hippoRoot, defaultTenantId, flags) {
     const ctx = cliApiContext(root, tenantFlag ?? defaultTenantId);
     let result;
     try {
-        result = api.authCreate(ctx, { label: labelFlag, role, ttlDays, noExpiry: noExpiry || undefined });
+        result = await api.authCreate(ctx, { label: labelFlag, role, ttlDays, noExpiry: noExpiry || undefined });
     }
     catch (err) {
         if (!(err instanceof api.BadRequestError))
@@ -81,11 +80,11 @@ function formatKeyRow(item) {
     const revoked = item.revokedAt ?? '-';
     return `${item.keyId}  ${item.tenantId}  ${item.role}  ${label}  ${created}  ${expires}  ${revoked}`;
 }
-function cmdAuthList(hippoRoot, flags) {
+function cmdAuthList(hippoRoot, tenantId, flags) {
     const root = resolveAuthRoot(hippoRoot, flags);
     const includeRevoked = boolFlag(flags, 'all');
     const asJson = boolFlag(flags, 'json');
-    const items = listApiKeys(root, { active: !includeRevoked });
+    const items = api.authListAllTenants(cliApiContext(root, tenantId), !includeRevoked);
     if (asJson) {
         console.log(JSON.stringify(items));
         return;
@@ -100,20 +99,20 @@ function cmdAuthList(hippoRoot, flags) {
     }
 }
 // The local CLI owns every tenant, so revoke and grant run in the key's own tenant.
-function keyContext(root, tenantId, keyId) {
+async function keyContext(root, tenantId, keyId) {
     const hostCtx = cliApiContext(root, tenantId);
-    const keyTenant = api.authKeyTenant(hostCtx, keyId);
+    const keyTenant = await api.authKeyTenant(hostCtx, keyId);
     if (keyTenant === undefined) {
         printError(`Unknown key_id: ${keyId}`);
         throw new CliExit(1);
     }
     return { ...hostCtx, tenantId: keyTenant };
 }
-function cmdAuthRevoke(hippoRoot, tenantId, keyId, flags) {
-    const ctx = keyContext(resolveAuthRoot(hippoRoot, flags), tenantId, keyId);
+async function cmdAuthRevoke(hippoRoot, tenantId, keyId, flags) {
+    const ctx = await keyContext(resolveAuthRoot(hippoRoot, flags), tenantId, keyId);
     let revokedAt;
     try {
-        revokedAt = api.authRevoke(ctx, keyId).revokedAt;
+        revokedAt = (await api.authRevoke(ctx, keyId)).revokedAt;
     }
     catch (err) {
         printError(`Error: ${errorMessage(err)}`);
@@ -126,8 +125,8 @@ function cmdAuthRevoke(hippoRoot, tenantId, keyId, flags) {
     console.log(`Revoked ${keyId} at ${revokedAt}`);
 }
 /** `hippo auth grant|ungrant <key_id> <scope>`, routed through api so the tenant, restricted-scope and audit checks live in one place. */
-function cmdAuthScopeGrant(hippoRoot, tenantId, keyId, scope, grant, flags) {
-    const ctx = keyContext(resolveAuthRoot(hippoRoot, flags), tenantId, keyId);
+async function cmdAuthScopeGrant(hippoRoot, tenantId, keyId, scope, grant, flags) {
+    const ctx = await keyContext(resolveAuthRoot(hippoRoot, flags), tenantId, keyId);
     try {
         if (grant)
             api.authGrant(ctx, keyId, scope);
@@ -144,7 +143,7 @@ function cmdAuthScopeGrant(hippoRoot, tenantId, keyId, scope, grant, flags) {
     }
     console.log(grant ? `Granted ${keyId} read access to ${scope}` : `Removed ${keyId}'s grant on ${scope}`);
 }
-export function handleAuth({ hippoRoot, tenantId, args, flags }) {
+export async function handleAuth({ hippoRoot, tenantId, args, flags }) {
     const sub = args[0];
     if (!sub) {
         printError('Usage: hippo auth <create|list|revoke|grant|ungrant> [options]');
@@ -153,10 +152,10 @@ export function handleAuth({ hippoRoot, tenantId, args, flags }) {
     const subArgs = args.slice(1);
     switch (sub) {
         case 'create':
-            cmdAuthCreate(hippoRoot, tenantId, flags);
+            await cmdAuthCreate(hippoRoot, tenantId, flags);
             return;
         case 'list':
-            cmdAuthList(hippoRoot, flags);
+            cmdAuthList(hippoRoot, tenantId, flags);
             return;
         case 'revoke': {
             const keyId = subArgs[0];
@@ -164,7 +163,7 @@ export function handleAuth({ hippoRoot, tenantId, args, flags }) {
                 printError('Usage: hippo auth revoke <key_id>');
                 throw new CliExit(1);
             }
-            cmdAuthRevoke(hippoRoot, tenantId, keyId, flags);
+            await cmdAuthRevoke(hippoRoot, tenantId, keyId, flags);
             return;
         }
         case 'grant':
@@ -174,7 +173,7 @@ export function handleAuth({ hippoRoot, tenantId, args, flags }) {
                 printError(`Usage: hippo auth ${sub} <key_id> <scope>`);
                 throw new CliExit(1);
             }
-            cmdAuthScopeGrant(hippoRoot, tenantId, keyId, scope, sub === 'grant', flags);
+            await cmdAuthScopeGrant(hippoRoot, tenantId, keyId, scope, sub === 'grant', flags);
             return;
         }
         default:

package/dist/cli/briefs.d.ts

@@ -1,5 +1,2 @@
-import { type CommandContext } from './flag-values.js';
-export declare function handleProjectBrief({ hippoRoot, tenantId, args, flags }: CommandContext): void;
-export declare function handleGraph({ hippoRoot, tenantId, args, flags }: CommandContext): void;
-export declare function handleCustomerNote({ hippoRoot, tenantId, args, flags }: CommandContext): void;
+export declare const handleProjectBrief: (ctx: import("./flag-values.js").CommandContext) => void;
 //# sourceMappingURL=briefs.d.ts.map