hippo-memory 1.61.0 → 1.63.0

package/dist/cli/projects.js

@@ -1,8 +1,8 @@
-// The `hippo projects` verb: list a store's project names, fold an old worktree name into its repo, repair sleep's user-global merges.
+// 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 { closeHippoDb, openHippoDb } from '../db.js';
-import { listProjects, mergeProjects, repairUserGlobalMerges } from '../project-merge.js';
+import { listProjects, mergeProjects, repairProjects } from '../project-merge.js';
 import { resolveTenantId } from '../tenant.js';
 import { resolveAuthRoot } from './shared.js';
 import { printError } from './output.js';
@@ -58,19 +58,24 @@ export function cmdProjects(hippoRoot, 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 (dormant; the next sync under ${into} imports the notes still on disk)`);
+            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.');
             return;
         }
         if (sub === 'repair') {
-            const r = repairUserGlobalMerges(db, root, { tenantId, dryRun: !apply });
+            const r = repairProjects(db, root, { tenantId, dryRun: !apply });
             if (flags['json']) {
                 console.log(JSON.stringify(r, null, 2));
                 return;
             }
-            console.log(`${apply ? 'Repaired' : 'Dry run: would repair'} sleep's user-global merged rows:`);
-            console.log(`  ${r.toProject.length} re-tagged to their parents' project`);
+            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)`);
+            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(`  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.');

package/dist/cli/recall.js

@@ -10,6 +10,7 @@ import { loadLatestHandoff } from '../store/handoffs.js';
 import { passesScopeFilterForRecall } from '../recall-scope.js';
 import { fitBudget } from '../search/finalize.js';
 import { explainMatch } from '../search/explain.js';
+import { DEFAULT_RECALL_BUDGET } from '../search/types.js';
 import { writeRecallTraceAtRoot } from '../recall-trace.js';
 import { loadConfig } from '../config.js';
 import { openHippoDb, closeHippoDb } from '../db.js';
