hippo-memory 1.71.0 → 2.0.0

package/dist/cli/curate.js

@@ -1,12 +1,11 @@
 // Verbs that weaken, suppress or retire memories: outcome, forget, conflicts, reject, dormant, quarantine, invalidate.
+import { truncateWithEllipsis } from '../util/ellipsize.js';
 import * as path from 'path';
-import { listMemoryConflicts, resolveConflict } from '../store/conflicts.js';
-import { rejectValue, unrejectValue, listRejectionsForTenant } from '../trust/reject-flow.js';
-import { RejectedValueError } from '../store/rejection.js';
+import { unrejectValue, listRejectionsForTenant } from '../trust/reject-flow.js';
+import { RejectedValueError } from '../core/api-errors.js';
 import { loadConfig } from '../core/config.js';
 import { RawAppendOnlyError } from '../core/raw-append-only.js';
 import { isGitRepo } from '../learn/autolearn.js';
-import { invalidateMatching } from '../learn/invalidation.js';
 import * as api from '../api/index.js';
 import { getMemory } from '../api/memories.js';
 import * as client from './client.js';
@@ -22,7 +21,7 @@ const CONFLICT_PREVIEW_CHARS = 120;
 const REJECTED_DIGEST_LIST_CHARS = 16;
 const DORMANT_PREVIEW_CHARS = 100;
 const STRENGTH_DECIMALS = 3;
