hippo-memory 1.70.0 → 1.72.0

package/dist/cli/curate.js

@@ -1,39 +1,36 @@
 // Verbs that weaken, suppress or retire memories: outcome, forget, conflicts, reject, dormant, quarantine, invalidate.
+import { truncateWithEllipsis } from '../util/ellipsize.js';
 import * as path from 'path';
-import { readEntry } from '../store/entry-reads.js';
-import { listMemoryConflicts, resolveConflict } from '../store/conflicts.js';
-import { rejectValue, unrejectValue, listRejectionsForTenant } from '../trust/reject-flow.js';
-import { RejectedValueError } from '../store/rejection.js';
+import { unrejectValue, listRejectionsForTenant } from '../trust/reject-flow.js';
+import { RejectedValueError } from '../core/api-errors.js';
 import { loadConfig } from '../core/config.js';
+import { RawAppendOnlyError } from '../core/raw-append-only.js';
 import { isGitRepo } from '../learn/autolearn.js';
-import { invalidateMatching } from '../learn/invalidation.js';
 import * as api from '../api/index.js';
+import { getMemory } from '../api/memories.js';
 import * as client from './client.js';
-import { resolveTenantId } from '../store/tenant.js';
+import { cliApiContext } from './api-context.js';
 import { printError } from './output.js';
-import { parseCountFlag, boolFlag, flagIsTrue, stringFlag } from './flag-values.js';
+import { parseCountFlag, boolFlag, flagIsTrue, nonEmptyStringFlag, stringFlag } from './flag-values.js';
 import { requireInit, runChurnStaleForRepo, runViaServerIfAvailable, resolveAuthRoot } from './shared.js';
 import { fmt } from './print.js';
 import { errorMessage } from '../util/log.js';
 import { DIGEST_DISPLAY_CHARS, CONTENT_PREVIEW_CHARS, DATE_PREFIX_CHARS } from '../util/token-text.js';
+import { CliExit } from './exit.js';
 const CONFLICT_PREVIEW_CHARS = 120;
 const REJECTED_DIGEST_LIST_CHARS = 16;
 const DORMANT_PREVIEW_CHARS = 100;
 const STRENGTH_DECIMALS = 3;
