hippo-memory 2.0.0 → 2.1.0

package/dist/cli/curate.js

@@ -7,16 +7,16 @@ import { loadConfig } from '../core/config.js';
 import { RawAppendOnlyError } from '../core/raw-append-only.js';
 import { isGitRepo } from '../learn/autolearn.js';
 import * as api from '../api/index.js';
-import { getMemory } from '../api/memories.js';
+import { getMemory } from '../api/memories/memories.js';
 import * as client from './client.js';
 import { cliApiContext } from './api-context.js';
 import { printError } from './output.js';
-import { parseCountFlag, boolFlag, flagIsTrue, nonEmptyStringFlag, stringFlag } from './flag-values.js';
+import { parseCountFlag, boolFlag, flagIsTrue, nonEmptyStringFlag, stringFlag, stringFlagOrExit, } 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';
+import { CliExit, fail } from './exit.js';
 const CONFLICT_PREVIEW_CHARS = 120;
 const REJECTED_DIGEST_LIST_CHARS = 16;
 const DORMANT_PREVIEW_CHARS = 100;
@@ -26,12 +26,11 @@ export async function handleOutcome({ hippoRoot, tenantId, flags }) {
     const good = boolFlag(flags, 'good');
     const bad = boolFlag(flags, 'bad');
     if (!good && !bad) {
-        printError('Specify --good or --bad');
-        throw new CliExit(1);
+        fail('Specify --good or --bad');
     }
     // Through api.outcome so every CLI outcome writes one audit_log row per id, as the MCP path does.
     const ctx = cliApiContext(hippoRoot, tenantId);
-    const specificId = flags['id'] ? String(flags['id']) : null;
+    const specificId = stringFlagOrExit(flags, 'id') || null;
     let updated;
     if (specificId) {
         updated = (await api.outcome(ctx, [specificId], good)).applied;
@@ -62,31 +61,29 @@ async function cmdForget(hippoRoot, tenantId, id, flags) {
         console.log(`Forgot ${id}`);
     }
     catch (err) {
-        reportForgetFailure(ctx, id, err);
+        await reportForgetFailure(ctx, id, err);
         throw new CliExit(1);
     }
 }
 async function archiveForgottenRaw(ctx, id, reason) {
     if (!reason) {
-        printError(ARCHIVE_REASON_REQUIRED);
-        throw new CliExit(1);
+        fail(ARCHIVE_REASON_REQUIRED);
     }
     try {
         await api.archiveRaw(ctx, id, reason);
         console.log(`Archived ${id}`);
     }
     catch (err) {
-        printError(`Could not archive ${id}: ${errorMessage(err)}`);
-        throw new CliExit(1);
+        fail(`Could not archive ${id}: ${errorMessage(err)}`);
     }
 }
-function reportForgetFailure(ctx, id, cause) {
+async 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));
     }