-export function handleOutcome({ hippoRoot, tenantId, flags }) {
+export async function handleOutcome({ hippoRoot, tenantId, flags }) {
     requireInit(hippoRoot);
     const good = boolFlag(flags, 'good');
     const bad = boolFlag(flags, 'bad');
@@ -35,10 +34,10 @@ export function handleOutcome({ hippoRoot, tenantId, flags }) {
     const specificId = flags['id'] ? String(flags['id']) : null;
     let updated;
     if (specificId) {
-        updated = api.outcome(ctx, [specificId], good).applied;
+        updated = (await api.outcome(ctx, [specificId], good)).applied;
     }
     else {
-        const r = api.outcomeForLastRecall(ctx, good);
+        const r = await api.outcomeForLastRecall(ctx, good);
         if (r.ids.length === 0) {
             console.log('No recent recall to apply outcome to. Use --id <id> to target a specific memory.');
             return;
@@ -49,17 +48,17 @@ export function handleOutcome({ hippoRoot, tenantId, flags }) {
 }
 // Shared between the forget dispatch and cmdForget so the message can't drift.
 const ARCHIVE_REASON_REQUIRED = 'hippo forget --archive requires --reason "<why>" (recorded on the archive).';
-function cmdForget(hippoRoot, tenantId, id, flags) {
+async function cmdForget(hippoRoot, tenantId, id, flags) {
     requireInit(hippoRoot);
     const ctx = cliApiContext(hippoRoot, tenantId);
     // Raw memories (connector ingestion) are append-only: a BEFORE-DELETE trigger aborts any delete,
     // so archiveRaw is the sanctioned removal path and records ctx.actor as the archiver.
     if (flagIsTrue(flags, 'archive')) {
-        archiveForgottenRaw(ctx, id, stringFlag(flags, 'reason') ?? null);
+        await archiveForgottenRaw(ctx, id, stringFlag(flags, 'reason') ?? null);
         return;
     }
     try {
-        api.forget(ctx, id);
+        await api.forget(ctx, id);
         console.log(`Forgot ${id}`);
     }
     catch (err) {
@@ -67,13 +66,13 @@ function cmdForget(hippoRoot, tenantId, id, flags) {
         throw new CliExit(1);
     }
 }
-function archiveForgottenRaw(ctx, id, reason) {
+async function archiveForgottenRaw(ctx, id, reason) {
     if (!reason) {
         printError(ARCHIVE_REASON_REQUIRED);
         throw new CliExit(1);
     }
     try {
-        api.archiveRaw(ctx, id, reason);
+        await api.archiveRaw(ctx, id, reason);
         console.log(`Archived ${id}`);
     }
     catch (err) {
@@ -116,12 +115,12 @@ async function previewForget(hippoRoot, tenantId, id, archive) {
         printError(`Could not archive ${id}: memory ${id} is not raw (kind=${entry.kind})`);
         throw new CliExit(1);
     }
-    const snippet = entry.content.length > CONTENT_PREVIEW_CHARS ? `${entry.content.slice(0, CONTENT_PREVIEW_CHARS)}...` : entry.content;
+    const snippet = truncateWithEllipsis(entry.content, CONTENT_PREVIEW_CHARS);
     console.log(`Would ${archive ? 'archive' : 'forget'} ${id} (dry run, nothing changed): "${snippet}"`);
 }
-export function handleConflicts({ hippoRoot, flags }) {
+export function handleConflicts({ hippoRoot, tenantId, flags }) {
     requireInit(hippoRoot);
-    const conflicts = listMemoryConflicts(hippoRoot, String(flags['status'] ?? 'open'));
+    const conflicts = api.listConflicts(cliApiContext(hippoRoot, tenantId), String(flags['status'] ?? 'open'), { everyTenant: true });
     if (flags['json']) {
         console.log(JSON.stringify({ conflicts }, null, 2));
         return;
@@ -140,7 +139,7 @@ export function handleConflicts({ hippoRoot, flags }) {
 }
 /** Shown when --keep is missing, to help the user decide. */
 async function showConflictForResolve(hippoRoot, conflictId, tenantId) {
-    const conflicts = listMemoryConflicts(hippoRoot, 'open', tenantId);
+    const conflicts = api.listConflicts(cliApiContext(hippoRoot, tenantId), 'open');
     const conflict = conflicts.find((c) => c.id === conflictId);
     if (!conflict) {
         printError(`Conflict ${conflictId} not found or already resolved.`);
@@ -155,11 +154,11 @@ async function showConflictForResolve(hippoRoot, conflictId, tenantId) {
     const entryB = await getMemory(ctx, conflict.memory_b_id);
     if (entryA) {
         console.log(`  [A] ${conflict.memory_a_id}:`);
-        console.log(`      ${entryA.content.slice(0, CONFLICT_PREVIEW_CHARS)}${entryA.content.length > CONFLICT_PREVIEW_CHARS ? '...' : ''}`);
+        console.log(`      ${truncateWithEllipsis(entryA.content, CONFLICT_PREVIEW_CHARS)}`);
     }
     if (entryB) {
         console.log(`  [B] ${conflict.memory_b_id}:`);
-        console.log(`      ${entryB.content.slice(0, CONFLICT_PREVIEW_CHARS)}${entryB.content.length > CONFLICT_PREVIEW_CHARS ? '...' : ''}`);
+        console.log(`      ${truncateWithEllipsis(entryB.content, CONFLICT_PREVIEW_CHARS)}`);
     }
     console.log('');
     console.log(`Resolve with: hippo resolve ${conflictId} --keep <memory_id> [--forget] [--reject-loser [--reason "<why>"]]`);
@@ -183,14 +182,12 @@ 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 = resolveConflict(hippoRoot, conflictId, keepId, forgetLoser, tenantId, {
-        rejectLoserValue: rejectLoser,
+    const result = api.resolveMemoryConflict(cliApiContext(hippoRoot, tenantId), conflictId, {
+        keepId,
+        forget: forgetLoser,
+        rejectLoser,
         reason: reasonFlag,
     });
-    if (!result) {
-        printError(`Could not resolve conflict ${conflictId}. Check the ID and --keep value.`);
-        throw new CliExit(1);
-    }
     const action = rejectLoser
         ? 'rejected (tombstoned) and removed'
         : forgetLoser
@@ -222,10 +219,7 @@ export function handleReject({ hippoRoot, tenantId, args, flags }) {
         throw new CliExit(1);
     }
     try {
-        const result = rejectValue({
-            hippoRoot: root,
-            tenantId,
-            actor: 'cli',
+        const result = api.rejectOnHost(cliApiContext(root, tenantId), {
             reason,
             memoryId: valueFlag === undefined ? memoryId : undefined,
             value: valueFlag,
@@ -239,7 +233,7 @@ export function handleReject({ hippoRoot, tenantId, args, flags }) {
 }
 function printRejected(result, reason) {
     const digestPrefix = result.digest.slice(0, DIGEST_DISPLAY_CHARS);
-    const preview = result.content.length > CONTENT_PREVIEW_CHARS ? `${result.content.slice(0, CONTENT_PREVIEW_CHARS)}...` : result.content;
+    const preview = truncateWithEllipsis(result.content, CONTENT_PREVIEW_CHARS);
     console.log(`Rejected [${digestPrefix}...]: "${preview}"`);
     console.log(`  Reason: ${reason}`);
     if (result.removedIds.length > 0) {
@@ -357,10 +351,12 @@ function printDormantRows(rows, hasQuery, root) {
     }
     console.log(`${rows.length} dormant memor${rows.length === 1 ? 'y' : 'ies'}${hasQuery ? ' matching' : ''} (newest first):\n`);
     for (const row of rows) {
-        const preview = row.content.length > DORMANT_PREVIEW_CHARS ? `${row.content.slice(0, DORMANT_PREVIEW_CHARS)}...` : row.content;
+        const preview = truncateWithEllipsis(row.content, DORMANT_PREVIEW_CHARS);
         console.log(`--- ${row.id}`);
         console.log(`    ${preview}`);
-        console.log(`    Dormant since ${row.dormantAt.slice(0, DATE_PREFIX_CHARS)} (${row.reason}, strength ${row.strength.toFixed(STRENGTH_DECIMALS)})${row.tags.length > 0 ? `  tags: ${row.tags.join(', ')}` : ''}`);
+        console.log(`    Dormant since ${row.dormantAt.slice(0, DATE_PREFIX_CHARS)} ` +
+            `(${row.reason}, strength ${row.strength.toFixed(STRENGTH_DECIMALS)})` +
+            `${row.tags.length > 0 ? `  tags: ${row.tags.join(', ')}` : ''}`);
         console.log('');
     }
     console.log('Bring one back: hippo dormant restore <id>   Delete for good: hippo dormant forget <id>');
@@ -457,9 +453,9 @@ export async function handleForget({ hippoRoot, tenantId, args, flags }) {
     });
     if (routed)
         return;
-    cmdForget(hippoRoot, tenantId, id, flags);
+    await cmdForget(hippoRoot, tenantId, id, flags);
 }
-function invalidateChurn(hippoRoot, args, flags) {
+function invalidateChurn(hippoRoot, tenantId, args, flags) {
     if (args[0] || flags['id'] !== undefined) {
         printError('Usage: hippo invalidate --churn [--dry-run]');
         printError('--churn takes no pattern or --id.');
@@ -471,7 +467,7 @@ function invalidateChurn(hippoRoot, args, flags) {
     }
     const churnDryRun = flagIsTrue(flags, 'dry-run');
     let churnFailed = false;
-    for (const { root, result } of runChurnStaleForRepo(hippoRoot, churnDryRun)) {
+    for (const { root, result } of runChurnStaleForRepo(hippoRoot, tenantId, churnDryRun)) {
         if (result.error) {
             printError(`Churn-staleness check failed for ${root}: ${result.error}`);
             churnFailed = true;
@@ -497,7 +493,7 @@ function invalidateChurn(hippoRoot, args, flags) {
 export function handleInvalidate({ hippoRoot, tenantId, args, flags }) {
     requireInit(hippoRoot);
     if (flagIsTrue(flags, 'churn'))
-        return invalidateChurn(hippoRoot, args, flags);
+        return invalidateChurn(hippoRoot, tenantId, args, flags);
     const target = args[0];
     if (flagIsTrue(flags, 'id')) {
         // Value-less --id must never silently fall through to pattern mode
@@ -519,7 +515,7 @@ export function handleInvalidate({ hippoRoot, tenantId, args, flags }) {
         to: reason,
         type: 'migration',
     };
-    const result = invalidateMatching(hippoRoot, invTarget, tenantId, { dryRun, onlyId });
+    const result = api.invalidateMemories(cliApiContext(hippoRoot, tenantId), invTarget, { dryRun, onlyId });
     const label = target ? `"${target}"` : `--id ${onlyId}`;
     if (result.dryRun) {
         if (result.invalidated === 0) {

package/dist/cli/dag.d.ts

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

package/dist/cli/dag.js

@@ -1,7 +1,9 @@
 // DAG summary verbs: `hippo dag`, `hippo assemble` and `hippo drill`.
-import { loadAllEntries } from '../store/entry-reads.js';
+import { truncateWithEllipsis } from '../util/ellipsize.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 { cliApiContext } from './api-context.js';
 import { printError } from './output.js';
 import { parseBudgetFlag, flagIsTrue, stringFlag, numberFlag } from './flag-values.js';
 import { requireInit } from './shared.js';
@@ -13,9 +15,9 @@ 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, flags }) {
+export function handleDag({ hippoRoot, tenantId, flags }) {
     requireInit(hippoRoot);
-    const entries = loadAllEntries(hippoRoot);
+    const entries = listMemories(cliApiContext(hippoRoot, tenantId), { everyTenant: true });
     const isStats = flagIsTrue(flags, 'stats');
     const byLevel = new Map();
     let unlinked = 0;
@@ -39,6 +41,17 @@ function printDagStats(byLevel, unlinked) {
     console.log(`  Level 0 (raw memories):     ${byLevel.get(0) ?? 0}`);
     console.log(`  Unlinked facts: ${unlinked}`);
 }
+function groupByParent(entries) {
+    const byParent = new Map();
+    for (const e of entries) {
+        if (!e.dag_parent_id)
+            continue;
+        const list = byParent.get(e.dag_parent_id) ?? [];
+        list.push(e);
+        byParent.set(e.dag_parent_id, list);
+    }
+    return byParent;
+}
 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);
@@ -52,6 +65,7 @@ function printDagTree(entries) {
         list.push(l2);
         childL2ByProfile.set(l2.dag_parent_id, list);
     }
+    const childrenByParent = groupByParent(entries);
     if (profiles.length === 0 && orphanL2.length === 0) {
         console.log('No DAG summaries yet. Run `hippo sleep` with ANTHROPIC_API_KEY set.');
         return;
@@ -68,7 +82,7 @@ function printDagTree(entries) {
             console.log(`   └─ 📌 ${l2.content.slice(0, TREE_CHILD_PREVIEW_CHARS)}`);
             if (l2Tags)
                 console.log(`      [${l2Tags}]`);
-            const facts = entries.filter((e) => e.dag_parent_id === l2.id);
+            const facts = childrenByParent.get(l2.id) ?? [];
             for (const f of facts) {
                 console.log(`      └─ ${f.content.slice(0, TREE_LEAF_PREVIEW_CHARS)}`);
             }
@@ -80,7 +94,7 @@ function printDagTree(entries) {
         console.log(`\n📌 ${summary.content.slice(0, CONTENT_PREVIEW_CHARS)}`);
         if (summaryTags)
             console.log(`   [${summaryTags}]`);
-        const children = entries.filter((e) => e.dag_parent_id === summary.id);
+        const children = childrenByParent.get(summary.id) ?? [];
         for (const child of children) {
             console.log(`   └─ ${child.content.slice(0, TREE_CHILD_PREVIEW_CHARS)}`);
         }
@@ -165,11 +179,12 @@ async function cmdDrillDown(hippoRoot, tenantId, summaryId, flags) {
         console.log(JSON.stringify(r, null, 2));
         return;
     }
-    console.log(`Summary ${r.summary.id} — ${r.summary.descendantCount} descendants${r.summary.earliestAt ? ` (${r.summary.earliestAt} → ${r.summary.latestAt})` : ''}`);
-    console.log(`  ${r.summary.content.slice(0, DAG_SUMMARY_PREVIEW_CHARS)}${r.summary.content.length > DAG_SUMMARY_PREVIEW_CHARS ? '…' : ''}`);
+    console.log(`Summary ${r.summary.id} — ${r.summary.descendantCount} descendants` +
+        `${r.summary.earliestAt ? ` (${r.summary.earliestAt} → ${r.summary.latestAt})` : ''}`);
+    console.log(`  ${truncateWithEllipsis(r.summary.content, DAG_SUMMARY_PREVIEW_CHARS, '…')}`);
     console.log(`\nChildren (${r.children.length}/${r.totalChildren}${r.truncated ? ', truncated' : ''}):`);
     for (const c of r.children) {
-        console.log(`  [L${c.dagLevel}] ${c.id} — ${c.content.slice(0, DAG_CHILD_PREVIEW_CHARS)}${c.content.length > DAG_CHILD_PREVIEW_CHARS ? '…' : ''}`);
+        console.log(`  [L${c.dagLevel}] ${c.id} — ${truncateWithEllipsis(c.content, DAG_CHILD_PREVIEW_CHARS, '…')}`);
     }
 }
 export async function handleDrill({ hippoRoot, tenantId, args, flags }) {

package/dist/cli/decisions.d.ts

@@ -1,5 +1,3 @@
 import { type CommandContext } from './flag-values.js';
-export declare function handlePredict({ hippoRoot, tenantId, args, flags }: CommandContext): void;
 export declare function handleDecide({ hippoRoot, tenantId, args, flags }: CommandContext): Promise<void>;
-export declare function handleIncident({ hippoRoot, tenantId, args, flags }: CommandContext): void;
 //# sourceMappingURL=decisions.d.ts.map

package/dist/cli/decisions.js

@@ -1,191 +1,15 @@
-// First-class object verbs for predictions, decisions and incidents.
+// 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 { extractPathTags } from '../search/path-context.js';
-import * as predictionsModule from '../store/predictions.js';
 import * as decisionsModule from '../objects/decisions.js';
-import * as incidentsModule from '../objects/incidents.js';
 import { printError } from './output.js';
-import { nonEmptyStringFlag, parseListLimit, flagIsTrue, isStringFlag, stringFlag } from './flag-values.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, requireStatus } 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';
-const BASERATE_DECIMALS = 3;
 const DECISION = { cmd: 'decide', noun: 'Decision', idLabel: 'decision' };
-const INCIDENT = { cmd: 'incident', noun: 'Incident', idLabel: 'incident' };
-const PREDICTION_NOUN = 'Prediction';
-// Lenient on purpose (parseInt reads "1abc" as 1) until the next major version; incidents use the strict parser.
-function parseObjectId(idRaw, noun) {
-    const id = parseInt(String(idRaw), 10);
-    if (!Number.isFinite(id) || id <= 0) {
-        printError(`Invalid ${noun} id: "${idRaw}"`);
-        throw new CliExit(1);
-    }
-    return id;
-}
-// Prediction first-class object
-function predictClose(hippoRoot, tenantId, args, flags) {
-    const id = idArgOrExit(args, 'Usage: hippo predict close <id> --state <closed|closed-unknown> [--actual <v>] [--note "..."]', 'prediction', parseObjectId);
-    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 (!predictionsModule.VALID_CLOSURE_STATES.has(stateRaw) || stateRaw === 'open') {
-        printError(`Invalid --state: "${stateRaw}". Must be one of: closed | closed-unknown.`);
-        throw new CliExit(1);
-    }
-    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);
-    }
-    const closureNote = stringFlag(flags, 'note');
-    const closed = predictionsModule.closePrediction(hippoRoot, tenantId, id, {
-        // SAFETY: the check above exits unless stateRaw is in VALID_CLOSURE_STATES.
-        closureState: stateRaw,
-        actualValue,
-        closureNote,
-    });
-    console.log(`Prediction ${closed.id} closed: state=${closed.closureState}${closed.actualValue !== null ? ` actual=${closed.actualValue}` : ''}`);
-}
-function loadPredictionList(hippoRoot, tenantId, status, classTag, limit) {
-    if (status === 'open') {
-        return predictionsModule.loadOpenPredictions(hippoRoot, tenantId, {
-            classTag: classTag || undefined,
-            limit,
-        });
-    }
-    if (status === 'all') {
-        return classTag
-            ? predictionsModule.loadPredictionsByClass(hippoRoot, tenantId, classTag, { limit })
-            : predictionsModule.loadAllPredictions(hippoRoot, tenantId, { limit });
-    }
-    const closureState = requireStatus(status, predictionsModule.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);
-    }
-    return predictionsModule.loadPredictionsByClass(hippoRoot, tenantId, classTag, {
-        closureState,
-        limit,
-    });
-}
-function predictList(hippoRoot, tenantId, flags) {
-    const classTag = stringFlag(flags, 'class')?.trim() ?? '';
-    const status = stringFlag(flags, 'status')?.trim() ?? 'all';
-    const limit = parseListLimit(flags);
-    const results = loadPredictionList(hippoRoot, tenantId, status, classTag, limit);
-    if (results.length === 0) {
-        console.log(classTag ? `No predictions in class "${classTag}".` : 'No predictions.');
-        return;
-    }
-    console.log(`Found ${results.length} predictions:\n`);
-    for (const p of results) {
-        const estPart = p.estimateValue !== null ? ` estimate=${p.estimateValue}${p.estimateUnit ? ` ${p.estimateUnit}` : ''}` : '';
-        const actPart = p.actualValue !== null ? ` actual=${p.actualValue}` : '';
-        const tgtPart = p.targetDate ? ` target=${p.targetDate}` : '';
-        console.log(`#${p.id} [${p.closureState}] class=${p.classTag}${estPart}${actPart}${tgtPart}`);
-        console.log(`    ${p.claimText}`);
-        if (p.closureNote)
-            console.log(`    note: ${p.closureNote}`);
-    }
-}
-function predictShow(hippoRoot, tenantId, args) {
-    const id = idArgOrExit(args, 'Usage: hippo predict show <id>', 'prediction', parseObjectId);
-    const pred = foundOrExit(predictionsModule.loadPredictionById(hippoRoot, tenantId, id), PREDICTION_NOUN, id);
-    console.log(`Prediction #${pred.id}`);
-    console.log(`  class: ${pred.classTag}`);
-    console.log(`  claim: ${pred.claimText}`);
-    console.log(`  state: ${pred.closureState}`);
-    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)
-        console.log(`  actual: ${pred.actualValue}`);
-    if (pred.closedAt)
-        console.log(`  closed: ${pred.closedAt}`);
-    if (pred.closureNote)
-        console.log(`  note: ${pred.closureNote}`);
-    if (pred.memoryId)
-        console.log(`  memory: ${pred.memoryId}`);
-    console.log(`  created: ${pred.createdAt}`);
-}
-function predictBaserate(hippoRoot, tenantId, 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);
-    }
-    const baserate = predictionsModule.computePredictionBaserate(hippoRoot, tenantId, classTag);
-    if (baserate.nClosed === 0) {
-        console.log(`No closed predictions in class "${baserate.classTag}" yet.`);
-        console.log(`  Create one with: hippo predict "<claim>" --class ${baserate.classTag} --estimate N`);
-        console.log(`  Close it later:  hippo predict close <id> --state closed --actual N`);
-        return;
-    }
-    console.log(baserate.summary);
-    console.log(`  n_closed:         ${baserate.nClosed}`);
-    console.log(`  n_ratio_eligible: ${baserate.nRatioEligible}`);
-    if (baserate.meanEstimate !== null)
-        console.log(`  mean_estimate:    ${baserate.meanEstimate.toFixed(BASERATE_DECIMALS)}`);
-    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)
-        console.log(`  p50_ratio:        ${baserate.p50Ratio.toFixed(BASERATE_DECIMALS)}x`);
-    if (baserate.mae !== null)
-        console.log(`  mae:              ${baserate.mae.toFixed(BASERATE_DECIMALS)}`);
-}
-export function handlePredict({ hippoRoot, tenantId, args, flags }) {
-    requireInit(hippoRoot);
-    const subcommand = args[0] ?? '';
-    if (subcommand === 'close')
-        return predictClose(hippoRoot, tenantId, args, flags);
-    if (subcommand === 'list')
-        return predictList(hippoRoot, tenantId, flags);
-    if (subcommand === 'show')
-        return predictShow(hippoRoot, tenantId, args);
-    if (subcommand === 'baserate')
-        return predictBaserate(hippoRoot, tenantId, flags);
-    // Default subcommand: create. args[0] is the claim text.
-    predictCreate(hippoRoot, tenantId, subcommand, flags);
-}
-function predictCreate(hippoRoot, tenantId, claimText, flags) {
-    if (!claimText) {
-        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);
-    }
-    const classTag = stringFlag(flags, 'class')?.trim();
-    if (!classTag) {
-        printError('--class is required for prediction creation.');
-        throw new CliExit(1);
-    }
-    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);
-    }
-    const estimateUnit = stringFlag(flags, 'unit');
-    const targetDate = stringFlag(flags, 'target');
-    const created = predictionsModule.savePrediction(hippoRoot, tenantId, {
-        classTag,
-        claimText,
-        estimateValue,
-        estimateUnit,
-        targetDate,
-    });
-    console.log(`Prediction recorded: #${created.id} class=${created.classTag}`);
-    if (created.memoryId)
-        console.log(`  memory: ${created.memoryId}`);
-}
 function printDecisionRow(d) {
     const supPart = d.supersededBy !== null ? ` superseded_by=#${d.supersededBy}` : '';
     console.log(`#${d.id} [${d.status}]${supPart} memory=${d.memoryId ?? '-'}`);
@@ -202,7 +26,7 @@ function decideList(hippoRoot, tenantId, flags) {
     });
 }
 function decideGet(hippoRoot, tenantId, args) {
-    const id = idArgOrExit(args, 'Usage: hippo decide get <id>', DECISION.idLabel, parseObjectId);
+    const id = idArgOrExit(args, 'Usage: hippo decide get <id>', DECISION.idLabel);
     const decision = foundOrExit(decisionsModule.loadDecisionById(hippoRoot, tenantId, id), DECISION.noun, id);
     console.log(`Decision #${decision.id}`);
     console.log(`  status: ${decision.status}`);
@@ -212,7 +36,7 @@ function decideGet(hippoRoot, tenantId, args) {
     printLifecycleTail(decision);
 }
 function decideClose(hippoRoot, tenantId, args) {
-    closeObject(args, DECISION, (id) => decisionsModule.closeDecision(hippoRoot, tenantId, id), parseObjectId);
+    closeObject(args, DECISION, (id) => decisionsModule.closeDecision(hippoRoot, tenantId, id));
 }
 export async function handleDecide({ hippoRoot, tenantId, args, flags }) {
     requireInit(hippoRoot);
@@ -258,7 +82,7 @@ async function decideCreate(hippoRoot, tenantId, decisionText, flags) {
         extraTags: decisionPathTags,
     });
     if (oldEntry)
-        weakenSupersededMemory(hippoRoot, oldEntry, supersedesMemId);
+        weakenOrWarn(hippoRoot, oldEntry, supersedesMemId);
     console.log(`Decision recorded: #${created.id}`);
     if (created.memoryId)
         console.log(`  memory: ${created.memoryId}`);
@@ -272,7 +96,7 @@ function exitWithDecideUsage() {
     printError('       hippo decide close <id>');
     throw new CliExit(1);
 }
-function weakenSupersededMemory(hippoRoot, oldEntry, supersedesMemId) {
+function weakenOrWarn(hippoRoot, oldEntry, supersedesMemId) {
     // Best-effort and last: saveDecision already committed. Failing here would make a retry find no active
     // decision for the old memory and create a duplicate active successor, so warn instead.
     try {
@@ -288,106 +112,4 @@ function printSupersedes(supersedesMemId, supersedesDecisionId) {
         : ' (no active decision row; memory weakened only)';
     console.log(`  supersedes memory: ${supersedesMemId}${tail}`);
 }
-function printIncidentRow(inc) {
-    const linkPart = inc.linkedMemoryIds.length > 0 ? ` links=${inc.linkedMemoryIds.length}` : '';
-    console.log(`#${inc.id} [${inc.status}]${linkPart} memory=${inc.memoryId ?? '-'}`);
-    console.log(`    ${inc.incidentText}`);
-    if (inc.context)
-        console.log(`    context: ${inc.context}`);
-}
-function incidentList(hippoRoot, tenantId, flags) {
-    listObjects(flags, {
-        plural: 'incidents',
-        states: incidentsModule.VALID_INCIDENT_STATES,
-        load: (opts) => incidentsModule.loadIncidents(hippoRoot, tenantId, opts),
-        printRow: printIncidentRow,
-    });
-}
-function incidentGet(hippoRoot, tenantId, args) {
-    const id = idArgOrExit(args, 'Usage: hippo incident get <id>', INCIDENT.idLabel);
-    const incident = foundOrExit(incidentsModule.loadIncidentById(hippoRoot, tenantId, id), INCIDENT.noun, id);
-    console.log(`Incident #${incident.id}`);
-    console.log(`  status: ${incident.status}`);
-    console.log(`  text: ${incident.incidentText}`);
-    if (incident.context)
-        console.log(`  context: ${incident.context}`);
-    if (incident.resolutionText)
-        console.log(`  resolution: ${incident.resolutionText}`);
-    if (incident.resolvedAt)
-        console.log(`  resolved_at: ${incident.resolvedAt}`);
-    if (incident.closedAt)
-        console.log(`  closed_at: ${incident.closedAt}`);
-    if (incident.linkedMemoryIds.length > 0) {
-        console.log(`  linked memories: ${incident.linkedMemoryIds.join(', ')}`);
-    }
-    if (incident.memoryId)
-        console.log(`  memory: ${incident.memoryId}`);
-    console.log(`  created: ${incident.createdAt}`);
-}
-function incidentResolve(hippoRoot, tenantId, args, flags) {
-    const id = idArgOrExit(args, 'Usage: hippo incident resolve <id> --resolution "<text>"', INCIDENT.idLabel);
-    const resolutionRaw = stringFlag(flags, 'resolution');
-    if (!resolutionRaw?.trim()) {
-        printError('--resolution requires a non-empty value, e.g. hippo incident resolve <id> --resolution "root cause fixed".');
-        throw new CliExit(1);
-    }
-    const resolved = incidentsModule.resolveIncident(hippoRoot, tenantId, id, resolutionRaw);
-    console.log(`Incident #${resolved.id} resolved.`);
-}
-function incidentClose(hippoRoot, tenantId, args) {
-    closeObject(args, INCIDENT, (id) => incidentsModule.closeIncident(hippoRoot, tenantId, id));
-}
-export function handleIncident({ hippoRoot, tenantId, args, flags }) {
-    requireInit(hippoRoot);
-    const subcommand = args[0] ?? '';
-    if (subcommand === 'list')
-        return incidentList(hippoRoot, tenantId, flags);
-    if (subcommand === 'get')
-        return incidentGet(hippoRoot, tenantId, args);
-    if (subcommand === 'resolve')
-        return incidentResolve(hippoRoot, tenantId, args, flags);
-    if (subcommand === 'close')
-        return incidentClose(hippoRoot, tenantId, args);
-    // Default subcommand is open (create): accept both `incident open "<text>"` and bare `incident "<text>"`;
-    // for the `open` keyword the text is args[1], otherwise args[0] is the text.
-    incidentCreate(hippoRoot, tenantId, subcommand === 'open' ? (args[1] ?? '') : subcommand, flags);
-}
-function incidentCreate(hippoRoot, tenantId, incidentText, flags) {
-    if (!incidentText) {
-        printError('Usage: hippo incident "<incident>" [--context "<details>"] [--link <memory-id>]...');
-        printError('       hippo incident list [--status open|resolved|closed|all] [--limit N]');
-        printError('       hippo incident get <id>');
-        printError('       hippo incident resolve <id> --resolution "<text>"');
-        printError('       hippo incident close <id>');
-        throw new CliExit(1);
-    }
-    const context = nonEmptyStringFlag(flags, 'context');
-    // --link is a repeatable flag (collected into an array by parseArgs). A
-    // single --link <id> yields a string; normalize both to string[].
-    const linkRaw = flags['link'];
-    let linkedMemoryIds;
-    if (Array.isArray(linkRaw)) {
-        linkedMemoryIds = linkRaw;
-    }
-    else if (isStringFlag(linkRaw)) {
-        linkedMemoryIds = [linkRaw];
-    }
-    else if (linkRaw === true) {
-        printError('--link requires a memory id, e.g. hippo incident "<text>" --link mem_abc123.');
-        throw new CliExit(1);
-    }
-    const incidentPathTags = extractPathTags(process.cwd());
-    const created = incidentsModule.saveIncident(hippoRoot, tenantId, {
-        incidentText,
-        context,
-        linkedMemoryIds,
-        extraTags: incidentPathTags,
-    });
-    console.log(`Incident recorded: #${created.id}`);
-    if (created.memoryId)
-        console.log(`  memory: ${created.memoryId}`);
-    if (created.linkedMemoryIds.length > 0) {
-        console.log(`  linked memories: ${created.linkedMemoryIds.join(', ')}`);
-    }
-}
 //# sourceMappingURL=decisions.js.map

package/dist/cli/eval.d.ts

@@ -1,3 +1,3 @@
 import { type CommandContext } from './flag-values.js';
-export declare function handleEval({ hippoRoot, args, flags }: CommandContext): Promise<void>;
+export declare function handleEval({ hippoRoot, tenantId, args, flags }: CommandContext): Promise<void>;
 //# sourceMappingURL=eval.d.ts.map