-export function cmdOutcome(hippoRoot, flags) {
+export function handleOutcome({ hippoRoot, tenantId, flags }) {
     requireInit(hippoRoot);
     const good = boolFlag(flags, 'good');
     const bad = boolFlag(flags, 'bad');
     if (!good && !bad) {
         printError('Specify --good or --bad');
-        process.exit(1);
+        throw new CliExit(1);
     }
     // Through api.outcome so every CLI outcome writes one audit_log row per id, as the MCP path does.
-    const ctx = {
-        hippoRoot,
-        tenantId: resolveTenantId({}),
-        actor: api.adminActor('cli'),
-    };
+    const ctx = cliApiContext(hippoRoot, tenantId);
     const specificId = flags['id'] ? String(flags['id']) : null;
     let updated;
     if (specificId) {
@@ -51,16 +48,11 @@ export function cmdOutcome(hippoRoot, flags) {
 }
 // Shared between the forget dispatch and cmdForget so the message can't drift.
 const ARCHIVE_REASON_REQUIRED = 'hippo forget --archive requires --reason "<why>" (recorded on the archive).';
-function cmdForget(hippoRoot, id, flags) {
+function cmdForget(hippoRoot, tenantId, id, flags) {
     requireInit(hippoRoot);
-    const ctx = {
-        hippoRoot,
-        tenantId: resolveTenantId({}),
-        actor: api.adminActor('cli'),
-    };
-    // Raw memories (Slack / GitHub connector ingestion) are append-only: a
-    // BEFORE-DELETE trigger aborts any delete. archiveRaw is the sanctioned
-    // removal path; it records ctx.actor as the archiver for provenance.
+    const ctx = cliApiContext(hippoRoot, tenantId);
+    // Raw memories (connector ingestion) are append-only: a BEFORE-DELETE trigger aborts any delete,
+    // so archiveRaw is the sanctioned removal path and records ctx.actor as the archiver.
     if (flagIsTrue(flags, 'archive')) {
         archiveForgottenRaw(ctx, id, stringFlag(flags, 'reason') ?? null);
         return;
@@ -70,14 +62,14 @@ function cmdForget(hippoRoot, id, flags) {
         console.log(`Forgot ${id}`);
     }
     catch (err) {
-        reportForgetFailure(ctx, id, errorMessage(err));
-        process.exit(1);
+        reportForgetFailure(ctx, id, err);
+        throw new CliExit(1);
     }
 }
 function archiveForgottenRaw(ctx, id, reason) {
     if (!reason) {
         printError(ARCHIVE_REASON_REQUIRED);
-        process.exit(1);
+        throw new CliExit(1);
     }
     try {
         api.archiveRaw(ctx, id, reason);
@@ -85,11 +77,11 @@ function archiveForgottenRaw(ctx, id, reason) {
     }
     catch (err) {
         printError(`Could not archive ${id}: ${errorMessage(err)}`);
-        process.exit(1);
+        throw new CliExit(1);
     }
 }
-function reportForgetFailure(ctx, id, msg) {
-    if (/append-only/i.test(msg)) {
+function reportForgetFailure(ctx, id, cause) {
+    if (cause instanceof RawAppendOnlyError) {
         // The delete was refused by the append-only trigger — this is a raw
         // memory, not a missing one. Point the user at the archive path.
         printError(rawForgetRefusal(id));
@@ -108,27 +100,27 @@ function rawForgetRefusal(id) {
     return `Cannot forget ${id}: it is a raw, append-only memory. Archive it instead: hippo forget ${id} --archive --reason "<why>"`;
 }
 // Refuses exactly where the real run would, so "Would forget" is a promise, not a guess.
-function previewForget(hippoRoot, id, archive) {
+async function previewForget(hippoRoot, tenantId, id, archive) {
     requireInit(hippoRoot);
-    const entry = readEntry(hippoRoot, id, resolveTenantId({}));
+    const entry = await getMemory(cliApiContext(hippoRoot, tenantId), id);
     if (!entry) {
         printError(`Memory not found: ${id}`);
-        process.exit(1);
+        throw new CliExit(1);
     }
     if (!archive && entry.kind === 'raw') {
         printError(rawForgetRefusal(id));
-        process.exit(1);
+        throw new CliExit(1);
     }
     if (archive && entry.kind !== 'raw') {
         printError(`Could not archive ${id}: memory ${id} is not raw (kind=${entry.kind})`);
-        process.exit(1);
+        throw new CliExit(1);
     }
-    const snippet = entry.content.length > CONTENT_PREVIEW_CHARS ? `${entry.content.slice(0, CONTENT_PREVIEW_CHARS)}...` : entry.content;
+    const snippet = truncateWithEllipsis(entry.content, CONTENT_PREVIEW_CHARS);
     console.log(`Would ${archive ? 'archive' : 'forget'} ${id} (dry run, nothing changed): "${snippet}"`);
 }
-export function cmdConflicts(hippoRoot, flags) {
+export function handleConflicts({ hippoRoot, tenantId, flags }) {
     requireInit(hippoRoot);
-    const conflicts = listMemoryConflicts(hippoRoot, String(flags['status'] ?? 'open'));
+    const conflicts = api.listConflicts(cliApiContext(hippoRoot, tenantId), String(flags['status'] ?? 'open'), { everyTenant: true });
     if (flags['json']) {
         console.log(JSON.stringify({ conflicts }, null, 2));
         return;
@@ -146,43 +138,43 @@ export function cmdConflicts(hippoRoot, flags) {
     }
 }
 /** Shown when --keep is missing, to help the user decide. */
-function showConflictForResolve(hippoRoot, conflictId, tenantId) {
-    const conflicts = listMemoryConflicts(hippoRoot, 'open', tenantId);
+async function showConflictForResolve(hippoRoot, conflictId, tenantId) {
+    const conflicts = api.listConflicts(cliApiContext(hippoRoot, tenantId), 'open');
     const conflict = conflicts.find((c) => c.id === conflictId);
     if (!conflict) {
         printError(`Conflict ${conflictId} not found or already resolved.`);
-        process.exit(1);
+        throw new CliExit(1);
     }
     console.log(`Conflict ${conflictId}:`);
     console.log(`  ${conflict.memory_a_id} <-> ${conflict.memory_b_id}`);
     console.log(`  Reason: ${conflict.reason}`);
     console.log('');
-    const entryA = readEntry(hippoRoot, conflict.memory_a_id, tenantId);
-    const entryB = readEntry(hippoRoot, conflict.memory_b_id, tenantId);
+    const ctx = cliApiContext(hippoRoot, tenantId);
+    const entryA = await getMemory(ctx, conflict.memory_a_id);
+    const entryB = await getMemory(ctx, conflict.memory_b_id);
     if (entryA) {
         console.log(`  [A] ${conflict.memory_a_id}:`);
-        console.log(`      ${entryA.content.slice(0, CONFLICT_PREVIEW_CHARS)}${entryA.content.length > CONFLICT_PREVIEW_CHARS ? '...' : ''}`);
+        console.log(`      ${truncateWithEllipsis(entryA.content, CONFLICT_PREVIEW_CHARS)}`);
     }
     if (entryB) {
         console.log(`  [B] ${conflict.memory_b_id}:`);
-        console.log(`      ${entryB.content.slice(0, CONFLICT_PREVIEW_CHARS)}${entryB.content.length > CONFLICT_PREVIEW_CHARS ? '...' : ''}`);
+        console.log(`      ${truncateWithEllipsis(entryB.content, CONFLICT_PREVIEW_CHARS)}`);
     }
     console.log('');
     console.log(`Resolve with: hippo resolve ${conflictId} --keep <memory_id> [--forget] [--reject-loser [--reason "<why>"]]`);
 }
-export function cmdResolve(hippoRoot, args, flags) {
+export async function handleResolve({ hippoRoot, tenantId, args, flags }) {
     requireInit(hippoRoot);
     const rawId = args[0] ?? '';
     // Accept "42" or "conflict_42"
     const conflictId = parseInt(rawId.replace(/^conflict_/, ''), 10);
     if (isNaN(conflictId)) {
         printError('Usage: hippo resolve <conflict_id> --keep <memory_id> [--forget]');
-        process.exit(1);
+        throw new CliExit(1);
     }
-    const tenantId = resolveTenantId({});
     const keepId = String(flags['keep'] ?? '').trim();
     if (!keepId) {
-        showConflictForResolve(hippoRoot, conflictId, tenantId);
+        await showConflictForResolve(hippoRoot, conflictId, tenantId);
         return;
     }
     const forgetLoser = boolFlag(flags, 'forget');
@@ -190,14 +182,12 @@ export function cmdResolve(hippoRoot, args, flags) {
     // --reason is optional here, unlike `hippo reject`: resolve already has the conflict id and keepId.
     const rejectLoser = boolFlag(flags, 'reject-loser');
     const reasonFlag = stringFlag(flags, 'reason');
-    const result = resolveConflict(hippoRoot, conflictId, keepId, forgetLoser, tenantId, {
-        rejectLoserValue: rejectLoser,
+    const result = api.resolveMemoryConflict(cliApiContext(hippoRoot, tenantId), conflictId, {
+        keepId,
+        forget: forgetLoser,
+        rejectLoser,
         reason: reasonFlag,
     });
-    if (!result) {
-        printError(`Could not resolve conflict ${conflictId}. Check the ID and --keep value.`);
-        process.exit(1);
-    }
     const action = rejectLoser
         ? 'rejected (tombstoned) and removed'
         : forgetLoser
@@ -205,37 +195,31 @@ export function cmdResolve(hippoRoot, args, flags) {
             : 'weakened (half-life halved)';
     console.log(`Resolved conflict ${conflictId}: kept ${keepId}, ${action} ${result.loserId}`);
 }
-// ---------------------------------------------------------------------------
 // reject / rejections / unreject
-// ---------------------------------------------------------------------------
-export function cmdReject(hippoRoot, args, flags) {
+export function handleReject({ hippoRoot, tenantId, args, flags }) {
     // Store resolution mirrors `hippo remember`: --global writes to the
     // global store, otherwise the local store (requireInit'd via resolveAuthRoot).
     const root = resolveAuthRoot(hippoRoot, flags);
-    const tenantId = resolveTenantId({});
     // --reason is REQUIRED: the tombstone stores no content, so reason is its only human-readable identity.
     const reason = (stringFlag(flags, 'reason') ?? '').trim();
     if (!reason) {
         printError('hippo reject requires --reason "<why>" (the tombstone stores no content; reason is its only identity).');
-        process.exit(1);
+        throw new CliExit(1);
     }
     const valueFlag = stringFlag(flags, 'value');
     const memoryId = args[0];
     if (!memoryId && valueFlag === undefined) {
         printError('Usage: hippo reject <memory-id> --reason "<why>"');
         printError('   or: hippo reject --value "<text>" --reason "<why>"');
-        process.exit(1);
+        throw new CliExit(1);
     }
     if (memoryId && valueFlag !== undefined) {
         // Ambiguous ask: silently preferring one form would ignore the other without feedback.
         printError('hippo reject takes EITHER a memory id OR --value, not both.');
-        process.exit(1);
+        throw new CliExit(1);
     }
     try {
-        const result = rejectValue({
-            hippoRoot: root,
-            tenantId,
-            actor: 'cli',
+        const result = api.rejectOnHost(cliApiContext(root, tenantId), {
             reason,
             memoryId: valueFlag === undefined ? memoryId : undefined,
             value: valueFlag,
@@ -244,12 +228,12 @@ export function cmdReject(hippoRoot, args, flags) {
     }
     catch (err) {
         printError(`Could not reject: ${errorMessage(err)}`);
-        process.exit(1);
+        throw new CliExit(1);
     }
 }
 function printRejected(result, reason) {
     const digestPrefix = result.digest.slice(0, DIGEST_DISPLAY_CHARS);
-    const preview = result.content.length > CONTENT_PREVIEW_CHARS ? `${result.content.slice(0, CONTENT_PREVIEW_CHARS)}...` : result.content;
+    const preview = truncateWithEllipsis(result.content, CONTENT_PREVIEW_CHARS);
     console.log(`Rejected [${digestPrefix}...]: "${preview}"`);
     console.log(`  Reason: ${reason}`);
     if (result.removedIds.length > 0) {
@@ -265,9 +249,8 @@ function printRejected(result, reason) {
         console.log('  No live rows matched (pre-emptive tombstone).');
     }
 }
-export function cmdRejections(hippoRoot, flags) {
+export function handleRejections({ hippoRoot, tenantId, flags }) {
     const root = resolveAuthRoot(hippoRoot, flags);
-    const tenantId = resolveTenantId({});
     const rows = listRejectionsForTenant(root, tenantId);
     if (flags['json']) {
         console.log(JSON.stringify({ rejections: rows }, null, 2));
@@ -290,41 +273,32 @@ export function cmdRejections(hippoRoot, flags) {
         console.log('');
     }
 }
-export function cmdUnreject(hippoRoot, args, flags) {
+export function handleUnreject({ hippoRoot, tenantId, args, flags }) {
     const root = resolveAuthRoot(hippoRoot, flags);
-    const tenantId = resolveTenantId({});
     const digestOrPrefix = (args[0] ?? '').trim();
     if (!digestOrPrefix) {
         printError('Usage: hippo unreject <digest-or-prefix>');
-        process.exit(1);
+        throw new CliExit(1);
     }
     const outcome = unrejectValue(root, tenantId, digestOrPrefix, 'cli');
     if (outcome.status === 'not_found') {
         printError(`No rejected value matches "${digestOrPrefix}". Run \`hippo rejections\` to list tombstones.`);
-        process.exit(1);
+        throw new CliExit(1);
     }
     if (outcome.status === 'ambiguous') {
         printError(`"${digestOrPrefix}" matches ${outcome.candidates.length} tombstones. Use a longer prefix:`);
         for (const c of outcome.candidates) {
             printError(`  ${c.digest.slice(0, REJECTED_DIGEST_LIST_CHARS)}...  ${c.reason ?? 'none given'}`);
         }
-        process.exit(1);
+        throw new CliExit(1);
     }
     console.log(`Unrejected [${outcome.digest.slice(0, DIGEST_DISPLAY_CHARS)}...] (was: ${outcome.reason ?? 'none given'})`);
 }
-/**
- * `hippo dormant [list] [<query>...] [--limit <n>] [--json] [--global]`,
- * `hippo dormant restore <id>`, `hippo dormant forget <id>`.
- * Dormant memories are what sleep keeps instead of deleting (on by default;
- * `"dormant": { "enabled": false }` in .hippo/config.json deletes instead).
- */
-export function cmdDormant(hippoRoot, args, flags) {
+/** `hippo dormant [list|restore <id>|forget <id>]`: dormant memories are what sleep keeps instead of deleting
+ * (on by default; `"dormant": { "enabled": false }` in .hippo/config.json deletes instead). */
+export function handleDormant({ hippoRoot, tenantId, args, flags }) {
     const root = resolveAuthRoot(hippoRoot, flags);
-    const ctx = {
-        hippoRoot: root,
-        tenantId: resolveTenantId({}),
-        actor: api.adminActor('cli'),
-    };
+    const ctx = cliApiContext(root, tenantId);
     const sub = args[0];
     if (sub === 'restore' || sub === 'forget') {
         changeDormant(ctx, sub, (args[1] ?? '').trim());
@@ -345,7 +319,7 @@ export function cmdDormant(hippoRoot, args, flags) {
 function changeDormant(ctx, sub, id) {
     if (!id) {
         printError(`Usage: hippo dormant ${sub} <id>`);
-        process.exit(1);
+        throw new CliExit(1);
     }
     try {
         if (sub === 'restore') {
@@ -364,7 +338,7 @@ function changeDormant(ctx, sub, id) {
         else {
             printError(`Could not ${sub} ${id}: ${errorMessage(err)}`);
         }
-        process.exit(1);
+        throw new CliExit(1);
     }
 }
 function printDormantRows(rows, hasQuery, root) {
@@ -377,22 +351,20 @@ function printDormantRows(rows, hasQuery, root) {
     }
     console.log(`${rows.length} dormant memor${rows.length === 1 ? 'y' : 'ies'}${hasQuery ? ' matching' : ''} (newest first):\n`);
     for (const row of rows) {
-        const preview = row.content.length > DORMANT_PREVIEW_CHARS ? `${row.content.slice(0, DORMANT_PREVIEW_CHARS)}...` : row.content;
+        const preview = truncateWithEllipsis(row.content, DORMANT_PREVIEW_CHARS);
         console.log(`--- ${row.id}`);
         console.log(`    ${preview}`);
-        console.log(`    Dormant since ${row.dormantAt.slice(0, DATE_PREFIX_CHARS)} (${row.reason}, strength ${row.strength.toFixed(STRENGTH_DECIMALS)})${row.tags.length > 0 ? `  tags: ${row.tags.join(', ')}` : ''}`);
+        console.log(`    Dormant since ${row.dormantAt.slice(0, DATE_PREFIX_CHARS)} ` +
+            `(${row.reason}, strength ${row.strength.toFixed(STRENGTH_DECIMALS)})` +
+            `${row.tags.length > 0 ? `  tags: ${row.tags.join(', ')}` : ''}`);
         console.log('');
     }
     console.log('Bring one back: hippo dormant restore <id>   Delete for good: hippo dormant forget <id>');
 }
 /** `hippo quarantine [list] [--all] [--json] [--global]`, `quarantine approve <id>`, `quarantine reject <id>` (poisoning defence). */
-export async function cmdQuarantine(hippoRoot, args, flags) {
+export async function handleQuarantine({ hippoRoot, tenantId, args, flags }) {
     const root = resolveAuthRoot(hippoRoot, flags);
-    const ctx = {
-        hippoRoot: root,
-        tenantId: resolveTenantId({}),
-        actor: api.adminActor('cli'),
-    };
+    const ctx = cliApiContext(root, tenantId);
     const sub = args[0];
     if (sub === 'approve' || sub === 'reject') {
         await decideQuarantined(ctx, sub, (args[1] ?? '').trim());
@@ -413,7 +385,7 @@ export async function cmdQuarantine(hippoRoot, args, flags) {
 async function decideQuarantined(ctx, sub, id) {
     if (!id) {
         printError(`Usage: hippo quarantine ${sub} <id>`);
-        process.exit(1);
+        throw new CliExit(1);
     }
     try {
         if (sub === 'approve') {
@@ -427,7 +399,7 @@ async function decideQuarantined(ctx, sub, id) {
     }
     catch (err) {
         printError(`Could not ${sub} ${id}: ${errorMessage(err)}`);
-        process.exit(1);
+        throw new CliExit(1);
     }
 }
 function printQuarantineRows(rows) {
@@ -440,11 +412,11 @@ function printQuarantineRows(rows) {
     }
     console.log('Approve: hippo quarantine approve <id>   Reject: hippo quarantine reject <id>');
 }
-export async function handleForget({ hippoRoot, args, flags }) {
+export async function handleForget({ hippoRoot, tenantId, args, flags }) {
     const id = args[0];
     if (!id) {
         printError('Please provide a memory ID.');
-        process.exit(1);
+        throw new CliExit(1);
     }
     // Archive has its own HTTP route (POST /v1/memories/:id/archive); route
     // both branches the same way the direct path does.
@@ -452,10 +424,10 @@ export async function handleForget({ hippoRoot, args, flags }) {
     const reason = stringFlag(flags, 'reason') ?? null;
     if (archive && !reason) {
         printError(ARCHIVE_REASON_REQUIRED);
-        process.exit(1);
+        throw new CliExit(1);
     }
     if (flagIsTrue(flags, 'dry-run')) {
-        previewForget(hippoRoot, id, archive);
+        await previewForget(hippoRoot, tenantId, id, archive);
         return;
     }
     const routed = await runViaServerIfAvailable(hippoRoot, async (info, apiKey) => {
@@ -472,30 +444,30 @@ export async function handleForget({ hippoRoot, args, flags }) {
         catch (err) {
             // A server that died after the health probe is the caller's transport
             // fallback to handle, not an error to report to the user.
-            if (client.classifyTransportFailure(err) !== 'none')
+            if (err instanceof Error && client.classifyTransportFailure(err) !== 'none')
                 throw err;
             const msg = errorMessage(err);
             printError(archive ? `Could not archive ${id}: ${msg}` : msg);
-            process.exit(1);
+            throw new CliExit(1);
         }
     });
     if (routed)
         return;
-    cmdForget(hippoRoot, id, flags);
+    cmdForget(hippoRoot, tenantId, id, flags);
 }
-function invalidateChurn(hippoRoot, args, flags) {
+function invalidateChurn(hippoRoot, tenantId, args, flags) {
     if (args[0] || flags['id'] !== undefined) {
         printError('Usage: hippo invalidate --churn [--dry-run]');
         printError('--churn takes no pattern or --id.');
-        process.exit(1);
+        throw new CliExit(1);
     }
     if (!isGitRepo(process.cwd())) {
         printError('hippo invalidate --churn must run inside a git repository.');
-        process.exit(1);
+        throw new CliExit(1);
     }
     const churnDryRun = flagIsTrue(flags, 'dry-run');
     let churnFailed = false;
-    for (const { root, result } of runChurnStaleForRepo(hippoRoot, churnDryRun)) {
+    for (const { root, result } of runChurnStaleForRepo(hippoRoot, tenantId, churnDryRun)) {
         if (result.error) {
             printError(`Churn-staleness check failed for ${root}: ${result.error}`);
             churnFailed = true;
@@ -516,18 +488,18 @@ function invalidateChurn(hippoRoot, args, flags) {
         }
     }
     if (churnFailed)
-        process.exit(1);
+        throw new CliExit(1);
 }
-export function handleInvalidate({ hippoRoot, args, flags }) {
+export function handleInvalidate({ hippoRoot, tenantId, args, flags }) {
     requireInit(hippoRoot);
     if (flagIsTrue(flags, 'churn'))
-        return invalidateChurn(hippoRoot, args, flags);
+        return invalidateChurn(hippoRoot, tenantId, args, flags);
     const target = args[0];
     if (flagIsTrue(flags, 'id')) {
         // Value-less --id must never silently fall through to pattern mode
         // (pattern mode writes broadly; an ignored --id reverses user intent).
         printError('--id requires a memory id');
-        process.exit(1);
+        throw new CliExit(1);
     }
     const onlyId = stringFlag(flags, 'id');
     const dryRun = flagIsTrue(flags, 'dry-run');
@@ -535,15 +507,15 @@ export function handleInvalidate({ hippoRoot, args, flags }) {
         printError('Usage: hippo invalidate "<old pattern>" [--dry-run] [--reason "<why>"]');
         printError('       hippo invalidate --id <memory-id> [--dry-run] [--reason "<why>"]');
         printError('Pass a pattern OR --id, not both. Tag matching is EXACT: the full pattern must equal a tag.');
-        process.exit(1);
+        throw new CliExit(1);
     }
-    const reason = (flags['reason'] || null);
+    const reason = nonEmptyStringFlag(flags, 'reason') ?? null;
     const invTarget = {
         from: target ?? `id:${onlyId}`,
         to: reason,
         type: 'migration',
     };
-    const result = invalidateMatching(hippoRoot, invTarget, resolveTenantId({}), { dryRun, onlyId });
+    const result = api.invalidateMemories(cliApiContext(hippoRoot, tenantId), invTarget, { dryRun, onlyId });
     const label = target ? `"${target}"` : `--id ${onlyId}`;
     if (result.dryRun) {
         if (result.invalidated === 0) {

package/dist/cli/dag.d.ts

@@ -1,5 +1,5 @@
-import { type CliFlags, type CommandContext } from './flag-values.js';
-export declare function cmdDag(hippoRoot: string, flags: CliFlags): void;
-export declare function handleDrill({ hippoRoot, args, flags }: CommandContext): Promise<void>;
-export declare function handleAssemble({ hippoRoot, args, flags }: CommandContext): Promise<void>;
+import { type CommandContext } from './flag-values.js';
+export declare function handleDag({ hippoRoot, tenantId, flags }: CommandContext): void;
+export declare function handleDrill({ hippoRoot, tenantId, args, flags }: CommandContext): Promise<void>;
+export declare function handleAssemble({ hippoRoot, tenantId, args, flags }: CommandContext): Promise<void>;
 //# sourceMappingURL=dag.d.ts.map