@@ -188,7 +189,7 @@ export async function cmdRecall(hippoRoot, query, flags) {
 }
 /** Every flag recall reads, parsed in the order the single-body command checked them. */
 function parseRecallOptions(hippoRoot, flags) {
-    const budget = parseBudgetFlag(flags['budget'], 4000);
+    const budget = parseBudgetFlag(flags['budget'], DEFAULT_RECALL_BUDGET);
     const limit = parseLimitFlag(flags['limit']);
     const asJson = Boolean(flags['json']);
     const showWhy = Boolean(flags['why']);
@@ -441,9 +442,7 @@ function auditRecall(hippoRoot, globalRoot, query, fit) {
 /** Traces the recall, books retrieval for a non-empty list, then prints JSON or the fitted block. */
 function writeRecallResult(hippoRoot, query, o, fit, localIndex) {
     const { tenantId, sessionId, showWhy, asJson, includeContinuity } = o;
-    const { results, recallText, cmdPlanningFallacyHint, cmdPlanningFallacyWatching, continuityTokens } = fit;
-    const { activeSnapshot, sessionHandoff, recentSessionEvents } = fit.continuity;
-    const { anchoring: cmdAnchoringHint, availability: cmdAvailabilityHint, summary: cmdSuppressionSummary } = fit.hints;
+    const { results, recallText } = fit;
     // The token ledger books the block this recall prints, on whichever exit it takes.
     const emit = (text) => {
         withLedgerDb(hippoRoot, (db) => recordTokenUse(db, {
@@ -466,59 +465,46 @@ function writeRecallResult(hippoRoot, query, o, fit, localIndex) {
             explainMode: showWhy,
             results: [],
         });
-        if (asJson) {
-            const out = {
-                query,
-                results: [],
-                total: 0,
-                suppressionSummary: cmdSuppressionSummary,
-                // HTTP and MCP surface the hint whatever matched, so the zero-result JSON keeps it for parity.
-                ...(cmdPlanningFallacyHint ? { planningFallacyHint: cmdPlanningFallacyHint } : {}),
-                ...(cmdPlanningFallacyWatching ? { planningFallacyWatching: cmdPlanningFallacyWatching } : {}),
-                ...(cmdAnchoringHint ? { anchoringHint: cmdAnchoringHint } : {}),
-                ...(cmdAvailabilityHint ? { availabilityHint: cmdAvailabilityHint } : {}),
-            };
-            if (includeContinuity) {
-                out.continuity = {
-                    activeSnapshot,
-                    sessionHandoff,
-                    recentSessionEvents,
-                };
-                out.continuityTokens = continuityTokens;
-            }
-            emit(JSON.stringify(out));
-            return;
-        }
-        emit(recallText);
+        // HTTP and MCP surface the hint whatever matched, so the zero-result JSON keeps it for parity.
+        emit(asJson ? JSON.stringify({ query, results: [], total: 0, ...recallJsonTail(fit, includeContinuity) }) : recallText);
         return;
     }
     recordRetrieval(hippoRoot, query, o, results, localIndex);
     if (asJson) {
         const output = results.map((r) => recallJsonRow(r, query, showWhy, o.primaryIsGlobal || (isInitialized(o.globalRoot) && !localIndex.entries[r.entry.id])));
-        const jsonOut = {
+        emit(JSON.stringify({
             query,
             budget: o.budget,
             results: output,
             total: output.length,
-            suppressionSummary: cmdSuppressionSummary,
-            ...(cmdPlanningFallacyHint ? { planningFallacyHint: cmdPlanningFallacyHint } : {}),
-            ...(cmdPlanningFallacyWatching ? { planningFallacyWatching: cmdPlanningFallacyWatching } : {}),
-            ...(cmdAnchoringHint ? { anchoringHint: cmdAnchoringHint } : {}),
-            ...(cmdAvailabilityHint ? { availabilityHint: cmdAvailabilityHint } : {}),
-        };
-        if (includeContinuity) {
-            jsonOut.continuity = {
-                activeSnapshot,
-                sessionHandoff,
-                recentSessionEvents,
-            };
-            jsonOut.continuityTokens = continuityTokens;
-        }
-        emit(JSON.stringify(jsonOut));
+            ...recallJsonTail(fit, includeContinuity),
+        }));
         return;
     }
     emit(recallText);
 }
+/** The JSON keys after the result list: suppression summary, any bias hints, then continuity when asked for. */
+function recallJsonTail(fit, includeContinuity) {
+    const { cmdPlanningFallacyHint, cmdPlanningFallacyWatching, continuityTokens } = fit;
+    const { activeSnapshot, sessionHandoff, recentSessionEvents } = fit.continuity;
+    const { anchoring: cmdAnchoringHint, availability: cmdAvailabilityHint, summary: cmdSuppressionSummary } = fit.hints;
+    const tail = {
+        suppressionSummary: cmdSuppressionSummary,
+        ...(cmdPlanningFallacyHint ? { planningFallacyHint: cmdPlanningFallacyHint } : {}),
+        ...(cmdPlanningFallacyWatching ? { planningFallacyWatching: cmdPlanningFallacyWatching } : {}),
+        ...(cmdAnchoringHint ? { anchoringHint: cmdAnchoringHint } : {}),
+        ...(cmdAvailabilityHint ? { availabilityHint: cmdAvailabilityHint } : {}),
+    };
+    if (includeContinuity) {
+        tail.continuity = {
+            activeSnapshot,
+            sessionHandoff,
+            recentSessionEvents,
+        };
+        tail.continuityTokens = continuityTokens;
+    }
+    return tail;
+}
 /** Strengthens the returned rows and persists last_retrieval_ids and last_trace_id in one saveIndex call. */
 function recordRetrieval(hippoRoot, query, o, results, localIndex) {
     const { globalRoot, tenantId, sessionId, showWhy } = o;

package/dist/cli/remember.js

@@ -41,17 +41,8 @@ function rememberTags(flags, cwd) {
     }
     return { requested, all };
 }
-async function cmdRemember(hippoRoot, text, flags) {
-    const useGlobal = Boolean(flags['global']);
-    const targetRoot = useGlobal ? getGlobalRoot() : hippoRoot;
-    if (useGlobal) {
-        initGlobal();
-    }
-    else {
-        requireInit(hippoRoot);
-    }
-    const { requested: requestedTags, all: allTags } = rememberTags(flags, process.cwd());
-    // Resolve explicit confidence flag (default: 'verified' for manual remember)
+// Resolve explicit confidence flag (default: 'verified' for manual remember)
+function rememberConfidence(flags) {
     let confidence = 'verified';
     if (flags['observed'])
         confidence = 'observed';
@@ -59,14 +50,13 @@ async function cmdRemember(hippoRoot, text, flags) {
         confidence = 'inferred';
     if (flags['verified'])
         confidence = 'verified';
-    // Schema fit needs the store, which the routed request has no access to, so it stays here.
-    const existing = loadAllEntries(targetRoot, resolveTenantId({}));
-    const schemaFit = computeSchemaFit(text, requestedTags, existing);
-    // A3 envelope flags
+    return confidence;
+}
+function parseKindFlag(flags) {
     const kindFlagRaw = typeof flags['kind'] === 'string' ? flags['kind'] : undefined;
     const kindFlag = kindFlagRaw === undefined ? undefined : kindFlagRaw.toLowerCase();
     // CLI surface intentionally restricted: 'raw' is reserved for ingestion connectors
-    // (E1.x: Slack/Jira/Gmail) that route deletions through archiveRawMemory. Existing
+    // that route deletions through archiveRawMemory. Existing
     // forget/consolidate/conflict-resolve paths abort on kind='raw' via the append-only
     // trigger, so exposing --kind raw here would create unforgettable memories.
     // 'archived' is an internal sentinel set only inside archiveRawMemory's transaction.
@@ -76,6 +66,10 @@ async function cmdRemember(hippoRoot, text, flags) {
         printError(`(kind='raw' is reserved for ingestion connectors; kind='archived' is internal.)`);
         process.exit(1);
     }
+    return kindFlag;
+}
+function parseRememberEnvelope(flags) {
+    const kind = parseKindFlag(flags);
     const ownerRaw = typeof flags['owner'] === 'string' ? flags['owner'] : null;
     const ownerCheck = validateOwner(ownerRaw, { strict: isStrictOwnerEnv() });
     if (!ownerCheck.ok) {
@@ -84,11 +78,27 @@ async function cmdRemember(hippoRoot, text, flags) {
     }
     if (ownerCheck.message)
         printError(ownerCheck.message);
-    const ownerFlag = ownerCheck.value ?? null;
-    const artifactRefFlag = typeof flags['artifact-ref'] === 'string' ? flags['artifact-ref'] : null;
-    const scopeForEnvelope = typeof flags['scope'] === 'string' ? flags['scope'].trim() || null : null;
-    // A5 stub auth: stamp tenant_id from env (HIPPO_TENANT) so recall isolation
-    // can filter on this row. Default tenant 'default' for unauthenticated CLI.
+    const owner = ownerCheck.value ?? null;
+    const artifactRef = typeof flags['artifact-ref'] === 'string' ? flags['artifact-ref'] : null;
+    const scope = typeof flags['scope'] === 'string' ? flags['scope'].trim() || null : null;
+    return { kind, owner, artifactRef, scope };
+}
+async function cmdRemember(hippoRoot, text, flags) {
+    const useGlobal = Boolean(flags['global']);
+    const targetRoot = useGlobal ? getGlobalRoot() : hippoRoot;
+    if (useGlobal) {
+        initGlobal();
+    }
+    else {
+        requireInit(hippoRoot);
+    }
+    const { requested: requestedTags, all: allTags } = rememberTags(flags, process.cwd());
+    const confidence = rememberConfidence(flags);
+    // Schema fit needs the store, which the routed request has no access to, so it stays here.
+    const existing = loadAllEntries(targetRoot, resolveTenantId({}));
+    const schemaFit = computeSchemaFit(text, requestedTags, existing);
+    const envelope = parseRememberEnvelope(flags);
+    // Stamp tenant_id from env (HIPPO_TENANT) so recall isolation can filter on this row; unauthenticated CLI gets 'default'.
     const tenantId = resolveTenantId({});
     const rememberConfig = loadConfig(targetRoot);
     const entry = createMemory(text, {
@@ -98,33 +108,43 @@ async function cmdRemember(hippoRoot, text, flags) {
         source: useGlobal ? 'cli-global' : 'cli',
         confidence,
         schema_fit: schemaFit,
-        kind: kindFlag,
-        scope: scopeForEnvelope,
-        owner: ownerFlag,
-        artifact_ref: artifactRefFlag,
+        kind: envelope.kind,
+        scope: envelope.scope,
+        owner: envelope.owner,
+        artifact_ref: envelope.artifactRef,
         tenantId,
         baseHalfLifeDays: rememberConfig.defaultHalfLifeDays,
     });
-    // Salience gate: decide if this memory is worth storing
-    if (rememberConfig.salience.enabled && !Boolean(flags['pin']) && !Boolean(flags['force'])) {
-        const salienceResult = computeSalience(text, entry.tags, existing, {
-            recentWindow: rememberConfig.salience.recentWindow,
-            overlapThreshold: rememberConfig.salience.overlapThreshold,
-            minContentLength: rememberConfig.salience.minContentLength,
-            maxRepeatErrors: rememberConfig.salience.maxRepeatErrors,
-        });
-        if (salienceResult.decision === 'skip') {
-            console.log(`Skipped (salience: ${salienceResult.reason}, score ${salienceResult.score.toFixed(2)})`);
-            return;
-        }
-        if (salienceResult.decision === 'start_weak') {
-            entry.strength = salienceResult.score;
-            entry.half_life_days = Math.max(1, entry.half_life_days * 0.5);
-            console.log(`Weakened (salience: ${salienceResult.reason}, strength ${salienceResult.score.toFixed(2)})`);
-        }
-    }
+    if (!passesSalienceGate(entry, text, existing, rememberConfig, flags))
+        return;
     writeEntry(targetRoot, entry);
     updateStats(targetRoot, { remembered: 1 });
+    printRemembered(entry, useGlobal);
+    void embedMemory(targetRoot, entry);
+    await extractRememberFacts(targetRoot, entry, flags);
+}
+/** False when the gate skips the write; a start_weak verdict weakens `entry` in place. */
+function passesSalienceGate(entry, text, existing, rememberConfig, flags) {
+    if (!rememberConfig.salience.enabled || Boolean(flags['pin']) || Boolean(flags['force']))
+        return true;
+    const salienceResult = computeSalience(text, entry.tags, existing, {
+        recentWindow: rememberConfig.salience.recentWindow,
+        overlapThreshold: rememberConfig.salience.overlapThreshold,
+        minContentLength: rememberConfig.salience.minContentLength,
+        maxRepeatErrors: rememberConfig.salience.maxRepeatErrors,
+    });
+    if (salienceResult.decision === 'skip') {
+        console.log(`Skipped (salience: ${salienceResult.reason}, score ${salienceResult.score.toFixed(2)})`);
+        return false;
+    }
+    if (salienceResult.decision === 'start_weak') {
+        entry.strength = salienceResult.score;
+        entry.half_life_days = Math.max(1, entry.half_life_days * 0.5);
+        console.log(`Weakened (salience: ${salienceResult.reason}, strength ${salienceResult.score.toFixed(2)})`);
+    }
+    return true;
+}
+function printRemembered(entry, useGlobal) {
     const prefix = useGlobal ? '[global] ' : '';
     console.log(`${prefix}Remembered [${entry.id}]`);
     console.log(`   Layer: ${entry.layer} | Strength: ${fmt(entry.strength)} | Half-life: ${entry.half_life_days}d | Confidence: ${entry.confidence}`);
@@ -134,7 +154,8 @@ async function cmdRemember(hippoRoot, text, flags) {
         console.log('   Pinned (no decay)');
     for (const w of vetSecrets(entry.content, entry.tags, false).warnings)
         printError(`Warning: ${w}`);
-    void embedMemory(targetRoot, entry);
+}
+async function extractRememberFacts(targetRoot, entry, flags) {
     const config = loadConfig(targetRoot);
     const shouldExtract = flags['extract'] || config.extraction.enabled === true;
     const apiKey = envAnthropicApiKey() ?? '';
@@ -186,15 +207,8 @@ function cmdSupersede(hippoRoot, oldId, newContent, flags) {
         tags,
         pinned,
     });
-    // AT1: write the SUCCESSOR first. The rejection guard fires on the new
-    // content — if it refuses, nothing has been mutated yet (the old ordering
-    // committed old.superseded_by before the guarded new write, leaving a
-    // dangling pointer to an id that was never created). If the old-row write
-    // below fails instead, the new row exists unpointered — an orphan
-    // successor, strictly less harmful than a dangling pointer. NOTE: unlike
-    // api.supersede (whose CAS + insert commit in ONE transaction), this CLI
-    // path is two independent writes and stays non-atomic; write order is its
-    // only ordering guarantee.
+    // Write the SUCCESSOR first: a rejection-guard refusal then mutates nothing, and an old-row failure leaves an
+    // orphan successor rather than a dangling pointer. Unlike api.supersede this path is two non-atomic writes.
     try {
         writeEntry(hippoRoot, newEntry);
     }
@@ -272,6 +286,18 @@ function cmdTrace(hippoRoot, id, flags) {
         printError(`Memory not found: ${id}`);
         process.exit(1);
     }
+    const t = {
+        entry, id, sourceLabel,
+        ...traceStats(entry),
+        ...traceLineage(hippoRoot, globalRoot, entry, id, tenantId),
+    };
+    if (asJson) {
+        printTraceJson(t);
+        return;
+    }
+    printTraceText(t);
+}
+function traceStats(entry) {
     const now = evalNow();
     const strength = calculateStrength(entry, now);
     const halfLife = entry.half_life_days;
@@ -285,6 +311,9 @@ function cmdTrace(hippoRoot, id, flags) {
     const conf = confidenceLabel(entry, now).text;
     // Projected strength: same decay curve, just push `now` out.
     const projectedAt = (days) => calculateStrength(entry, new Date(now.getTime() + days * 86_400_000));
+    return { strength, halfLife, rewardFactor, effHalfLife, ageDays, sinceLast, facets, conf, projectedAt };
+}
+function traceLineage(hippoRoot, globalRoot, entry, id, tenantId) {
     // Parents (consolidation lineage) — schema v9 field.
     const parents = Array.isArray(entry.parents) ? entry.parents : [];
     const parentPreviews = parents.map((pid) => {
@@ -297,35 +326,40 @@ function cmdTrace(hippoRoot, id, flags) {
         ...(isInitialized(globalRoot) ? listMemoryConflicts(globalRoot, 'open', tenantId) : []),
     ];
     const myConflicts = allConflicts.filter((c) => c.memory_a_id === id || c.memory_b_id === id);
-    if (asJson) {
-        console.log(JSON.stringify({
-            id: entry.id,
-            source: sourceLabel,
-            layer: entry.layer,
-            confidence: facets.tier,
-            aged_out: facets.agedOut,
-            pinned: entry.pinned,
-            starred: entry.starred,
-            tags: entry.tags,
-            content: entry.content,
-            created: entry.created,
-            age_days: ageDays,
-            last_retrieved: entry.last_retrieved,
-            days_since_last_retrieval: sinceLast,
-            retrieval_count: entry.retrieval_count,
-            strength_now: strength,
-            half_life_days: halfLife,
-            reward_factor: rewardFactor,
-            effective_half_life_days: effHalfLife,
-            projected_strength_30d: projectedAt(30),
-            projected_strength_90d: projectedAt(90),
-            outcome_positive: entry.outcome_positive,
-            outcome_negative: entry.outcome_negative,
-            parents: parentPreviews,
-            open_conflicts: myConflicts,
-        }, null, 2));
-        return;
-    }
+    return { parentPreviews, myConflicts };
+}
+function printTraceJson(t) {
+    const { entry, facets } = t;
+    console.log(JSON.stringify({
+        id: entry.id,
+        source: t.sourceLabel,
+        layer: entry.layer,
+        confidence: facets.tier,
+        aged_out: facets.agedOut,
+        pinned: entry.pinned,
+        starred: entry.starred,
+        tags: entry.tags,
+        content: entry.content,
+        created: entry.created,
+        age_days: t.ageDays,
+        last_retrieved: entry.last_retrieved,
+        days_since_last_retrieval: t.sinceLast,
+        retrieval_count: entry.retrieval_count,
+        strength_now: t.strength,
+        half_life_days: t.halfLife,
+        reward_factor: t.rewardFactor,
+        effective_half_life_days: t.effHalfLife,
+        projected_strength_30d: t.projectedAt(30),
+        projected_strength_90d: t.projectedAt(90),
+        outcome_positive: entry.outcome_positive,
+        outcome_negative: entry.outcome_negative,
+        parents: t.parentPreviews,
+        open_conflicts: t.myConflicts,
+    }, null, 2));
+}
+function printTraceText(t) {
+    const { entry, id, sourceLabel, conf, ageDays, strength, projectedAt, halfLife, rewardFactor, effHalfLife, sinceLast } = t;
+    const { parentPreviews, myConflicts } = t;
     console.log(`Memory: ${entry.id}  [${sourceLabel}]`);
     console.log('='.repeat(50));
     console.log(`Content:   ${entry.content.replace(/\s+/g, ' ').slice(0, 160)}${entry.content.length > 160 ? '...' : ''}`);
@@ -377,8 +411,7 @@ export async function handleRemember({ hippoRoot, args, flags }) {
     // flags (--pin, --layer, --extract, --global) still need the direct
     // path; we only intercept the minimal envelope. The salience gate is
     // NOT in richFlag and the route does not apply it, so a routed remember
-    // stores what a direct one would skip. Measured 2026-09-07, tracked in
-    // TODOS.md; do not read this list as covering salience.
+    // stores what a direct one would skip; do not read this list as covering salience.
     const richFlag = flags['pin'] || flags['global'] || flags['extract'] || flags['force'] ||
         flags['observed'] || flags['inferred'] || flags['verified'] ||
         flags['layer'] !== undefined;
@@ -387,9 +420,7 @@ export async function handleRemember({ hippoRoot, args, flags }) {
         const rememberKindAllowed = ['distilled', 'superseded'];
         if (rememberKindRaw === undefined || rememberKindAllowed.includes(rememberKindRaw)) {
             const tags = rememberTags(flags, process.cwd()).all;
-            // B2 v1.12.6 — validate --owner on the thin-client path too.
-            // Failure on this path exits early so the user gets the same
-            // validation experience whether or not a server is up.
+            // Validate --owner on the thin-client path too, so validation is the same whether or not a server is up.
             const thinOwnerRaw = typeof flags['owner'] === 'string' ? flags['owner'] : undefined;
             const thinOwnerCheck = validateOwner(thinOwnerRaw, { strict: isStrictOwnerEnv() });
             if (!thinOwnerCheck.ok) {