-    else if (api.isDormant(ctx, id)) {
+    else if (await api.isDormant(ctx, id)) {
         // Sleep moved it to the dormant store: it is not in active memory, so
         // point at the command that owns it.
         printError(`${id} is dormant, not in active memory. Delete it for good: hippo dormant forget ${id} ` +
@@ -104,23 +101,21 @@ async function previewForget(hippoRoot, tenantId, id, archive) {
     requireInit(hippoRoot);
     const entry = await getMemory(cliApiContext(hippoRoot, tenantId), id);
     if (!entry) {
-        printError(`Memory not found: ${id}`);
-        throw new CliExit(1);
+        fail(`Memory not found: ${id}`);
     }
     if (!archive && entry.kind === 'raw') {
-        printError(rawForgetRefusal(id));
-        throw new CliExit(1);
+        fail(rawForgetRefusal(id));
     }
     if (archive && entry.kind !== 'raw') {
-        printError(`Could not archive ${id}: memory ${id} is not raw (kind=${entry.kind})`);
-        throw new CliExit(1);
+        fail(`Could not archive ${id}: memory ${id} is not raw (kind=${entry.kind})`);
     }
     const snippet = truncateWithEllipsis(entry.content, CONTENT_PREVIEW_CHARS);
     console.log(`Would ${archive ? 'archive' : 'forget'} ${id} (dry run, nothing changed): "${snippet}"`);
 }
-export function handleConflicts({ hippoRoot, tenantId, flags }) {
+export async function handleConflicts({ hippoRoot, tenantId, flags }) {
     requireInit(hippoRoot);
-    const conflicts = api.listConflicts(cliApiContext(hippoRoot, tenantId), String(flags['status'] ?? 'open'), { everyTenant: true });
+    const status = stringFlagOrExit(flags, 'status') ?? 'open';
+    const conflicts = await api.listConflicts(cliApiContext(hippoRoot, tenantId), status, { everyTenant: true });
     if (flags['json']) {
         console.log(JSON.stringify({ conflicts }, null, 2));
         return;
@@ -139,11 +134,10 @@ export function handleConflicts({ hippoRoot, tenantId, flags }) {
 }
 /** Shown when --keep is missing, to help the user decide. */
 async function showConflictForResolve(hippoRoot, conflictId, tenantId) {
-    const conflicts = api.listConflicts(cliApiContext(hippoRoot, tenantId), 'open');
+    const conflicts = await api.listConflicts(cliApiContext(hippoRoot, tenantId), 'open');
     const conflict = conflicts.find((c) => c.id === conflictId);
     if (!conflict) {
-        printError(`Conflict ${conflictId} not found or already resolved.`);
-        throw new CliExit(1);
+        fail(`Conflict ${conflictId} not found or already resolved.`);
     }
     console.log(`Conflict ${conflictId}:`);
     console.log(`  ${conflict.memory_a_id} <-> ${conflict.memory_b_id}`);
@@ -169,10 +163,9 @@ export async function handleResolve({ hippoRoot, tenantId, args, flags }) {
     // 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]');
-        throw new CliExit(1);
+        fail('Usage: hippo resolve <conflict_id> --keep <memory_id> [--forget]');
     }
-    const keepId = String(flags['keep'] ?? '').trim();
+    const keepId = stringFlagOrExit(flags, 'keep') ?? '';
     if (!keepId) {
         await showConflictForResolve(hippoRoot, conflictId, tenantId);
         return;
@@ -182,7 +175,7 @@ export async function handleResolve({ hippoRoot, tenantId, 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 = api.resolveMemoryConflict(cliApiContext(hippoRoot, tenantId), conflictId, {
+    const result = await api.resolveMemoryConflict(cliApiContext(hippoRoot, tenantId), conflictId, {
         keepId,
         forget: forgetLoser,
         rejectLoser,
@@ -203,20 +196,17 @@ export function handleReject({ hippoRoot, tenantId, args, flags }) {
     // --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).');
-        throw new CliExit(1);
+        fail('hippo reject requires --reason "<why>" (the tombstone stores no content; reason is its only identity).');
     }
     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>"');
-        throw new CliExit(1);
+        fail('   or: hippo reject --value "<text>" --reason "<why>"');
     }
     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.');
-        throw new CliExit(1);
+        fail('hippo reject takes EITHER a memory id OR --value, not both.');
     }
     try {
         const result = api.rejectOnHost(cliApiContext(root, tenantId), {
@@ -227,8 +217,7 @@ export function handleReject({ hippoRoot, tenantId, args, flags }) {
         printRejected(result, reason);
     }
     catch (err) {
-        printError(`Could not reject: ${errorMessage(err)}`);
-        throw new CliExit(1);
+        fail(`Could not reject: ${errorMessage(err)}`);
     }
 }
 function printRejected(result, reason) {
@@ -277,13 +266,11 @@ export function handleUnreject({ hippoRoot, tenantId, args, flags }) {
     const root = resolveAuthRoot(hippoRoot, flags);
     const digestOrPrefix = (args[0] ?? '').trim();
     if (!digestOrPrefix) {
-        printError('Usage: hippo unreject <digest-or-prefix>');
-        throw new CliExit(1);
+        fail('Usage: hippo unreject <digest-or-prefix>');
     }
     const outcome = unrejectValue(root, tenantId, digestOrPrefix, 'cli');
     if (outcome.status === 'not_found') {
-        printError(`No rejected value matches "${digestOrPrefix}". Run \`hippo rejections\` to list tombstones.`);
-        throw new CliExit(1);
+        fail(`No rejected value matches "${digestOrPrefix}". Run \`hippo rejections\` to list tombstones.`);
     }
     if (outcome.status === 'ambiguous') {
         printError(`"${digestOrPrefix}" matches ${outcome.candidates.length} tombstones. Use a longer prefix:`);
@@ -296,17 +283,17 @@ export function handleUnreject({ hippoRoot, tenantId, 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 }) {
+export async function handleDormant({ hippoRoot, tenantId, args, flags }) {
     const root = resolveAuthRoot(hippoRoot, flags);
     const ctx = cliApiContext(root, tenantId);
     const sub = args[0];
     if (sub === 'restore' || sub === 'forget') {
-        changeDormant(ctx, sub, (args[1] ?? '').trim());
+        await changeDormant(ctx, sub, (args[1] ?? '').trim());
         return;
     }
     const queryArgs = sub === 'list' ? args.slice(1) : args;
     const limit = parseCountFlag(flags['limit']);
-    const rows = api.listDormant(ctx, {
+    const rows = await api.listDormant(ctx, {
         query: queryArgs.join(' '),
         limit: limit > 0 ? limit : undefined,
     });
@@ -316,18 +303,17 @@ export function handleDormant({ hippoRoot, tenantId, args, flags }) {
     }
     printDormantRows(rows, queryArgs.length > 0, root);
 }
-function changeDormant(ctx, sub, id) {
+async function changeDormant(ctx, sub, id) {
     if (!id) {
-        printError(`Usage: hippo dormant ${sub} <id>`);
-        throw new CliExit(1);
+        fail(`Usage: hippo dormant ${sub} <id>`);
     }
     try {
         if (sub === 'restore') {
-            api.restoreDormant(ctx, id);
+            await api.restoreDormant(ctx, id);
             console.log(`Restored ${id} to active memory.`);
         }
         else {
-            api.forgetDormant(ctx, id);
+            await api.forgetDormant(ctx, id);
             console.log(`Forgot dormant memory ${id} permanently.`);
         }
     }
@@ -361,7 +347,8 @@ function printDormantRows(rows, hasQuery, root) {
     }
     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). */
+/** `hippo quarantine [list] [--all] [--json] [--global]`,
+ * `quarantine approve <id>`, `quarantine reject <id>` (poisoning defence). */
 export async function handleQuarantine({ hippoRoot, tenantId, args, flags }) {
     const root = resolveAuthRoot(hippoRoot, flags);
     const ctx = cliApiContext(root, tenantId);
@@ -384,8 +371,7 @@ export async function handleQuarantine({ hippoRoot, tenantId, args, flags }) {
 }
 async function decideQuarantined(ctx, sub, id) {
     if (!id) {
-        printError(`Usage: hippo quarantine ${sub} <id>`);
-        throw new CliExit(1);
+        fail(`Usage: hippo quarantine ${sub} <id>`);
     }
     try {
         if (sub === 'approve') {
@@ -398,8 +384,7 @@ async function decideQuarantined(ctx, sub, id) {
         }
     }
     catch (err) {
-        printError(`Could not ${sub} ${id}: ${errorMessage(err)}`);
-        throw new CliExit(1);
+        fail(`Could not ${sub} ${id}: ${errorMessage(err)}`);
     }
 }
 function printQuarantineRows(rows) {
@@ -415,16 +400,14 @@ function printQuarantineRows(rows) {
 export async function handleForget({ hippoRoot, tenantId, args, flags }) {
     const id = args[0];
     if (!id) {
-        printError('Please provide a memory ID.');
-        throw new CliExit(1);
+        fail('Please provide a memory ID.');
     }
     // Archive has its own HTTP route (POST /v1/memories/:id/archive); route
     // both branches the same way the direct path does.
     const archive = flagIsTrue(flags, 'archive');
     const reason = stringFlag(flags, 'reason') ?? null;
     if (archive && !reason) {
-        printError(ARCHIVE_REASON_REQUIRED);
-        throw new CliExit(1);
+        fail(ARCHIVE_REASON_REQUIRED);
     }
     if (flagIsTrue(flags, 'dry-run')) {
         await previewForget(hippoRoot, tenantId, id, archive);
@@ -447,8 +430,7 @@ export async function handleForget({ hippoRoot, tenantId, args, flags }) {
             if (err instanceof Error && client.classifyTransportFailure(err) !== 'none')
                 throw err;
             const msg = errorMessage(err);
-            printError(archive ? `Could not archive ${id}: ${msg}` : msg);
-            throw new CliExit(1);
+            fail(archive ? `Could not archive ${id}: ${msg}` : msg);
         }
     });
     if (routed)
@@ -458,12 +440,10 @@ export async function handleForget({ hippoRoot, tenantId, 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.');
-        throw new CliExit(1);
+        fail('--churn takes no pattern or --id.');
     }
     if (!isGitRepo(process.cwd())) {
-        printError('hippo invalidate --churn must run inside a git repository.');
-        throw new CliExit(1);
+        fail('hippo invalidate --churn must run inside a git repository.');
     }
     const churnDryRun = flagIsTrue(flags, 'dry-run');
     let churnFailed = false;
@@ -482,7 +462,7 @@ function invalidateChurn(hippoRoot, tenantId, args, flags) {
         else {
             console.log(`Tagged ${result.marked} memories churn-stale in ${root} (${result.alreadyMarked} already tagged):`);
         }
-        result.preview.forEach(p => console.log(`   ${p.id}  ${p.evidence}  ${p.already ? '(already) ' : ''}${p.headline}`));
+        result.preview.forEach((p) => console.log(`   ${p.id}  ${p.evidence}  ${p.already ? '(already) ' : ''}${p.headline}`));
         if (result.skippedPinned.length > 0) {
             console.log(`Skipped ${result.skippedPinned.length} pinned: ${result.skippedPinned.join(', ')}`);
         }
@@ -498,16 +478,14 @@ export function handleInvalidate({ hippoRoot, tenantId, args, flags }) {
     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');
-        throw new CliExit(1);
+        fail('--id requires a memory id');
     }
     const onlyId = stringFlag(flags, 'id');
     const dryRun = flagIsTrue(flags, 'dry-run');
     if ((target && onlyId) || (!target && !onlyId)) {
         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.');
-        throw new CliExit(1);
+        fail('Pass a pattern OR --id, not both. Tag matching is EXACT: the full pattern must equal a tag.');
     }
     const reason = nonEmptyStringFlag(flags, 'reason') ?? null;
     const invTarget = {

package/dist/cli/dag.d.ts

@@ -1,5 +1,5 @@
 import { type CommandContext } from './flag-values.js';
-export declare function handleDag({ hippoRoot, tenantId, flags }: CommandContext): void;
+export declare function handleDag({ hippoRoot, tenantId, flags }: CommandContext): Promise<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

package/dist/cli/dag.js

@@ -1,30 +1,31 @@
 // DAG summary verbs: `hippo dag`, `hippo assemble` and `hippo drill`.
 import { truncateWithEllipsis } from '../util/ellipsize.js';
+import { DAG_LEVEL } from '../core/memory.js';
 import * as api from '../api/index.js';
 import { assembleCost, assembleHeading, drillCost, settleTokens } from '../api/context-render.js';
-import { listMemories } from '../api/memories.js';
+import { listMemories } from '../api/memories/memories.js';
 import { cliApiContext } from './api-context.js';
 import { printError } from './output.js';
-import { parseBudgetFlag, flagIsTrue, stringFlag, numberFlag } from './flag-values.js';
+import { parseBudgetFlag, flagIsTrue, stringFlag, numberFlag, } from './flag-values.js';
 import { requireInit } from './shared.js';
 import { captureConsole } from './print.js';
 import { CONTENT_PREVIEW_CHARS } from '../util/token-text.js';
-import { CliExit } from './exit.js';
+import { CliExit, fail } from './exit.js';
 const TREE_CHILD_PREVIEW_CHARS = 70;
 const TREE_LEAF_PREVIEW_CHARS = 60;
 const DAG_HEAD_CHARS = 120;
 const DAG_SUMMARY_PREVIEW_CHARS = 200;
 const DAG_CHILD_PREVIEW_CHARS = 100;
-export function handleDag({ hippoRoot, tenantId, flags }) {
+export async function handleDag({ hippoRoot, tenantId, flags }) {
     requireInit(hippoRoot);
-    const entries = listMemories(cliApiContext(hippoRoot, tenantId), { everyTenant: true });
+    const entries = await listMemories(cliApiContext(hippoRoot, tenantId), { everyTenant: true });
     const isStats = flagIsTrue(flags, 'stats');
     const byLevel = new Map();
     let unlinked = 0;
     for (const entry of entries) {
         const level = entry.dag_level ?? 0;
         byLevel.set(level, (byLevel.get(level) ?? 0) + 1);
-        if (level === 1 && !entry.dag_parent_id)
+        if (level === DAG_LEVEL.extracted && !entry.dag_parent_id)
             unlinked++;
     }
     if (isStats) {
@@ -54,8 +55,8 @@ function groupByParent(entries) {
 }
 function printDagTree(entries) {
     // Tree view: L3 entity profiles as roots with L2 children indented, then orphan L2 summaries at top level.
-    const profiles = entries.filter((e) => e.dag_level === 3);
-    const l2List = entries.filter((e) => e.dag_level === 2);
+    const profiles = entries.filter((e) => e.dag_level === DAG_LEVEL.entity);
+    const l2List = entries.filter((e) => e.dag_level === DAG_LEVEL.topic);
     const orphanL2 = l2List.filter((e) => !e.dag_parent_id);
     const childL2ByProfile = new Map();
     for (const l2 of l2List) {
@@ -108,8 +109,7 @@ async function cmdAssemble(hippoRoot, tenantId, sessionId, flags) {
     const summarizeOlder = flags['no-summarize-older'] !== true;
     const scope = stringFlag(flags, 'scope') || undefined;
     const ctx = {
-        hippoRoot,
-        tenantId,
+        ...cliApiContext(hippoRoot, tenantId),
         actor: api.adminActor('cli:assemble'),
     };
     const opts = {};
@@ -145,14 +145,13 @@ async function cmdDrillDown(hippoRoot, tenantId, summaryId, flags) {
     let depth;
     if (rawDepth !== undefined) {
         if (!Number.isInteger(rawDepth) || rawDepth < 1 || rawDepth > 10) {
-            printError(`--depth must be an integer between 1 and 10 (got ${flags['depth']})`);
+            printError(`--depth must be an integer between 1 and 10 (got ${stringFlag(flags, 'depth')})`);
             throw new CliExit(2);
         }
         depth = rawDepth;
     }
     const ctx = {
-        hippoRoot,
-        tenantId,
+        ...cliApiContext(hippoRoot, tenantId),
         actor: api.adminActor('cli:drill'),
     };
     const opts = {};
@@ -190,16 +189,14 @@ async function cmdDrillDown(hippoRoot, tenantId, summaryId, flags) {
 export async function handleDrill({ hippoRoot, tenantId, args, flags }) {
     const summaryId = args[0];
     if (!summaryId) {
-        printError('Usage: hippo drill <summary-id> [--limit N] [--budget N]');
-        throw new CliExit(1);
+        fail('Usage: hippo drill <summary-id> [--limit N] [--budget N]');
     }
     await cmdDrillDown(hippoRoot, tenantId, summaryId, flags);
 }
 export async function handleAssemble({ hippoRoot, tenantId, args, flags }) {
     const sessionId = stringFlag(flags, 'session') ?? args[0];
     if (!sessionId) {
-        printError('Usage: hippo assemble --session <id> [--budget N] [--fresh-tail N] [--no-summarize-older] [--json]');
-        throw new CliExit(1);
+        fail('Usage: hippo assemble --session <id> [--budget N] [--fresh-tail N] [--no-summarize-older] [--json]');
     }
     await cmdAssemble(hippoRoot, tenantId, sessionId, flags);
 }

package/dist/cli/decisions.js

@@ -1,14 +1,15 @@
 // First-class object verbs for decisions: record one (optionally superseding an older one's memory), list, get, close.
-import { getMemory } from '../api/memories.js';
+import { getMemory } from '../api/memories/memories.js';
+import { objectsOf } from '../api/objects/objects.js';
 import { extractPathTags } from '../search/path-context.js';
 import * as decisionsModule from '../objects/decisions.js';
 import { printError } from './output.js';
 import { nonEmptyStringFlag, flagIsTrue, stringFlag } from './flag-values.js';
 import { requireInit } from './shared.js';
 import { cliApiContext } from './api-context.js';
-import { closeObject, foundOrExit, idArgOrExit, listObjects, printLifecycleTail } from './object-verbs.js';
+import { closeObject, foundOrExit, idArgOrExit, listObjects, printLifecycleTail, } from './object-verbs.js';
 import { errorMessage } from '../util/log.js';
-import { CliExit } from './exit.js';
+import { fail } from './exit.js';
 const DECISION = { cmd: 'decide', noun: 'Decision', idLabel: 'decision' };
 function printDecisionRow(d) {
     const supPart = d.supersededBy !== null ? ` superseded_by=#${d.supersededBy}` : '';
@@ -17,17 +18,17 @@ function printDecisionRow(d) {
     if (d.context)
         console.log(`    context: ${d.context}`);
 }
-function decideList(hippoRoot, tenantId, flags) {
-    listObjects(flags, {
+function decideList(objects, tenantId, flags) {
+    return listObjects(flags, {
         plural: 'decisions',
         states: decisionsModule.VALID_DECISION_STATES,
-        load: (opts) => decisionsModule.loadDecisions(hippoRoot, tenantId, opts),
+        load: (opts) => decisionsModule.loadDecisions(objects, tenantId, opts),
         printRow: printDecisionRow,
     });
 }
-function decideGet(hippoRoot, tenantId, args) {
+async function decideGet(objects, tenantId, args) {
     const id = idArgOrExit(args, 'Usage: hippo decide get <id>', DECISION.idLabel);
-    const decision = foundOrExit(decisionsModule.loadDecisionById(hippoRoot, tenantId, id), DECISION.noun, id);
+    const decision = foundOrExit(await decisionsModule.loadDecisionById(objects, tenantId, id), DECISION.noun, id);
     console.log(`Decision #${decision.id}`);
     console.log(`  status: ${decision.status}`);
     console.log(`  text: ${decision.decisionText}`);
@@ -35,47 +36,48 @@ function decideGet(hippoRoot, tenantId, args) {
         console.log(`  context: ${decision.context}`);
     printLifecycleTail(decision);
 }
-function decideClose(hippoRoot, tenantId, args) {
-    closeObject(args, DECISION, (id) => decisionsModule.closeDecision(hippoRoot, tenantId, id));
+function decideClose(objects, tenantId, args) {
+    return closeObject(args, DECISION, (id) => decisionsModule.closeDecision(objects, tenantId, id));
 }
 export async function handleDecide({ hippoRoot, tenantId, args, flags }) {
     requireInit(hippoRoot);
     const subcommand = args[0] ?? '';
+    const ctx = cliApiContext(hippoRoot, tenantId);
+    const objects = objectsOf(ctx);
     if (subcommand === 'list')
-        return decideList(hippoRoot, tenantId, flags);
+        return decideList(objects, tenantId, flags);
     if (subcommand === 'get')
-        return decideGet(hippoRoot, tenantId, args);
+        return decideGet(objects, tenantId, args);
     if (subcommand === 'close')
-        return decideClose(hippoRoot, tenantId, args);
+        return decideClose(objects, tenantId, args);
     // Default subcommand: create. args[0] is the decision text.
-    await decideCreate(hippoRoot, tenantId, subcommand, flags);
+    await decideCreate(ctx, subcommand, flags);
 }
-async function decideCreate(hippoRoot, tenantId, decisionText, flags) {
+async function decideCreate(ctx, decisionText, flags) {
+    const { hippoRoot, tenantId } = ctx;
     if (!decisionText)
         exitWithDecideUsage();
     const context = nonEmptyStringFlag(flags, 'context');
     // A value-less `--supersedes` asks to supersede but gives no memory id: reject it rather
     // than silently creating a non-superseding decision.
     if (flagIsTrue(flags, 'supersedes')) {
-        printError('--supersedes requires a memory id, e.g. hippo decide "<text>" --supersedes mem_abc123.');
-        throw new CliExit(1);
+        fail('--supersedes requires a memory id, e.g. hippo decide "<text>" --supersedes mem_abc123.');
     }
     const supersedesMemId = stringFlag(flags, 'supersedes') ?? null;
-    // Commit the table create+supersede first (inside saveDecision's SAVEPOINT) and weaken the old memory last, best-effort,
-    // so a memory-write failure cannot leave the memory stale while the table shows the supersession.
+    // Commit the table create+supersede first (inside saveDecision's SAVEPOINT) and weaken the old memory last,
+    // best-effort, so a memory-write failure cannot leave the memory stale while the table shows the supersession.
     let supersedesDecisionId;
     let oldEntry = null;
     if (supersedesMemId) {
-        oldEntry = await getMemory(cliApiContext(hippoRoot, tenantId), supersedesMemId);
+        oldEntry = await getMemory(ctx, supersedesMemId);
         if (!oldEntry) {
-            printError(`Memory ${supersedesMemId} not found.`);
-            throw new CliExit(1);
+            fail(`Memory ${supersedesMemId} not found.`);
         }
         supersedesDecisionId =
-            decisionsModule.resolveActiveDecisionIdByMemory(hippoRoot, tenantId, supersedesMemId) ?? undefined;
+            (await decisionsModule.resolveActiveDecisionIdByMemory(objectsOf(ctx), tenantId, supersedesMemId)) ?? undefined;
     }
     const decisionPathTags = extractPathTags(process.cwd());
-    const created = decisionsModule.saveDecision(hippoRoot, tenantId, {
+    const created = await decisionsModule.saveDecision(objectsOf(ctx), hippoRoot, tenantId, {
         decisionText,
         context,
         supersedesDecisionId,
@@ -93,8 +95,7 @@ function exitWithDecideUsage() {
     printError('Usage: hippo decide "<decision>" [--context "<why>"] [--supersedes <memory-id>]');
     printError('       hippo decide list [--status active|superseded|closed|all] [--limit N]');
     printError('       hippo decide get <id>');
-    printError('       hippo decide close <id>');
-    throw new CliExit(1);
+    fail('       hippo decide close <id>');
 }
 function weakenOrWarn(hippoRoot, oldEntry, supersedesMemId) {
     // Best-effort and last: saveDecision already committed. Failing here would make a retry find no active