hippo-memory 1.59.0 → 1.61.0

package/dist/capture/transcript.js

@@ -0,0 +1,193 @@
+import { envHomeDir } from '../env.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import { isObjectLike, isStringValue } from '../capture-contract.js';
+/**
+ * Build a compact text summary from a Claude Code / OpenCode JSONL transcript.
+ * Keeps plain user messages and the final chunk of assistant text, drops
+ * thinking blocks, tool_use, and tool_result noise. Output is fed to the
+ * existing `extractFromText` pipeline.
+ *
+ * Exported for tests.
+ */
+/** Leading markers of the command lines Claude Code writes with type 'user'. */
+const CLAUDE_CODE_COMMAND_PREFIXES = ['<local-command-', '<command-name>', '<command-message>', '<command-args>'];
+function isNonHumanUserLine(entry, content) {
+    if (entry.isMeta === true || entry.isSidechain === true || entry.isCompactSummary === true || entry.promptSource === 'system')
+        return true;
+    const head = content.trimStart();
+    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. */
+export function humanUserText(entry, message) {
+    const content = message.content;
+    let text = '';
+    if (isStringValue(content)) {
+        text = content;
+    }
+    else if (Array.isArray(content) && !content.some((b) => isObjectLike(b) && 'type' in b && b.type === 'tool_result')) {
+        const parts = [];
+        for (const block of content) {
+            const blockText = isObjectLike(block) && 'type' in block && block.type === 'text' && 'text' in block ? block.text : undefined;
+            if (isStringValue(blockText) && !NON_HUMAN_BLOCK_PREFIXES.some((p) => blockText.trimStart().startsWith(p)))
+                parts.push(blockText);
+        }
+        text = parts.join('\n');
+    }
+    text = text.trim();
+    return text && !isNonHumanUserLine(entry, text) ? text : '';
+}
+export function collectSessionTurns(jsonl, visit) {
+    const lines = jsonl.split('\n').filter((l) => l.trim());
+    const turns = [];
+    for (const line of lines) {
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue; // a torn or partial transcript line carries no turn
+        }
+        if (!isObjectLike(entry) || !('type' in entry))
+            continue;
+        visit?.(entry);
+        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') });
+                }
+            }
+            continue;
+        }
+        // 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') });
+        }
+    }
+    return turns;
+}
+export function summariseTranscript(jsonl) {
+    return summariseSessionTurns(collectSessionTurns(jsonl));
+}
+export function summariseSessionTurns(turns) {
+    const userMessages = turns.filter((t) => t.role === 'user').map((t) => t.text);
+    const assistantTexts = turns.filter((t) => t.role === 'assistant').map((t) => t.text);
+    if (userMessages.length === 0 && assistantTexts.length === 0)
+        return '';
+    // Keep the tail: last ~20 user turns and last ~10 assistant replies.
+    // Session-end is about what was decided near the end, not at the start.
+    const tailUsers = userMessages.slice(-20);
+    const tailAssistants = assistantTexts.slice(-10);
+    return [
+        '# Session Summary',
+        '',
+        '## User Messages',
+        ...tailUsers.map((m) => `- ${m.replace(/\s+/g, ' ').slice(0, 500)}`),
+        '',
+        '## Assistant Responses',
+        ...tailAssistants.map((t) => t.slice(0, 2000)),
+    ].join('\n');
+}
+/**
+ * Resolve a transcript path for `--last-session`.
+ *
+ * Priority, where the first source present is the only one tried:
+ *   1. Explicit `transcriptPath` option (from `--transcript <path>`)
+ *   2. Stdin JSON payload (Claude Code / OpenCode SessionEnd hook shape)
+ *   3. Most recent `.jsonl` under `~/.claude/projects/<any>/`, only when the caller passes `mayScan` (only the caller knows it is not a hook) and there is no path and no stdin text, because this scan spans every project on the box
+ *
+ * Returns null when nothing resolves, a named transcript or payload whose file is missing included. Never throws.
+ */
+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;
+    }
+    if (!opts.mayScan)
+        return null;
+    const home = envHomeDir();
+    if (!home)
+        return null;
+    const projectsDir = path.join(home, '.claude', 'projects');
+    if (!fs.existsSync(projectsDir))
+        return null;
+    let newest = null;
+    try {
+        for (const entry of fs.readdirSync(projectsDir)) {
+            const subDir = path.join(projectsDir, entry);
+            const stat = fs.statSync(subDir);
+            if (!stat.isDirectory())
+                continue;
+            for (const file of fs.readdirSync(subDir)) {
+                if (!file.endsWith('.jsonl'))
+                    continue;
+                const full = path.join(subDir, file);
+                const m = fs.statSync(full).mtimeMs;
+                if (!newest || m > newest.mtime)
+                    newest = { path: full, mtime: m };
+            }
+        }
+    }
+    catch {
+        return null; // an unlistable projects dir means no transcript to find; the caller prints that
+    }
+    return newest?.path ?? null;
+}
+//# sourceMappingURL=transcript.js.map

