hippo-memory 1.72.0 → 2.1.0

package/dist/cli/install-steps.js

@@ -1,15 +1,19 @@
 // The init and setup steps that touch the machine: Codex hooks, the settings.json warning and the daily schedule.
 import * as path from 'path';
-import { execFileSync, execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 import { installJsonHooks } from '../hooks/json-hooks.js';
 import { CODEX_TRUST_LINE } from '../hooks/shared.js';
 import { envSkipSchedule } from '../util/env.js';
 import { DAILY_TASK_NAME, buildDailyRunnerCommand, hasUnsafeRunnerPathChars, buildSchtasksCreateArgs, buildWindowsTaskRun, quoteInsideWindowsArg, } from './scheduler.js';
-/** Adds hippo's two Codex hooks and says what changed; each install ends on the trust reminder, since Codex skips an untrusted hook. */
+/**
+ * Adds hippo's two Codex hooks and says what changed; each install ends on the trust reminder, since Codex skips an
+ * untrusted hook.
+ */
 export function installCodexMemoryHooks(indent) {
     const result = installJsonHooks('codex');
     if (result.invalidJson) {
-        console.log(`${indent}WARNING: ${result.settingsPath} is not a hooks file hippo can merge into; fix it, then run \`hippo hook install codex\`.`);
+        console.log(`${indent}WARNING: ${result.settingsPath} is not a hooks file hippo can merge into; fix it, then run \`hippo ` +
+            `hook install codex\`.`);
         return;
     }
     const added = [
@@ -21,7 +25,9 @@ export function installCodexMemoryHooks(indent) {
         : `${indent}hippo's Codex memory hooks already in ${result.settingsPath}`);
     console.log(`${indent}${CODEX_TRUST_LINE}`);
 }
-/** The one line init, hook install, hook uninstall and setup print when Claude Code's settings.json is not JSON hippo can edit and so was
+/**
+ * The one line init, hook install, hook uninstall and setup print when Claude Code's settings.json is not JSON hippo
+ * can edit and so was
  * left unchanged; true when it printed. */
 export function warnClaudeSettingsUnusable(result, indent, action = 'install') {
     if (!result.invalidJson)
@@ -30,17 +36,34 @@ export function warnClaudeSettingsUnusable(result, indent, action = 'install') {
         `fix it, then run \`hippo hook ${action} claude-code\`.`);
     return true;
 }
-/** Machine-level daily runner sweeping all registered workspaces: user crontab on Linux/macOS, a scheduled task on Windows; skips if installed. */
-/** Bound on each schtasks and crontab call, so a scheduler that never answers cannot hang `hippo init` or `hippo setup`. */
+/**
+ * Machine-level daily runner sweeping all registered workspaces: user crontab on Linux/macOS, a scheduled task on
+ * Windows; skips if installed.
+ */
+/**
+ * Bound on each schtasks and crontab call, so a scheduler that never answers cannot hang `hippo init` or `hippo setup`.
+ */
 const SCHEDULER_CALL_TIMEOUT_MS = 30_000;
-/** Node kills a child at its timeout and reports ETIMEDOUT; every other failure here means the scheduler refused or is missing. */
+// Piped stderr stands in for `2>nul` and `2>/dev/null`, so no shell is needed to keep the scheduler's complaints off
+// the terminal.
+const SCHEDULER_CALL = {
+    encoding: 'utf-8',
+    stdio: 'pipe',
+    windowsHide: true,
+    timeout: SCHEDULER_CALL_TIMEOUT_MS,
+};
+/**
+ * Node kills a child at its timeout and reports ETIMEDOUT; every other failure here means the scheduler refused or is
+ * missing.
+ */
 function schedulerTimedOut(err) {
     return err instanceof Error && 'code' in err && err.code === 'ETIMEDOUT';
 }
 function warnSchedulerTimedOut(command) {
-    console.log(`   ${command} did not answer within ${SCHEDULER_CALL_TIMEOUT_MS / 1000} s and was stopped, so the daily runner is not scheduled.`);
+    console.log(`   ${command} did not answer within ${SCHEDULER_CALL_TIMEOUT_MS / 1000} s and was stopped, so the daily runner ` +
+        `is not scheduled.`);
 }
-export function setupDailySchedule(globalRoot) {
+export function setupDailySchedule(globalRoot, run = execFileSync) {
     // Checked here, not per caller, so init, init --scan and setup all honour it.
     if (envSkipSchedule()) {
         console.log('   HIPPO_SKIP_SCHEDULE=1, so the machine-level daily runner was not scheduled.');
@@ -55,14 +78,14 @@ export function setupDailySchedule(globalRoot) {
     const taskName = DAILY_TASK_NAME;
     const cmd = buildDailyRunnerCommand(runnerDir);
     if (isWindows)
-        scheduleOnWindows(taskName, cmd);
+        scheduleOnWindows(taskName, cmd, run);
     else
-        scheduleOnCrontab(taskName, cmd);
+        scheduleOnCrontab(taskName, cmd, run);
 }
-function scheduleOnWindows(taskName, cmd) {
+function scheduleOnWindows(taskName, cmd, run) {
     // Check if task already exists
     try {
-        const existing = execSync(`schtasks /query /tn "${taskName}" 2>nul`, { encoding: 'utf-8', windowsHide: true, timeout: SCHEDULER_CALL_TIMEOUT_MS });
+        const existing = run('schtasks', ['/query', '/tn', taskName], SCHEDULER_CALL);
         if (existing.includes(taskName)) {
             return; // already scheduled
         }
@@ -73,7 +96,7 @@ function scheduleOnWindows(taskName, cmd) {
             warnSchedulerTimedOut('schtasks /query');
     }
     try {
-        execFileSync('schtasks', buildSchtasksCreateArgs(taskName, cmd), { stdio: 'pipe', windowsHide: true, timeout: SCHEDULER_CALL_TIMEOUT_MS });
+        run('schtasks', buildSchtasksCreateArgs(taskName, cmd), SCHEDULER_CALL);
         console.log(`   Scheduled machine-level daily runner (6:15am) via Task Scheduler: ${taskName}`);
     }
     catch (err) {
@@ -81,20 +104,21 @@ function scheduleOnWindows(taskName, cmd) {
             warnSchedulerTimedOut('schtasks /create');
         // No admin rights or schtasks unavailable, fall back to printing instructions
         console.log(`   To schedule the machine-level daily runner, run:`);
-        console.log(`   schtasks /create /tn "${taskName}" /tr "${quoteInsideWindowsArg(buildWindowsTaskRun(cmd))}" /sc daily /st 06:15`);
+        console.log(`   schtasks /create /tn "${taskName}" /tr "${quoteInsideWindowsArg(buildWindowsTaskRun(cmd))}" /sc daily /st ` +
+            `06:15`);
     }
 }
-function scheduleOnCrontab(taskName, cmd) {
+function scheduleOnCrontab(taskName, cmd, run) {
     // Unix: check crontab for existing entry
     const marker = `# hippo:${taskName}`;
     try {
-        const existing = execSync('crontab -l 2>/dev/null', { encoding: 'utf-8', windowsHide: true, timeout: SCHEDULER_CALL_TIMEOUT_MS });
+        const existing = run('crontab', ['-l'], SCHEDULER_CALL);
         if (existing.includes(marker)) {
             return; // already scheduled
         }
         const cronLine = `15 6 * * * ${cmd} ${marker}`;
         const newCrontab = existing.trimEnd() + '\n' + cronLine + '\n';
-        execSync('crontab -', { input: newCrontab, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true, timeout: SCHEDULER_CALL_TIMEOUT_MS });
+        run('crontab', ['-'], { ...SCHEDULER_CALL, input: newCrontab });
         console.log(`   Scheduled machine-level daily runner (6:15am) via crontab`);
     }
     catch (err) {

package/dist/cli/last-sleep.d.ts

@@ -1,5 +1,8 @@
 import { type CliFlags, type CommandContext } from './flag-values.js';
-/** The line the user sees when the last sleep failed, a spool step hit an unexpected error, or the spool holds `.bad` files; null when none did. */
+/**
+ * The line the user sees when the last sleep failed, a spool step hit an unexpected error, or the spool holds `.bad`
+ * files; null when none did.
+ */
 export declare function sleepProblems(logText: string, bad: number): string | null;
 /** Prints the SessionEnd sleep log on stderr, then clears it. In a hook, stdout carries only `systemMessage`,
  *  because Claude Code shows that to the user and adds any other SessionStart stdout to the model's context. */

package/dist/cli/last-sleep.js

@@ -4,19 +4,24 @@ import { isStringValue } from '../core/capture-contract.js';
 import { REPLAY_AFTER_MS } from '../core/compaction-timing.js';
 import { SPOOL_PROBLEM, spoolCounts } from '../capture/compaction-spool.js';
 import { defaultSleepLogPath } from '../hooks/shared.js';
-import { errorMessage, log } from '../util/log.js';
+import { errorMessage, log, errorFields } from '../util/log.js';
 import { truncateCodePointSafe } from '../util/transcript-tail.js';
 import { printError } from './output.js';
 import { hookStoreRoot } from './hook-runtime.js';
 const SLEEP_FAILED = '[hippo] sleep failed: ';
 const FAILURE_CHARS = 120;
-/** The line the user sees when the last sleep failed, a spool step hit an unexpected error, or the spool holds `.bad` files; null when none did. */
+/**
+ * The line the user sees when the last sleep failed, a spool step hit an unexpected error, or the spool holds `.bad`
+ * files; null when none did.
+ */
 export function sleepProblems(logText, bad) {
     const lines = logText.split(/\r?\n/);
     const failed = lines.find((line) => line.startsWith(SLEEP_FAILED));
     const errors = lines.filter((line) => line.includes(SPOOL_PROBLEM)).length;
     const parts = [
-        failed === undefined ? '' : `the last sleep failed (${truncateCodePointSafe(failed.slice(SLEEP_FAILED.length).trim(), FAILURE_CHARS)})`,
+        failed === undefined
+            ? ''
+            : `the last sleep failed (${truncateCodePointSafe(failed.slice(SLEEP_FAILED.length).trim(), FAILURE_CHARS)})`,
         errors === 0 ? '' : `${errors} error${errors === 1 ? '' : 's'} while saving waiting compaction summaries`,
         bad === 0 ? '' : `${bad} compaction ${bad === 1 ? 'summary' : 'summaries'} set aside as .bad`,
     ].filter((part) => part !== '');
@@ -63,7 +68,7 @@ export function cmdLastSleep(hippoRoot, flags, out = process.stdout.isTTY ? 'ter
             fs.unlinkSync(logPath);
         }
         catch (err) {
-            log.debug(`last-sleep log not removed, it shows again next session: ${errorMessage(err)}`);
+            log.debug(`last-sleep log not removed, it shows again next session: ${errorMessage(err)}`, errorFields(err));
         }
     }
 }

package/dist/cli/maintenance.d.ts

@@ -1,6 +1,6 @@
 import { type EmbeddingProvider } from '../embeddings/provider.js';
 import { type CommandContext } from './flag-values.js';
 export declare function handleRefine({ hippoRoot, tenantId, flags }: CommandContext): Promise<void>;
-export declare function handleDedup({ hippoRoot, tenantId, flags }: CommandContext): void;
+export declare function handleDedup({ hippoRoot, tenantId, flags }: CommandContext): Promise<void>;
 export declare function handleEmbed({ hippoRoot, tenantId, flags }: CommandContext, given?: EmbeddingProvider): Promise<void>;
 //# sourceMappingURL=maintenance.d.ts.map

package/dist/cli/maintenance.js

@@ -3,15 +3,15 @@ import { envAnthropicApiKey } from '../util/env.js';
 import { deduplicateStore } from '../consolidate/dedupe.js';
 import { resolveEmbeddingProvider } from '../embeddings/provider.js';
 import { embedCoverage, embedMissingMemories, resetPhysicsFromVectors, storedVectorCount } from '../api/embeddings.js';
-import { countAllMemories } from '../api/memories.js';
-import { cliApiContext } from './api-context.js';
+import { countAllMemories } from '../api/memories/memories.js';
+import { cliApiContext, cliLocalFiles } from './api-context.js';
 import { loadConfig } from '../core/config.js';
 import { refineStore } from './refine-llm.js';
 import { printError } from './output.js';
-import { boolFlag, numberFlag } from './flag-values.js';
+import { boolFlag, numberFlag, stringFlagOrExit } from './flag-values.js';
 import { requireInit, resolveAuthRoot } from './shared.js';
 import { errorMessage } from '../util/log.js';
-import { CliExit } from './exit.js';
+import { fail } from './exit.js';
 const MAX_FAILED_SHOWN = 5;
 const MAX_PAIRS_SHOWN = 15;
 const PAIR_PREVIEW_CHARS = 90;
@@ -19,13 +19,12 @@ export async function handleRefine({ hippoRoot, tenantId, flags }) {
     requireInit(hippoRoot);
     const apiKey = envAnthropicApiKey();
     if (!apiKey) {
-        printError('hippo refine needs ANTHROPIC_API_KEY in the environment.');
-        throw new CliExit(1);
+        fail('hippo refine needs ANTHROPIC_API_KEY in the environment.');
     }
     const dryRun = boolFlag(flags, 'dry-run');
     const all = boolFlag(flags, 'all');
     const limit = numberFlag(flags, 'limit');
-    const model = flags['model'] ? String(flags['model']) : undefined;
+    const model = stringFlagOrExit(flags, 'model') || undefined;
     const asJson = boolFlag(flags, 'json');
     const result = await refineStore(hippoRoot, {
         apiKey,
@@ -50,15 +49,15 @@ export async function handleRefine({ hippoRoot, tenantId, flags }) {
         }
     }
 }
-export function handleDedup({ hippoRoot, tenantId, flags }) {
+export async function handleDedup({ hippoRoot, tenantId, flags }) {
     requireInit(hippoRoot);
     const dryRun = boolFlag(flags, 'dry-run');
     if (flags['threshold'] !== undefined) {
         printError('hippo dedup: --threshold is ignored; a duplicate is the same text apart from spacing.');
     }
-    const total = countAllMemories(cliApiContext(hippoRoot, tenantId));
+    const total = await countAllMemories(cliApiContext(hippoRoot, tenantId));
     console.log(`Scanning ${total} memories for duplicates (same text apart from spacing)${dryRun ? ' (dry run)' : ''}...\n`);
-    const result = deduplicateStore(hippoRoot, { dryRun });
+    const result = deduplicateStore(cliLocalFiles(hippoRoot).consolidation, { dryRun });
     if (result.removed === 0) {
         console.log('No duplicates found.');
         return;
@@ -105,8 +104,8 @@ export async function handleEmbed({ hippoRoot, tenantId, flags }, given) {
     // so it heals pre-1.27.0 global stores from a directory with no local .hippo.
     const root = resolveAuthRoot(hippoRoot, flags);
     const ctx = cliApiContext(root, tenantId);
-    // --status and --reset-physics only read cached state, so they must work with no provider key (e.g. removed after an earlier embed);
-    // the provider-availability gate is deferred to the embed path.
+    // --status and --reset-physics only read cached state, so they must work with no provider key (e.g. removed after an
+    // earlier embed); the provider-availability gate is deferred to the embed path.
     if (flags['reset-physics']) {
         resetPhysics(ctx);
         return;

package/dist/cli/notes.d.ts

@@ -1,2 +1,2 @@
-export declare const handleCustomerNote: (ctx: import("./flag-values.js").CommandContext) => void;
+export declare const handleCustomerNote: (ctx: import("./flag-values.js").CommandContext) => Promise<void>;
 //# sourceMappingURL=notes.d.ts.map

package/dist/cli/notes.js

@@ -7,7 +7,7 @@ function printNoteRow(n) {
     if (n.changeSummary)
         console.log(`    change: ${n.changeSummary}`);
 }
-const noteKind = (hippoRoot, tenantId) => ({
+const noteKind = (objects, hippoRoot, tenantId) => ({
     names: { cmd: 'note', noun: 'Customer note', idLabel: 'note' },
     plural: 'customer notes',
     states: customerNotesModule.VALID_NOTE_STATES,
@@ -22,13 +22,16 @@ const noteKind = (hippoRoot, tenantId) => ({
     bodyRequired: '--text "<note>"',
     body: (flags) => requiredText(flags, 'text'),
     keyOf: (n) => n.customer,
-    save: (customer, note, extraTags, from) => customerNotesModule.saveCustomerNote(hippoRoot, tenantId, {
+    save: (customer, note, extraTags, from) => customerNotesModule.saveCustomerNote(objects, hippoRoot, tenantId, {
         customer, note, extraTags, changeSummary: from?.changeSummary, supersedesNoteId: from?.id,
     }),
     recorded: (n) => `Customer note recorded: #${n.id} (v${n.version}) for customer "${n.customer}"`,
-    list: (opts, flags) => customerNotesModule.loadCustomerNotes(hippoRoot, tenantId, { ...opts, customer: stringFlag(flags, 'customer')?.trim() || undefined }),
-    loadById: (id) => customerNotesModule.loadCustomerNoteById(hippoRoot, tenantId, id),
-    close: (id) => customerNotesModule.closeCustomerNote(hippoRoot, tenantId, id),
+    list: (opts, flags) => customerNotesModule.loadCustomerNotes(objects, tenantId, {
+        ...opts,
+        customer: stringFlag(flags, 'customer')?.trim() || undefined,
+    }),
+    loadById: (id) => customerNotesModule.loadCustomerNoteById(objects, tenantId, id),
+    close: (id) => customerNotesModule.closeCustomerNote(objects, tenantId, id),
     printRow: printNoteRow,
     printDetail: (n) => {
         console.log(`  customer: ${n.customer}`);

package/dist/cli/object-verbs.d.ts

@@ -9,12 +9,12 @@ export interface ObjectListSpec<O, S extends string> {
     readonly load: (opts: {
         status?: S;
         limit: number;
-    }) => readonly O[];
+    }) => Promise<readonly O[]>;
     readonly printRow: (o: O) => void;
 }
-export declare function listObjects<O, S extends string>(flags: CliFlags, spec: ObjectListSpec<O, S>): void;
+export declare function listObjects<O, S extends string>(flags: CliFlags, spec: ObjectListSpec<O, S>): Promise<void>;
 /** The `<id>` after the subcommand; prints `usage` and exits 1 when it is missing. */
-export declare function idArgOrExit(args: string[], usage: string, label: string, parseId?: (raw: string, label: string) => number): number;
+export declare function idArgOrExit(args: string[], usage: string, label: string): number;
 export declare function foundOrExit<O>(found: O | null | undefined, noun: string, id: number): O;
 /** How a kind is named in usage lines (`cmd`), in messages (`noun`) and in the invalid-id error (`idLabel`). */
 export interface ObjectNames {
@@ -23,9 +23,9 @@ export interface ObjectNames {
     readonly idLabel: string;
 }
 /** `hippo <cmd> close <id>` for a kind whose close call returns the closed row. */
-export declare function closeObject(args: string[], names: ObjectNames, close: (id: number) => {
+export declare function closeObject(args: string[], names: ObjectNames, close: (id: number) => Promise<{
     id: number;
-}, parseId?: (raw: string, label: string) => number): void;
+}>): Promise<void>;
 interface LifecycleTail {
     readonly changeSummary?: string | null;
     readonly supersededBy: number | null;

package/dist/cli/object-verbs.js

@@ -1,13 +1,12 @@
-// The status, list, id and not-found paths the typed-object verbs (process, policy, skill, brief, note, decide, incident, predict) share.
-import { printError } from './output.js';
+// The status, list, id and not-found paths the typed-object verbs (process, policy, skill, brief, note, decide,
+// incident, predict) share.
 import { parseListLimit, parsePositiveId, stringFlag } from './flag-values.js';
-import { CliExit } from './exit.js';
+import { fail } from './exit.js';
 /** The member of `states` named by `status`, or exit 1 with the message that lists every allowed value. */
 export function requireStatus(status, states) {
     const found = [...states].find((s) => s === status);
     if (found === undefined) {
-        printError(`Invalid --status: "${status}". Must be one of: ${[...states, 'all'].join(' | ')}.`);
-        throw new CliExit(1);
+        fail(`Invalid --status: "${status}". Must be one of: ${[...states, 'all'].join(' | ')}.`);
     }
     return found;
 }
@@ -16,10 +15,10 @@ export function statusFilter(flags, states) {
     const status = stringFlag(flags, 'status')?.trim() ?? 'all';
     return status === 'all' ? undefined : requireStatus(status, states);
 }
-export function listObjects(flags, spec) {
+export async function listObjects(flags, spec) {
     const limit = parseListLimit(flags);
     const status = statusFilter(flags, spec.states);
-    const results = spec.load(status === undefined ? { limit } : { status, limit });
+    const results = await spec.load(status === undefined ? { limit } : { status, limit });
     if (results.length === 0) {
         console.log(`No ${spec.plural}.`);
         return;
@@ -29,25 +28,23 @@ export function listObjects(flags, spec) {
         spec.printRow(o);
 }
 /** The `<id>` after the subcommand; prints `usage` and exits 1 when it is missing. */
-export function idArgOrExit(args, usage, label, parseId = parsePositiveId) {
+export function idArgOrExit(args, usage, label) {
     const idRaw = args[1];
     if (!idRaw) {
-        printError(usage);
-        throw new CliExit(1);
+        fail(usage);
     }
-    return parseId(idRaw, label);
+    return parsePositiveId(idRaw, label);
 }
 export function foundOrExit(found, noun, id) {
     if (!found) {
-        printError(`${noun} ${id} not found.`);
-        throw new CliExit(1);
+        fail(`${noun} ${id} not found.`);
     }
     return found;
 }
 /** `hippo <cmd> close <id>` for a kind whose close call returns the closed row. */
-export function closeObject(args, names, close, parseId = parsePositiveId) {
-    const id = idArgOrExit(args, `Usage: hippo ${names.cmd} close <id>`, names.idLabel, parseId);
-    console.log(`${names.noun} #${close(id).id} closed.`);
+export async function closeObject(args, names, close) {
+    const id = idArgOrExit(args, `Usage: hippo ${names.cmd} close <id>`, names.idLabel);
+    console.log(`${names.noun} #${(await close(id)).id} closed.`);
 }
 /** The detail lines every `get` ends with. */
 export function printLifecycleTail(o) {

package/dist/cli/open-browser.js

@@ -1,8 +1,17 @@
 // Best-effort browser launch for CLI verbs that write a file.
 import { spawn } from 'child_process';
-import { errorMessage, log } from '../util/log.js';
+import { errorMessage, log, errorFields } from '../util/log.js';
+// cmd.exe re-reads `start`'s argument as a command line, so one of these in the file name would end it and run the
+// rest.
+const CMD_METACHARS = /[&|<>^%!"\r\n]/;
 /** `launch` is the process starter; tests hand in a stand-in. */
 export function openInBrowser(out, launch = spawn) {
+    if (process.platform === 'win32' && CMD_METACHARS.test(out)) {
+        log.warn(`graph view: not opening ${out} in the browser, since cmd.exe would run part of its name as a command; open ` +
+            `the file by hand`);
+        process.exitCode = 1;
+        return;
+    }
     // Best-effort browser launch; never fail the command if it doesn't work.
     try {
         const [cmd, cmdArgs] = process.platform === 'win32'
@@ -20,7 +29,7 @@ export function openInBrowser(out, launch = spawn) {
     }
     catch (err) {
         // The file is written and its path printed above, so a browser that will not start costs nothing.
-        log.debug(`browser not opened: ${errorMessage(err)}`);
+        log.debug(`browser not opened: ${errorMessage(err)}`, errorFields(err));
     }
 }
 //# sourceMappingURL=open-browser.js.map

package/dist/cli/playbooks.d.ts

@@ -1,4 +1,4 @@
-export declare const handleProcess: (ctx: import("./flag-values.js").CommandContext) => void;
-export declare const handlePolicy: (ctx: import("./flag-values.js").CommandContext) => void;
-export declare const handleSkill: (ctx: import("./flag-values.js").CommandContext) => void;
+export declare const handleProcess: (ctx: import("./flag-values.js").CommandContext) => Promise<void>;
+export declare const handlePolicy: (ctx: import("./flag-values.js").CommandContext) => Promise<void>;
+export declare const handleSkill: (ctx: import("./flag-values.js").CommandContext) => Promise<void>;
 //# sourceMappingURL=playbooks.d.ts.map

package/dist/cli/playbooks.js

@@ -2,10 +2,9 @@
 import * as processesModule from '../objects/processes.js';
 import * as policiesModule from '../objects/policies.js';
 import * as skillsModule from '../objects/skills.js';
-import { printError } from './output.js';
 import { isStringFlag, nonEmptyStringFlag } from './flag-values.js';
 import { errorMessage } from '../util/log.js';
-import { CliExit } from './exit.js';
+import { fail } from './exit.js';
 import { requiredText, versionedVerbs } from './versioned-verbs.js';
 // --step is a repeatable flag (collected into an array by parseArgs). A single
 // --step yields a string; normalize both to string[]. A value-less --step errors.
@@ -15,8 +14,7 @@ function collectProcessSteps(stepRaw) {
     if (isStringFlag(stepRaw))
         return [stepRaw];
     if (stepRaw === true) {
-        printError('--step requires a value, e.g. hippo process new "<name>" --step "do X".');
-        throw new CliExit(1);
+        fail('--step requires a value, e.g. hippo process new "<name>" --step "do X".');
     }
     return [];
 }
@@ -26,7 +24,7 @@ function printProcessRow(proc) {
     if (proc.changeSummary)
         console.log(`    change: ${proc.changeSummary}`);
 }
-const processKind = (hippoRoot, tenantId) => ({
+const processKind = (objects, hippoRoot, tenantId) => ({
     names: { cmd: 'process', noun: 'Process', idLabel: 'process' },
     plural: 'processes',
     states: processesModule.VALID_PROCESS_STATES,
@@ -47,13 +45,17 @@ const processKind = (hippoRoot, tenantId) => ({
         return { steps, description: nonEmptyStringFlag(flags, 'description') };
     },
     keyOf: (proc) => proc.processName,
-    save: (processName, body, extraTags, from) => processesModule.saveProcess(hippoRoot, tenantId, {
-        processName, ...body, extraTags, changeSummary: from?.changeSummary, supersedesProcessId: from?.id,
+    save: (processName, body, extraTags, from) => processesModule.saveProcess(objects, hippoRoot, tenantId, {
+        processName,
+        ...body,
+        extraTags,
+        changeSummary: from?.changeSummary,
+        supersedesProcessId: from?.id,
     }),
     recorded: (proc) => `Process recorded: #${proc.id} (v${proc.version}, ${proc.steps.length} steps)`,
-    list: (opts) => processesModule.loadProcesses(hippoRoot, tenantId, opts),
-    loadById: (id) => processesModule.loadProcessById(hippoRoot, tenantId, id),
-    close: (id) => processesModule.closeProcess(hippoRoot, tenantId, id),
+    list: (opts) => processesModule.loadProcesses(objects, tenantId, opts),
+    loadById: (id) => processesModule.loadProcessById(objects, tenantId, id),
+    close: (id) => processesModule.closeProcess(objects, tenantId, id),
     printRow: printProcessRow,
     printDetail: (proc) => {
         console.log(`  name: ${proc.processName}`);
@@ -75,20 +77,18 @@ function printPolicyRow(p) {
     if (p.changeSummary)
         console.log(`    change: ${p.changeSummary}`);
 }
-function policyAsOf(hippoRoot, tenantId, args, flags) {
+async function policyAsOf(objects, tenantId, args, flags) {
     const dateRaw = args[1];
     if (!dateRaw) {
-        printError('Usage: hippo policy asof <iso-date> [--name "<policy>"]');
-        throw new CliExit(1);
+        fail('Usage: hippo policy asof <iso-date> [--name "<policy>"]');
     }
     const name = nonEmptyStringFlag(flags, 'name');
     let results;
     try {
-        results = policiesModule.loadPoliciesAsOf(hippoRoot, tenantId, dateRaw, { name });
+        results = await policiesModule.policiesAsOf(objects, tenantId, dateRaw, { name });
     }
     catch (e) {
-        printError(errorMessage(e));
-        throw new CliExit(1);
+        fail(errorMessage(e));
     }
     if (results.length === 0) {
         console.log(`No active policies in force at ${dateRaw}${name ? ` for "${name}"` : ''}.`);
@@ -98,7 +98,7 @@ function policyAsOf(hippoRoot, tenantId, args, flags) {
     for (const p of results)
         printPolicyRow(p);
 }
-const policyKind = (hippoRoot, tenantId) => ({
+const policyKind = (objects, hippoRoot, tenantId) => ({
     names: { cmd: 'policy', noun: 'Policy', idLabel: 'policy' },
     plural: 'policies',
     states: policiesModule.VALID_POLICY_STATES,
@@ -119,13 +119,17 @@ const policyKind = (hippoRoot, tenantId) => ({
         return { policyText, validFrom: nonEmptyStringFlag(flags, 'from'), validTo: nonEmptyStringFlag(flags, 'to') };
     },
     keyOf: (p) => p.policyName,
-    save: (policyName, body, extraTags, from) => policiesModule.savePolicy(hippoRoot, tenantId, {
-        policyName, ...body, extraTags, changeSummary: from?.changeSummary, supersedesPolicyId: from?.id,
+    save: (policyName, body, extraTags, from) => policiesModule.savePolicy(objects, hippoRoot, tenantId, {
+        policyName,
+        ...body,
+        extraTags,
+        changeSummary: from?.changeSummary,
+        supersedesPolicyId: from?.id,
     }),
     recorded: (p) => `Policy recorded: #${p.id} (v${p.version}, effective ${policyRange(p)})`,
-    list: (opts) => policiesModule.loadPolicies(hippoRoot, tenantId, opts),
-    loadById: (id) => policiesModule.loadPolicyById(hippoRoot, tenantId, id),
-    close: (id) => policiesModule.closePolicy(hippoRoot, tenantId, id),
+    list: (opts) => policiesModule.loadPolicies(objects, tenantId, opts),
+    loadById: (id) => policiesModule.loadPolicyById(objects, tenantId, id),
+    close: (id) => policiesModule.closePolicy(objects, tenantId, id),
     printRow: printPolicyRow,
     printDetail: (p) => {
         console.log(`  name: ${p.policyName}`);
@@ -135,7 +139,7 @@ const policyKind = (hippoRoot, tenantId) => ({
         console.log(`  valid_from: ${p.validFrom}`);
         console.log(`  valid_to: ${p.validTo ?? '(open-ended)'}`);
     },
-    extra: { sub: 'asof', run: (args, flags) => policyAsOf(hippoRoot, tenantId, args, flags) },
+    extra: { sub: 'asof', run: (args, flags) => policyAsOf(objects, tenantId, args, flags) },
 });
 export const handlePolicy = versionedVerbs(policyKind);
 function printSkillRow(s) {
@@ -145,15 +149,15 @@ function printSkillRow(s) {
     if (s.changeSummary)
         console.log(`    change: ${s.changeSummary}`);
 }
-function skillExport(hippoRoot, tenantId) {
-    const md = skillsModule.exportSkills(hippoRoot, tenantId);
+async function skillExport(objects, tenantId) {
+    const md = await skillsModule.skillsMarkdown(objects, tenantId);
     if (!md) {
         console.log('No active skills.');
         return;
     }
     console.log(md);
 }
-const skillKind = (hippoRoot, tenantId) => ({
+const skillKind = (objects, hippoRoot, tenantId) => ({
     names: { cmd: 'skill', noun: 'Skill', idLabel: 'skill' },
     plural: 'skills',
     states: skillsModule.VALID_SKILL_STATES,
@@ -174,13 +178,17 @@ const skillKind = (hippoRoot, tenantId) => ({
         return { instructions, trigger: nonEmptyStringFlag(flags, 'trigger') };
     },
     keyOf: (s) => s.skillName,
-    save: (skillName, body, extraTags, from) => skillsModule.saveSkill(hippoRoot, tenantId, {
-        skillName, ...body, extraTags, changeSummary: from?.changeSummary, supersedesSkillId: from?.id,
+    save: (skillName, body, extraTags, from) => skillsModule.saveSkill(objects, hippoRoot, tenantId, {
+        skillName,
+        ...body,
+        extraTags,
+        changeSummary: from?.changeSummary,
+        supersedesSkillId: from?.id,
     }),
     recorded: (s) => `Skill recorded: #${s.id} (v${s.version})`,
-    list: (opts) => skillsModule.loadSkills(hippoRoot, tenantId, opts),
-    loadById: (id) => skillsModule.loadSkillById(hippoRoot, tenantId, id),
-    close: (id) => skillsModule.closeSkill(hippoRoot, tenantId, id),
+    list: (opts) => skillsModule.loadSkills(objects, tenantId, opts),
+    loadById: (id) => skillsModule.loadSkillById(objects, tenantId, id),
+    close: (id) => skillsModule.closeSkill(objects, tenantId, id),
     printRow: printSkillRow,
     printDetail: (s) => {
         console.log(`  name: ${s.skillName}`);
@@ -190,7 +198,7 @@ const skillKind = (hippoRoot, tenantId) => ({
             console.log(`  when: ${s.trigger}`);
         console.log(`  instructions: ${s.instructions}`);
     },
-    extra: { sub: 'export', run: () => skillExport(hippoRoot, tenantId) },
+    extra: { sub: 'export', run: () => skillExport(objects, tenantId) },
 });
 export const handleSkill = versionedVerbs(skillKind);
 //# sourceMappingURL=playbooks.js.map