hippo-memory 2.0.0 → 2.1.0

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,10 +9,10 @@ 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): number;
 export declare function foundOrExit<O>(found: O | null | undefined, noun: string, id: number): O;
@@ -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;
-}): 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;
@@ -32,22 +31,20 @@ export function listObjects(flags, spec) {
 export function idArgOrExit(args, usage, label) {
     const idRaw = args[1];
     if (!idRaw) {
-        printError(usage);
-        throw new CliExit(1);
+        fail(usage);
     }
     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) {
+export async function closeObject(args, names, close) {
     const id = idArgOrExit(args, `Usage: hippo ${names.cmd} close <id>`, names.idLabel);
-    console.log(`${names.noun} #${close(id).id} closed.`);
+    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

package/dist/cli/predictions.js

@@ -1,12 +1,12 @@
 // First-class object verbs for predictions: record a claim, close it against the actual, and read the class base rate.
-import * as predictionsApi from '../api/predictions.js';
+import * as predictionsApi from '../api/objects/predictions.js';
 import { VALID_CLOSURE_STATES } from '../core/prediction.js';
 import { cliApiContext } from './api-context.js';
 import { printError } from './output.js';
 import { parseListLimit, stringFlag } from './flag-values.js';
 import { requireInit } from './shared.js';
 import { foundOrExit, idArgOrExit, requireStatus } from './object-verbs.js';
-import { CliExit } from './exit.js';
+import { fail } from './exit.js';
 const BASERATE_DECIMALS = 3;
 const PREDICTION_NOUN = 'Prediction';
 async function predictClose(ctx, args, flags) {
@@ -14,14 +14,12 @@ async function predictClose(ctx, args, flags) {
     const stateRaw = (stringFlag(flags, 'state') ?? '').trim();
     // SAFETY: Set.has only compares by value, so a string outside the closure states is a plain miss.
     if (!VALID_CLOSURE_STATES.has(stateRaw) || stateRaw === 'open') {
-        printError(`Invalid --state: "${stateRaw}". Must be one of: closed | closed-unknown.`);
-        throw new CliExit(1);
+        fail(`Invalid --state: "${stateRaw}". Must be one of: closed | closed-unknown.`);
     }
     const actualRaw = flags['actual'];
     const actualValue = actualRaw !== undefined ? Number(actualRaw) : undefined;
     if (actualRaw !== undefined && !Number.isFinite(actualValue)) {
-        printError(`Invalid --actual: "${actualRaw}". Must be a number.`);
-        throw new CliExit(1);
+        fail(`Invalid --actual: "${actualRaw}". Must be a number.`);
     }
     const closureNote = stringFlag(flags, 'note');
     const closed = await predictionsApi.closePrediction(ctx, id, {
@@ -46,8 +44,7 @@ async function loadPredictionList(ctx, status, classTag, limit) {
     const closureState = requireStatus(status, VALID_CLOSURE_STATES);
     if (!classTag) {
         // status filter without class: scan all classes is more complex; v1 requires --class for non-default status
-        printError('--status filter (non-open) requires --class to be set.');
-        throw new CliExit(1);
+        fail('--status filter (non-open) requires --class to be set.');
     }
     return predictionsApi.listPredictions(ctx, {
         classTag,
@@ -82,8 +79,9 @@ async function predictShow(ctx, args) {
     console.log(`  class: ${pred.classTag}`);
     console.log(`  claim: ${pred.claimText}`);
     console.log(`  state: ${pred.closureState}`);
-    if (pred.estimateValue !== null)
+    if (pred.estimateValue !== null) {
         console.log(`  estimate: ${pred.estimateValue}${pred.estimateUnit ? ' ' + pred.estimateUnit : ''}`);
+    }
     if (pred.targetDate)
         console.log(`  target: ${pred.targetDate}`);
     if (pred.actualValue !== null)
@@ -100,8 +98,7 @@ async function predictBaserate(ctx, flags) {
     // Reference-class / planning-fallacy detector
     const classTag = stringFlag(flags, 'class')?.trim();
     if (!classTag) {
-        printError('Usage: hippo predict baserate --class <c>');
-        throw new CliExit(1);
+        fail('Usage: hippo predict baserate --class <c>');
     }
     const baserate = await predictionsApi.predictionBaserate(ctx, classTag);
     if (baserate.nClosed === 0) {
@@ -113,10 +110,12 @@ async function predictBaserate(ctx, flags) {
     console.log(baserate.summary);
     console.log(`  n_closed:         ${baserate.nClosed}`);
     console.log(`  n_ratio_eligible: ${baserate.nRatioEligible}`);
-    if (baserate.meanEstimate !== null)
+    if (baserate.meanEstimate !== null) {
         console.log(`  mean_estimate:    ${baserate.meanEstimate.toFixed(BASERATE_DECIMALS)}`);
-    if (baserate.meanActual !== null)
+    }
+    if (baserate.meanActual !== null) {
         console.log(`  mean_actual:      ${baserate.meanActual.toFixed(BASERATE_DECIMALS)}`);
+    }
     if (baserate.meanRatio !== null)
         console.log(`  mean_ratio:       ${baserate.meanRatio.toFixed(BASERATE_DECIMALS)}x`);
     if (baserate.p50Ratio !== null)
@@ -144,19 +143,16 @@ async function predictCreate(ctx, claimText, flags) {
         printError('Usage: hippo predict "<claim>" --class <c> [--estimate <v>] [--unit <u>] [--target <YYYY-MM-DD>]');
         printError('       hippo predict close <id> --state <closed|closed-unknown> [--actual <v>] [--note "..."]');
         printError('       hippo predict list [--class X] [--status open|closed|closed-unknown|all] [--limit N]');
-        printError('       hippo predict show <id>');
-        throw new CliExit(1);
+        fail('       hippo predict show <id>');
     }
     const classTag = stringFlag(flags, 'class')?.trim();
     if (!classTag) {
-        printError('--class is required for prediction creation.');
-        throw new CliExit(1);
+        fail('--class is required for prediction creation.');
     }
     const estimateRaw = flags['estimate'];
     const estimateValue = estimateRaw !== undefined ? Number(estimateRaw) : undefined;
     if (estimateRaw !== undefined && !Number.isFinite(estimateValue)) {
-        printError(`Invalid --estimate: "${estimateRaw}". Must be a number.`);
-        throw new CliExit(1);
+        fail(`Invalid --estimate: "${estimateRaw}". Must be a number.`);
     }
     const estimateUnit = stringFlag(flags, 'unit');
     const targetDate = stringFlag(flags, 'target');

package/dist/cli/print.js

@@ -15,9 +15,11 @@ export function recallEntryText(r, query, showWhy, isGlobal) {
     const bars = Math.round(e.strength * 10);
     const graphMark = r.graphVia ? ` [graph: ${r.graphVia.hops}hop ${r.graphVia.relType}]` : '';
     const lines = [
-        `--- ${e.id} [${e.layer}] ${confLabel}${isGlobal ? ' [global]' : ''}${e.superseded_by ? ' [superseded]' : ''}${graphMark} ` +
+        `--- ${e.id} [${e.layer}] ` +
+            `${confLabel}${isGlobal ? ' [global]' : ''}${e.superseded_by ? ' [superseded]' : ''}${graphMark} ` +
             `score=${fmt(r.score, 3)} strength=${fmt(e.strength)}`,
-        `    [${'█'.repeat(bars)}${'░'.repeat(10 - bars)}] tags: ${e.tags.join(', ') || 'none'} | retrieved: ${e.retrieval_count}x`,
+        `    [${'█'.repeat(bars)}${'░'.repeat(10 - bars)}] tags: ${e.tags.join(', ') || 'none'} | retrieved: ` +
+            `${e.retrieval_count}x`,
     ];
     if (showWhy) {
         const explanation = explainMatch(query, r);

package/dist/cli/projects.js

@@ -1,4 +1,5 @@
-// The `hippo projects` verb: list a store's project names, fold an old worktree name into its repo, repair old tags in one pass.
+// The `hippo projects` verb: list a store's project names, fold an old worktree name into its repo, repair old tags in
+// one pass.
 import * as path from 'path';
 import { execFileSync } from 'child_process';
 import * as api from '../api/index.js';
@@ -17,7 +18,10 @@ function worktreeNames() {
             stdio: ['ignore', 'pipe', 'ignore'],
             windowsHide: true,
         });
-        const paths = out.split(/\r?\n/).filter((l) => l.startsWith('worktree ')).map((l) => path.basename(l.slice('worktree '.length)));
+        const paths = out
+            .split(/\r?\n/)
+            .filter((l) => l.startsWith('worktree '))
+            .map((l) => path.basename(l.slice('worktree '.length)));
         return new Map(paths.slice(1).map((name) => [name, paths[0]]));
     }
     catch {
@@ -32,7 +36,9 @@ function hint(p, worktrees) {
     const main = p.origin ? worktrees.get(p.origin) : undefined;
     if (main)
         return `\n    a worktree of ${main}: hippo projects merge ${p.origin} ${main}`;
-    return p.copiesElsewhere > 0 ? `\n    ${p.copiesElsewhere} of its imported notes are copies also held under another name` : '';
+    return p.copiesElsewhere > 0
+        ? `\n    ${p.copiesElsewhere} of its imported notes are copies also held under another name`
+        : '';
 }
 function count(n, one, many = `${one}s`) {
     return `${n} ${n === 1 ? one : many}`;
@@ -60,11 +66,12 @@ function projectsMerge(ctx, args, flags) {
         return;
     }
     console.log(`${apply ? 'Merged' : 'Dry run: would merge'} ${from} into ${into}:`);
-    console.log(`  ${count(r.setAside.length, 'imported note ' +
-        'copy', 'imported note copies')} set aside (${into} already holds the same note; the rest move under ${into} on the next sync)`);
+    console.log(`  ${count(r.setAside.length, 'imported note ' + 'copy', 'imported note copies')} set aside (${into} already holds the same note; the rest move under ${into} on the next sync)`);
     console.log(`  ${count(r.restamped.length, 'memory', 'memories')} re-tagged, plus ${r.dormantRestamped.length} dormant ` +
         `and ${count(r.compactions, 'compaction record')}`);
-    console.log(apply ? `Backup: ${r.backup}\nEvery id is in the audit log: hippo audit list --op project_merge` : 'Nothing written. Add --apply to run it.');
+    console.log(apply
+        ? `Backup: ${r.backup}\nEvery id is in the audit log: hippo audit list --op project_merge`
+        : 'Nothing written. Add --apply to run it.');
 }
 function projectsRepair(ctx, flags) {
     const root = ctx.hippoRoot;
@@ -75,17 +82,20 @@ function projectsRepair(ctx, flags) {
         return;
     }
     console.log(`${apply ? 'Repaired' : 'Dry run: would repair'} ${root}:`);
-    console.log(`  ${count(r.copies.length, 'imported note ' +
-        'copy', 'imported note copies')} under the wrong project set aside (the note stays under its own, or user-global)`);
+    console.log(`  ${count(r.copies.length, 'imported note ' + 'copy', 'imported note copies')} under the wrong project set aside (the note stays under its own, or user-global)`);
     for (const f of r.folds)
         console.log(`  ${f.from} folded into ${f.into} (its sessions' folders resolve there now)`);
     for (const c of r.collisions) {
-        console.log(`  ${c.name} left as it is: its folders now resolve to ${c.ids.join(', ')}; fold it by hand with hippo projects merge`);
+        console.log(`  ${c.name} left as it is: its folders now resolve to ${c.ids.join(', ')}; fold it by hand with hippo ` +
+            `projects merge`);
     }
     console.log(`  sleep's user-global merged rows: ${r.toProject.length} re-tagged to their parents' project`);
     console.log(`  ${r.setAside.length} set aside (parents in two projects; sleep re-merges them per project)`);
-    console.log(`  ${r.untraced.length} left as they are (no parent left to show which project; check them with hippo inspect <id>)`);
-    console.log(apply ? `Backup: ${r.backup}\nEvery id is in the audit log: hippo audit list --op project_repair` : 'Nothing written. Add --apply to run it.');
+    console.log(`  ${r.untraced.length} left as they are (no parent left to show which project; check them with hippo inspect ` +
+        `<id>)`);
+    console.log(apply
+        ? `Backup: ${r.backup}\nEvery id is in the audit log: hippo audit list --op project_repair`
+        : 'Nothing written. Add --apply to run it.');
 }
 export function handleProjects({ hippoRoot, tenantId, args, flags }) {
     const ctx = cliApiContext(resolveAuthRoot(hippoRoot, flags), tenantId);