package/dist/capture-error.js

@@ -2,7 +2,8 @@
 // stored, because error memories decay slowly and would crowd out real lessons; what is stored stays `observed`
 // until outcome feedback confirms it. Every failure, stored or not, goes to the failure log (ROADMAP CD13).
 import { createMemory } from './memory.js';
-import { writeEntry, loadContentsWithTag } from './store.js';
+import { writeEntry } from './store/entry-writes.js';
+import { loadContentsWithTag } from './store/entry-reads.js';
 import { loadConfig } from './config.js';
 import { closeHippoDb, openHippoDb } from './db.js';
 import { recordFailure } from './failure-log.js';

package/dist/churn-git.js

@@ -5,12 +5,14 @@ import * as os from 'os';
 import * as path from 'path';
 // A `git log --name-status` dump can run to tens of MB; default 1MB pipe would truncate it.
 const GIT_MAX_BUFFER = 64 * 1024 * 1024;
+// Longer than the 10 s of one-line git reads because a full log dump on a large repo is slow, yet bounded so a wedged git cannot stall sleep.
+const GIT_TIMEOUT_MS = 60_000;
 /** A real git failure (not git grep's expected exit-1-no-match). Callers abort the whole run on this. */
 export class GitReadError extends Error {
 }
 function runGit(args, repoRoot) {
     try {
-        return execFileSync('git', args, { cwd: repoRoot, encoding: 'utf8', maxBuffer: GIT_MAX_BUFFER, windowsHide: true });
+        return execFileSync('git', args, { cwd: repoRoot, encoding: 'utf8', maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, windowsHide: true });
     }
     catch (err) {
         throw new GitReadError(`git ${args.join(' ')} failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -19,7 +21,7 @@ function runGit(args, repoRoot) {
 // git grep exits 1 for "no match" -- a normal empty result, not a failure.
 function runGitGrepOrEmpty(args, repoRoot) {
     try {
-        return execFileSync('git', args, { cwd: repoRoot, encoding: 'utf8', maxBuffer: GIT_MAX_BUFFER, windowsHide: true });
+        return execFileSync('git', args, { cwd: repoRoot, encoding: 'utf8', maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, windowsHide: true });
     }
     catch (err) {
         // SAFETY: execFileSync attaches `status` to the thrown Error on a non-zero child exit.

package/dist/cli/audit.d.ts

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

package/dist/cli/audit.js

@@ -0,0 +1,159 @@
+// `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 { printError } from './output.js';
+import { requireInit, resolveAuthRoot } from './shared.js';
+// ---------------------------------------------------------------------------
+// Audit log subcommands (A5 stub auth — `hippo audit list`)
+// ---------------------------------------------------------------------------
+const VALID_AUDIT_OPS = new Set(AUDIT_OPS);
+function formatAuditRow(ev) {
+    const target = ev.targetId ?? '-';
+    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;
+    if (opFlag && !VALID_AUDIT_OPS.has(opFlag)) {
+        // Regenerate from Set to prevent future drift (v1.11.5: pre-v1.11.5 message
+        // was hand-maintained and had drifted — missed 'auth_revoke' and 'outcome').
+        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);
+    }
+    const limitRaw = flags['limit'];
+    let limit = 100;
+    if (limitRaw !== undefined && typeof limitRaw !== 'boolean') {
+        const parsed = parseInt(String(limitRaw), 10);
+        if (!Number.isFinite(parsed)) {
+            printError(`Invalid --limit value: ${String(limitRaw)} (expected a positive integer).`);
+            process.exit(1);
+        }
+        limit = parsed;
+    }
+    if (limit < 1 || limit > 10000) {
+        printError(`--limit must be between 1 and 10000 (got ${limit}).`);
+        process.exit(1);
+    }
+    const ctx = { hippoRoot: root, tenantId, actor: { subject: 'cli', role: 'admin' } };
+    const events = api.auditList(ctx, { op, since, limit });
+    if (asJson) {
+        console.log(JSON.stringify(events));
+        return;
+    }
+    if (events.length === 0) {
+        console.log('No audit events.');
+        return;
+    }
+    console.log('ts  actor  op  target_id  metadata');
+    for (const ev of events) {
+        console.log(formatAuditRow(ev));
+    }
+}
+function cmdAuditPrune(hippoRoot, flags) {
+    const olderThanRaw = typeof flags['older-than'] === 'string' ? flags['older-than'] : '';
+    if (!olderThanRaw) {
+        printError('Usage: hippo audit prune --older-than <Nd> [--dry-run] [--tenant <t>]');
+        process.exit(1);
+    }
+    let olderThanDays;
+    try {
+        olderThanDays = parseOlderThanFlag(olderThanRaw);
+    }
+    catch (e) {
+        printError(e.message);
+        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);
+    }
+    if (asJson) {
+        console.log(JSON.stringify(result));
+        return;
+    }
+    const verb = dryRun ? 'would delete' : 'deleted';
+    console.log(`audit prune: ${verb} ${result.count} row${result.count === 1 ? '' : 's'} for tenant "${tenantId}" with ts < ${result.cutoff}`);
+    if (dryRun) {
+        console.log('(dry-run; re-run without --dry-run to actually delete)');
+    }
+}
+function cmdAuditLog(hippoRoot, args, flags) {
+    const sub = args[0];
+    if (sub === 'list') {
+        cmdAuditList(hippoRoot, flags);
+        return;
+    }
+    if (sub === 'prune') {
+        cmdAuditPrune(hippoRoot, flags);
+        return;
+    }
+    printError(`Unknown audit subcommand: ${sub}. Expected: list | prune.`);
+    process.exit(1);
+}
+export function handleAudit({ hippoRoot, args, flags }) {
+    // `audit list` and `audit prune` -> A5 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);
+        return;
+    }
+    requireInit(hippoRoot);
+    const entries = loadAllEntries(hippoRoot, resolveTenantId({}));
+    const result = auditMemories(entries, memoriesBackingObjects(hippoRoot));
+    const shouldFix = Boolean(flags['fix']);
+    if (result.issues.length === 0) {
+        console.log(`All ${result.total} memories passed quality checks.`);
+    }
+    else {
+        console.log(`Audited ${result.total} memories: ${result.clean} clean, ${result.issues.length} issues\n`);
+        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 ? '...' : ''}"`);
+        }
+        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.`);
+            }
+        }
+        else {
+            console.log(`\nRun with --fix to auto-remove error-severity issues.`);
+        }
+    }
+}
+//# sourceMappingURL=audit.js.map

package/dist/cli/auth.d.ts

@@ -0,0 +1,2 @@
+export declare function cmdAuth(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
+//# sourceMappingURL=auth.d.ts.map

package/dist/cli/auth.js

@@ -0,0 +1,171 @@
+// `hippo auth`: create, list, revoke and scope API keys.
+import { openHippoDb, closeHippoDb } from '../db.js';
+import { listApiKeys } from '../auth.js';
+import * as api from '../api.js';
+import { resolveTenantId } from '../tenant.js';
+import { printError } from './output.js';
+import { resolveAuthRoot } from './shared.js';
+// ---------------------------------------------------------------------------
+// Auth subcommands (A5 stub auth)
+// ---------------------------------------------------------------------------
+function cmdAuthCreate(hippoRoot, flags) {
+    const root = resolveAuthRoot(hippoRoot, flags);
+    const tenantFlag = typeof flags['tenant'] === 'string' ? flags['tenant'] : undefined;
+    const labelFlag = typeof flags['label'] === 'string' ? flags['label'] : undefined;
+    const asJson = Boolean(flags['json']);
+    // v1.12.3: --role flag surfaces the api_keys.role column added v1.12.0
+    // sub-1. Accepts 'admin' | 'member' only; anything else exits 1 with a
+    // typed error so a typo doesn't silently default to admin.
+    const roleFlag = typeof flags['role'] === 'string' ? flags['role'] : undefined;
+    let role = 'admin';
+    if (roleFlag !== undefined) {
+        if (roleFlag !== 'admin' && roleFlag !== 'member') {
+            printError(`Invalid --role value: '${roleFlag}'. Use 'admin' or 'member'.`);
+            process.exit(1);
+        }
+        role = roleFlag;
+    }
+    // The CLI's --tenant flag is the only legitimate cross-tenant override
+    // (admin minting a key for another tenant from the local machine). It
+    // flows through ctx.tenantId, NOT through opts — authCreate's opts no
+    // longer accepts a tenantId field, so the HTTP layer cannot smuggle a
+    // body.tenantId across.
+    const ctx = {
+        hippoRoot: root,
+        tenantId: tenantFlag ?? resolveTenantId({}),
+        actor: api.adminActor('cli'),
+    };
+    const result = api.authCreate(ctx, { label: labelFlag, role });
+    if (asJson) {
+        console.log(JSON.stringify({
+            keyId: result.keyId,
+            plaintext: result.plaintext,
+            tenantId: result.tenantId,
+            label: labelFlag ?? null,
+            role: result.role,
+        }));
+        return;
+    }
+    console.log(`key_id:    ${result.keyId}`);
+    console.log(`plaintext: ${result.plaintext}`);
+    console.log(`role:      ${result.role}`);
+    console.log('');
+    console.log('!! WARNING: this is the ONLY time the plaintext key will be shown. !!');
+    console.log('!! Copy it now. Hippo stores only a scrypt hash and cannot recover it. !!');
+}
+function formatKeyRow(item) {
+    const label = item.label ?? '-';
+    const created = item.createdAt;
+    const revoked = item.revokedAt ?? '-';
+    // v1.12.3: role column surfaced
+    return `${item.keyId}  ${item.tenantId}  ${item.role}  ${label}  ${created}  ${revoked}`;
+}
+function cmdAuthList(hippoRoot, flags) {
+    const root = resolveAuthRoot(hippoRoot, flags);
+    const includeRevoked = Boolean(flags['all']);
+    const asJson = Boolean(flags['json']);
+    const db = openHippoDb(root);
+    let items;
+    try {
+        items = listApiKeys(db, { active: !includeRevoked });
+    }
+    finally {
+        closeHippoDb(db);
+    }
+    if (asJson) {
+        console.log(JSON.stringify(items));
+        return;
+    }
+    if (items.length === 0) {
+        console.log(includeRevoked ? 'No API keys.' : 'No active API keys. (Use --all to include revoked.)');
+        return;
+    }
+    console.log('key_id  tenant  role  label  created  revoked');
+    for (const item of items) {
+        console.log(formatKeyRow(item));
+    }
+}
+// The local CLI owns every tenant, so revoke and grant run in the key's own tenant.
+function keyContext(root, keyId) {
+    const hostCtx = { hippoRoot: root, tenantId: resolveTenantId({}), actor: api.adminActor('cli') };
+    const keyTenant = api.authKeyTenant(hostCtx, keyId);
+    if (keyTenant === undefined) {
+        printError(`Unknown key_id: ${keyId}`);
+        process.exit(1);
+    }
+    return { ...hostCtx, tenantId: keyTenant };
+}
+function cmdAuthRevoke(hippoRoot, keyId, flags) {
+    const ctx = keyContext(resolveAuthRoot(hippoRoot, flags), keyId);
+    let revokedAt;
+    try {
+        revokedAt = api.authRevoke(ctx, keyId).revokedAt;
+    }
+    catch (err) {
+        printError(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+    if (flags['json']) {
+        console.log(JSON.stringify({ keyId, revokedAt }));
+        return;
+    }
+    console.log(`Revoked ${keyId} at ${revokedAt}`);
+}
+/** EI2: `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, keyId, scope, grant, flags) {
+    const ctx = keyContext(resolveAuthRoot(hippoRoot, flags), keyId);
+    try {
+        if (grant)
+            api.authGrant(ctx, keyId, scope);
+        else
+            api.authUngrant(ctx, keyId, scope);
+    }
+    catch (err) {
+        printError(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+    if (flags['json']) {
+        console.log(JSON.stringify({ keyId, scope, granted: grant }));
+        return;
+    }
+    console.log(grant ? `Granted ${keyId} read access to ${scope}` : `Removed ${keyId}'s grant on ${scope}`);
+}
+export function cmdAuth(hippoRoot, args, flags) {
+    const sub = args[0];
+    if (!sub) {
+        printError('Usage: hippo auth <create|list|revoke|grant|ungrant> [options]');
+        process.exit(1);
+    }
+    const subArgs = args.slice(1);
+    switch (sub) {
+        case 'create':
+            cmdAuthCreate(hippoRoot, flags);
+            return;
+        case 'list':
+            cmdAuthList(hippoRoot, flags);
+            return;
+        case 'revoke': {
+            const keyId = subArgs[0];
+            if (!keyId) {
+                printError('Usage: hippo auth revoke <key_id>');
+                process.exit(1);
+            }
+            cmdAuthRevoke(hippoRoot, keyId, flags);
+            return;
+        }
+        case 'grant':
+        case 'ungrant': {
+            const [keyId, scope] = subArgs;
+            if (!keyId || !scope) {
+                printError(`Usage: hippo auth ${sub} <key_id> <scope>`);
+                process.exit(1);
+            }
+            cmdAuthScopeGrant(hippoRoot, keyId, scope, sub === 'grant', flags);
+            return;
+        }
+        default:
+            printError(`Unknown auth subcommand: ${sub}. Expected: create | list | revoke | grant | ungrant.`);
+            process.exit(1);
+    }
+}
+//# sourceMappingURL=auth.js.map

package/dist/cli/briefs.d.ts

@@ -0,0 +1,4 @@
+export declare function cmdProjectBrief(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
+export declare function cmdGraph(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
+export declare function cmdCustomerNote(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
+//# sourceMappingURL=briefs.d.ts.map