hippo-memory 1.22.0 → 1.24.0

package/dist/src/cli.js

@@ -25,6 +25,7 @@
  *   hippo decide "<decision>" [--context "<why>"] [--supersedes <id>]
  *   hippo wm <push|read|clear|flush>
  */
+import { evalNow, isRecallBoostAblated } from './ablation.js';
 import * as path from 'path';
 import * as fs from 'fs';
 import * as os from 'os';
@@ -32,11 +33,13 @@ import { fileURLToPath } from 'node:url';
 import { execFileSync, execSync, spawn } from 'child_process';
 import { installJsonHooks, uninstallJsonHooks, resolveJsonHookPaths, detectInstalledTools, defaultSleepLogPath, ensureCodexWrapperInstalled, installCodexWrapper, uninstallCodexWrapper, resolveCodexSessionTranscript, resolveCodexWrapperPaths, installOpencodePlugin, uninstallOpencodePlugin, resolveOpencodePluginPath, } from './hooks.js';
 import { createMemory, calculateStrength, calculateRewardFactor, deriveHalfLife, resolveConfidence, computeSchemaFit, Layer, } from './memory.js';
+import { resolveProjectIdentity } from './project-identity.js';
 import { getHippoRoot, isInitialized, initStore, writeEntry, readEntry, deleteEntry, loadAllEntries, loadSearchEntries, loadIndex, saveIndex, loadStats, updateStats, saveActiveTaskSnapshot, loadActiveTaskSnapshot, clearActiveTaskSnapshot, appendSessionEvent, listSessionEvents, listMemoryConflicts, resolveConflict, saveSessionHandoff, loadLatestHandoff, loadHandoffById, RECALL_DEFAULT_DENY_SCOPES, } from './store.js';
 import { markRetrieved, hybridSearch, physicsSearch, explainMatch, textOverlap } from './search.js';
 import { renderTraceContent, parseSteps } from './trace.js';
 import { deduplicateStore } from './dedupe.js';
-import { isEmbeddingAvailable, embedAll, embedMemory, loadEmbeddingIndex, resolveEmbeddingModel, } from './embeddings.js';
+import { isEmbeddingAvailable, embedAll, embedMemory, loadEmbeddingIndex, resolveEmbeddingModel, embeddingModelRequiresReindex, } from './embeddings.js';
+import { isEmbeddingConfigured, resolveEmbeddingProvider } from './embedding-provider.js';
 import { loadPhysicsState, resetAllPhysicsState } from './physics-state.js';
 import { computeSystemEnergy, vecNorm } from './physics.js';
 import { loadConfig } from './config.js';
@@ -49,7 +52,7 @@ import { extractPathTags } from './path-context.js';
 import { detectScope } from './scope.js';
 import { getGlobalRoot, initGlobal, shareMemory, listPeers, autoShare, transferScore, searchBothHybrid, syncGlobalToLocal, } from './shared.js';
 import { DAILY_TASK_NAME, buildDailyRunnerCommand, listRegisteredWorkspaces, registerWorkspace, runDailyMaintenance, } from './scheduler.js';
-import { importChatGPT, importClaude, importCursor, importGenericFile, importMarkdown, } from './importers.js';
+import { importChatGPT, importClaude, importCursor, importGenericFile, importMarkdown, importVault, } from './importers.js';
 import { cmdCapture } from './capture.js';
 import { auditMemories, appendAuditEvent, } from './audit.js';
 import { listApiKeys, revokeApiKey } from './auth.js';
@@ -639,8 +642,8 @@ async function cmdRemember(hippoRoot, text, flags) {
         console.log(`   Tags: ${entry.tags.join(', ')}`);
     if (entry.pinned)
         console.log('   Pinned (no decay)');
-    // Auto-embed if available
-    if (isEmbeddingAvailable()) {
+    // Auto-embed if available (provider-aware: local dep installed, or API key present)
+    if (isEmbeddingConfigured(targetRoot)) {
         embedMemory(targetRoot, entry).catch(() => {
             // Silently ignore embedding errors
         });
@@ -1481,9 +1484,15 @@ async function cmdRecall(hippoRoot, query, flags) {
     // Update retrieval metadata and persist
     const updated = markRetrieved(results.map((r) => r.entry));
     const localIndex = loadIndex(hippoRoot);
-    for (const u of updated) {
-        const targetRoot = localIndex.entries[u.id] ? hippoRoot : (isInitialized(globalRoot) ? globalRoot : hippoRoot);
-        writeEntry(targetRoot, u);
+    // EVAL-ONLY ablation (see ablation.ts): under the recall flag, markRetrieved
+    // returns unmutated entries (ids preserved for outcome attribution below)
+    // and persistence is skipped - writeEntry on identical rows still refreshes
+    // updated_at, rewrites mirrors, and marks DAG parents dirty.
+    if (!isRecallBoostAblated()) {
+        for (const u of updated) {
+            const targetRoot = localIndex.entries[u.id] ? hippoRoot : (isInitialized(globalRoot) ? globalRoot : hippoRoot);
+            writeEntry(targetRoot, u);
+        }
     }
     // Track last retrieval IDs for outcome command
     localIndex.last_retrieval_ids = updated.map((u) => u.id);
@@ -2090,7 +2099,7 @@ function cmdTrace(hippoRoot, id, flags) {
         console.error(`Memory not found: ${id}`);
         process.exit(1);
     }
-    const now = new Date();
+    const now = evalNow();
     const strength = calculateStrength(entry, now);
     const halfLife = deriveHalfLife(7, entry);
     const rewardFactor = calculateRewardFactor(entry);
@@ -2704,7 +2713,7 @@ function cmdStatus(hippoRoot) {
     requireInit(hippoRoot);
     const entries = loadAllEntries(hippoRoot);
     const stats = loadStats(hippoRoot);
-    const now = new Date();
+    const now = evalNow();
     const byLayer = {
         [Layer.Buffer]: 0,
         [Layer.Episodic]: 0,
@@ -2762,19 +2771,52 @@ function cmdStatus(hippoRoot) {
     else {
         console.log(`Last sleep:        never`);
     }
-    // Embedding status
-    const embAvail = isEmbeddingAvailable();
+    // Embedding status (provider-aware)
+    const embedProvider = (() => {
+        try {
+            return resolveEmbeddingProvider(hippoRoot);
+        }
+        catch {
+            return null;
+        }
+    })();
     console.log('');
-    console.log(`Embeddings:        ${embAvail ? 'available' : 'not installed (BM25 only)'}`);
-    if (embAvail) {
+    if (!embedProvider) {
+        console.log(`Embeddings:        misconfigured (check embeddings.provider / apiBaseUrl), BM25 only`);
+    }
+    else {
+        const embeddingsDisabled = loadConfig(hippoRoot).embeddings.enabled === false;
+        const embAvail = embedProvider.isAvailable();
+        if (embeddingsDisabled) {
+            console.log(`Embeddings:        disabled in config (embeddings.enabled = false), BM25 only`);
+        }
+        else if (embedProvider.kind === 'local') {
+            console.log(`Embeddings:        ${embAvail ? `available [${embedProvider.id}]` : 'not installed (BM25 only)'}`);
+        }
+        else if (embAvail) {
+            console.log(`Embeddings:        ${embedProvider.kind} api [${embedProvider.id}]`);
+        }
+        else {
+            console.log(`Embeddings:        ${embedProvider.kind} configured but ${embedProvider.keyEnv} not set (BM25 only)`);
+        }
+        // Show cached counts whenever vectors exist on disk (even when disabled or
+        // the key was removed), so the user still sees what is already indexed.
         const embIndex = loadEmbeddingIndex(hippoRoot);
-        const activeIds = new Set(entries.map((e) => e.id));
-        const activeEmbedded = Object.keys(embIndex).filter((id) => activeIds.has(id)).length;
-        const orphaned = Object.keys(embIndex).length - activeEmbedded;
-        let line = `Embedded:          ${activeEmbedded}/${entries.length} memories`;
-        if (orphaned > 0)
-            line += ` (${orphaned} orphaned — run \`hippo embed\` to prune)`;
-        console.log(line);
+        if (embAvail || Object.keys(embIndex).length > 0) {
+            const activeIds = new Set(entries.map((e) => e.id));
+            const activeEmbedded = Object.keys(embIndex).filter((id) => activeIds.has(id)).length;
+            const orphaned = Object.keys(embIndex).length - activeEmbedded;
+            const dims = Object.values(embIndex)[0]?.length;
+            let line = `Embedded:          ${activeEmbedded}/${entries.length} memories`;
+            if (dims)
+                line += ` (${dims}-dim)`;
+            if (orphaned > 0)
+                line += ` (${orphaned} orphaned, run \`hippo embed\` to prune)`;
+            console.log(line);
+            if (embeddingModelRequiresReindex(hippoRoot, embedProvider.id, embIndex)) {
+                console.log(`                   model changed, run \`hippo embed\` to reindex`);
+            }
+        }
     }
     // Physics status
     try {
@@ -2892,7 +2934,7 @@ function cmdInspect(hippoRoot, id) {
         console.error(`Memory not found: ${id}`);
         process.exit(1);
     }
-    const now = new Date();
+    const now = evalNow();
     const currentStrength = calculateStrength(entry, now);
     const lastRetrieved = new Date(entry.last_retrieved);
     const created = new Date(entry.created);
@@ -4877,6 +4919,9 @@ async function cmdContext(hippoRoot, args, flags) {
         tenantId: resolveTenantId({}),
         actor: api.adminActor('cli'),
     };
+    // v39 memory scope isolation: --cross-project re-includes other-project
+    // memories (rendered under a demarcated section below).
+    const crossProject = flags['cross-project'] === true;
     const opts = {
         q: query,
         budget,
@@ -4884,6 +4929,7 @@ async function cmdContext(hippoRoot, args, flags) {
         pinnedOnly,
         scope: ctxActiveScope ?? undefined,
         includeRecent: parseCountFlag(flags['include-recent']),
+        crossProject,
     };
     const result = await api.getContext(ctx, opts);
     // Early exit when there's nothing to render (matches pre-extraction behavior).
@@ -4896,8 +4942,13 @@ async function cmdContext(hippoRoot, args, flags) {
     // Format + framing are CLI rendering concerns; api.getContext doesn't see them.
     const format = String(flags['format'] ?? 'markdown');
     const framing = String(flags['framing'] ?? 'observe');
-    // Adapter: ContextResultEntry -> the print-helper input shape.
-    const renderItems = result.entries.map((r) => ({
+    // Adapter: ContextResultEntry -> the print-helper input shape. v39:
+    // cross-project inclusions (only present under --cross-project or with
+    // isolation disabled via crossProject) render in their own demarcated
+    // section so they can never masquerade as project memory.
+    const mainEntries = result.entries.filter((r) => r.category !== 'cross-project');
+    const crossEntries = result.entries.filter((r) => r.category === 'cross-project');
+    const renderItems = mainEntries.map((r) => ({
         entry: r.entry,
         score: r.score,
         tokens: r.tokens,
@@ -4912,6 +4963,8 @@ async function cmdContext(hippoRoot, args, flags) {
             confidence: r.entry.confidence,
             content: r.entry.content,
             global: r.isGlobal ?? false,
+            origin: r.origin ?? null,
+            category: r.category ?? null,
         }));
         console.log(JSON.stringify({
             query: query || '*',
@@ -4939,6 +4992,7 @@ async function cmdContext(hippoRoot, args, flags) {
             if (renderItems.length > 0) {
                 printContextMarkdown(renderItems, result.tokens, framing);
             }
+            printCrossProjectSection(crossEntries);
         }
         finally {
             console.log = realLog;
@@ -4968,6 +5022,7 @@ async function cmdContext(hippoRoot, args, flags) {
         if (renderItems.length > 0) {
             printContextMarkdown(renderItems, result.tokens, framing);
         }
+        printCrossProjectSection(crossEntries);
         // Ambient state summary (CLI-side: api.getContext doesn't load all entries
         // post-selection, so we re-load here for the landscape summary).
         const ambientConfig = loadConfig(hippoRoot);
@@ -4975,11 +5030,17 @@ async function cmdContext(hippoRoot, args, flags) {
             const tenantId = ctx.tenantId;
             const globalRoot = getGlobalRoot();
             const hasGlobalForAmbient = isInitialized(globalRoot);
+            // v39: the landscape summary must reflect the same admission policy as
+            // the injected entries - otherwise excluded rows leak back in as
+            // aggregate signal (codex P2-13).
+            const isolationOff = ambientConfig.contextProjectIsolation === false;
+            const ambientCurrentName = resolveProjectIdentity(process.cwd()).name;
+            const ambientAdmit = (e) => api.ambientAdmitEntry(e, ambientCurrentName, crossProject || isolationOff);
             const localForAmbient = isInitialized(hippoRoot)
-                ? loadAllEntries(hippoRoot, tenantId).filter(e => !e.superseded_by)
+                ? loadAllEntries(hippoRoot, tenantId).filter(e => !e.superseded_by).filter(ambientAdmit)
                 : [];
             const globalForAmbient = hasGlobalForAmbient
-                ? loadAllEntries(globalRoot, tenantId).filter(e => !e.superseded_by)
+                ? loadAllEntries(globalRoot, tenantId).filter(e => !e.superseded_by).filter(ambientAdmit)
                 : [];
             const allForAmbient = [...localForAmbient, ...globalForAmbient];
             if (allForAmbient.length > 0) {
@@ -4989,9 +5050,24 @@ async function cmdContext(hippoRoot, args, flags) {
         }
     }
 }
+/**
+ * v39: render cross-project inclusions under an explicit header so agents
+ * (and humans) can tell borrowed context from project memory. Only ever
+ * non-empty when the caller passed --cross-project or disabled isolation.
+ */
+function printCrossProjectSection(items) {
+    if (items.length === 0)
+        return;
+    console.log(`\n## Other-project memory (explicitly requested, ${items.length} entries)\n`);
+    for (const item of items) {
+        const originLabel = item.origin === null || item.origin === '' ? 'unknown-origin' : item.origin;
+        const tagStr = item.entry.tags.length > 0 ? ` [${item.entry.tags.join(', ')}]` : '';
+        console.log(`- **[${originLabel}]** ${item.entry.content}${tagStr}`);
+    }
+}
 /** @internal — exported for snapshot tests (tests/cli-context-render-snapshot.test.ts). NOT a stable public API. */
 export function printContextMarkdown(items, totalTokens, framing = 'observe') {
-    const now = new Date();
+    const now = evalNow();
     console.log(`## Project Memory (${items.length} entries, ${totalTokens} tokens)\n`);
     for (const item of items) {
         const e = item.entry;
@@ -5059,11 +5135,9 @@ function autoDetectContext() {
 // ---------------------------------------------------------------------------
 async function cmdEmbed(hippoRoot, flags) {
     requireInit(hippoRoot);
-    if (!isEmbeddingAvailable()) {
-        console.log('Embeddings not available. Install @xenova/transformers to enable:');
-        console.log('  npm install @xenova/transformers');
-        return;
-    }
+    // --status and --reset-physics only read cached state, so they must work even
+    // when no provider key is present (e.g. embedded earlier with a key that was
+    // later removed). The provider-availability gate is deferred to the embed path.
     if (flags['reset-physics']) {
         const entries = loadAllEntries(hippoRoot);
         const embIndex = loadEmbeddingIndex(hippoRoot);
@@ -5093,8 +5167,48 @@ async function cmdEmbed(hippoRoot, flags) {
         }
         return;
     }
+    // Embedding (unlike status/reset) needs an available provider.
+    const embedProvider = (() => {
+        try {
+            return resolveEmbeddingProvider(hippoRoot);
+        }
+        catch (err) {
+            console.error(err instanceof Error ? err.message : String(err));
+            return null;
+        }
+    })();
+    if (!embedProvider) {
+        process.exitCode = 1;
+        return;
+    }
+    if (!embedProvider.isAvailable()) {
+        if (loadConfig(hippoRoot).embeddings.enabled === false) {
+            console.log('Embeddings are disabled in config (embeddings.enabled = false). Set it to true or "auto" to enable.');
+            return;
+        }
+        if (embedProvider.kind === 'local') {
+            console.log('Embeddings not available. Install @xenova/transformers to enable:');
+            console.log('  npm install @xenova/transformers');
+        }
+        else {
+            console.error(`Embedding provider '${embedProvider.kind}' is configured but ${embedProvider.keyEnv} is not set.`);
+            console.error(`Export ${embedProvider.keyEnv}, or set config.embeddings.provider back to 'local'.`);
+            process.exitCode = 1;
+        }
+        return;
+    }
     console.log('Embedding all memories (this may take a moment on first run to download model)...');
-    const count = await embedAll(hippoRoot, resolveEmbeddingModel(hippoRoot));
+    let count;
+    try {
+        count = await embedAll(hippoRoot, resolveEmbeddingModel(hippoRoot));
+    }
+    catch (err) {
+        console.error(`Embedding failed: ${err instanceof Error ? err.message : String(err)}`);
+        const partial = loadEmbeddingIndex(hippoRoot);
+        console.error(`Partial progress saved: ${Object.keys(partial).length} embeddings on disk. Re-run \`hippo embed\` to resume.`);
+        process.exitCode = 1;
+        return;
+    }
     const entriesAfter = loadAllEntries(hippoRoot);
     const embIndexAfter = loadEmbeddingIndex(hippoRoot);
     console.log(`Done. ${count} new embeddings created. ${Object.keys(embIndexAfter).length}/${entriesAfter.length} total.`);
@@ -5126,7 +5240,7 @@ async function cmdWatch(command, hippoRoot) {
     entry.strength = calculateStrength(entry);
     writeEntry(hippoRoot, entry);
     updateStats(hippoRoot, { remembered: 1 });
-    if (isEmbeddingAvailable()) {
+    if (isEmbeddingConfigured(hippoRoot)) {
         embedMemory(hippoRoot, entry).catch(() => { });
     }
     const preview = stderr.trim().slice(0, 80);
@@ -5190,7 +5304,7 @@ function learnFromRepo(hippoRoot, repoPath, days, label) {
         }
         writeEntry(hippoRoot, entry);
         updateStats(hippoRoot, { remembered: 1 });
-        if (isEmbeddingAvailable()) {
+        if (isEmbeddingConfigured(hippoRoot)) {
             embedMemory(hippoRoot, entry).catch(() => { });
         }
         added++;
@@ -5248,6 +5362,54 @@ function cmdImport(hippoRoot, args, flags) {
         extraTags,
         hippoRoot,
     };
+    // K1 vault import: a FOLDER importer that mirrors the connector pattern
+    // (kind='raw' + tag provenance + archiveRaw deletions), so it dispatches
+    // separately from the single-file `importer` function-pointer slot below.
+    // It writes through api.remember/archiveRaw which are tenant-scoped, so we
+    // resolve the tenant and pass it through. --global is not supported for
+    // vault import (the connector raw-archive path is tenant-local).
+    if (flags['vault']) {
+        const folderPath = String(flags['vault']);
+        if (!fs.existsSync(folderPath) || !fs.statSync(folderPath).isDirectory()) {
+            console.error(`Vault folder not found (or not a directory): ${folderPath}`);
+            process.exit(1);
+        }
+        if (useGlobal) {
+            console.error('hippo import --vault does not support --global (raw rows are tenant-local).');
+            process.exit(1);
+        }
+        if (typeof flags['name'] !== 'string' || !flags['name'].trim()) {
+            // --name is the vault identity key for the destructive source-deletion sync;
+            // inferring it from the folder basename let same-basename vaults collide and
+            // clobber each other (codex R10 P2). A valueless `--name` parses as boolean
+            // true, and String(true) === "true" would silently import under vault:true:*
+            // - reject a non-string so it fails fast instead (codex R11 P2).
+            console.error('hippo import --vault requires --name <vault> (a non-empty identity key for source-deletion sync).');
+            process.exit(1);
+        }
+        if (flags['scope'] !== undefined && (typeof flags['scope'] !== 'string' || !flags['scope'].trim())) {
+            // Same valueless-flag trap: a bare `--scope` must not become scope "true".
+            // Example uses the source-prefixed private form, since a bare `private` scope
+            // is NOT treated as private by recall and importVault rejects it (R13 P2).
+            console.error('hippo import --vault: --scope requires a value (e.g. --scope vault:private:notes).');
+            process.exit(1);
+        }
+        const tenantId = resolveTenantId({});
+        const vaultOptions = {
+            ...importOptions,
+            tenantId,
+            name: flags['name'] ? String(flags['name']) : undefined,
+            scope: flags['scope'] ? String(flags['scope']) : undefined,
+        };
+        const vaultResult = importVault(folderPath, vaultOptions);
+        console.log(`\nImport Vault: ${folderPath}${dryRun ? ' (dry run - no writes)' : ''}`);
+        console.log(`  Notes found:           ${vaultResult.total}`);
+        console.log(`  ${dryRun ? 'Would import:         ' : 'Imported:             '}${vaultResult.imported}`);
+        console.log(`  Skipped (unchanged):   ${vaultResult.skipped}`);
+        console.log(`  ${dryRun ? 'Would archive:        ' : 'Archived (removed):   '}${vaultResult.archived ?? 0}`);
+        console.log(`  Store:                 ${hippoRoot}`);
+        return;
+    }
     // Determine which importer to use based on flag
     let filePath;
     let importer;
@@ -5284,7 +5446,7 @@ function cmdImport(hippoRoot, args, flags) {
         importerName = 'File';
     }
     if (!filePath || !importer) {
-        console.error('Usage: hippo import <--chatgpt|--claude|--cursor|--file|--markdown> <path>');
+        console.error('Usage: hippo import <--chatgpt|--claude|--cursor|--file|--markdown|--vault> <path>');
         process.exit(1);
     }
     if (!fs.existsSync(filePath)) {
@@ -5340,15 +5502,17 @@ function cmdPromote(hippoRoot, id) {
 // ---------------------------------------------------------------------------
 // Sync command
 // ---------------------------------------------------------------------------
-function cmdSync(hippoRoot) {
+function cmdSync(hippoRoot, flags = {}) {
     requireInit(hippoRoot);
     const globalRoot = getGlobalRoot();
     if (!isInitialized(globalRoot)) {
         console.log('No global store found. Run `hippo init --global` first.');
         return;
     }
-    const count = syncGlobalToLocal(hippoRoot, globalRoot);
-    console.log(`Synced ${count} global memories into local project.`);
+    // v39: other-project rows are skipped by default; secrets always are.
+    const includeCrossProject = flags['cross-project'] === true;
+    const count = syncGlobalToLocal(hippoRoot, globalRoot, { includeCrossProject });
+    console.log(`Synced ${count} global memories into local project.${includeCrossProject ? '' : ' (other-project rows skipped; use --cross-project to include them)'}`);
 }
 // ---------------------------------------------------------------------------
 // Hook install/uninstall
@@ -5364,7 +5528,11 @@ const HOOKS = {
         content: `
 ## Project Memory (Hippo)
 
-Before starting work, load relevant context:
+Pinned rules and recent writes auto-inject at every prompt via the installed
+UserPromptSubmit hook; never re-run that part manually. At the START of a
+task (not per prompt), additionally load task-specific context: git-aware
+recall over the full store that per-prompt injection does not cover. Also
+run it if the hook is not installed:
 \`\`\`bash
 hippo context --auto --budget 1500
 \`\`\`
@@ -7004,6 +7172,9 @@ Commands:
     --cursor <path>        Import from .cursorrules or .cursor/rules
     --file <path>          Import from any markdown or text file
     --markdown <path>      Import from structured MEMORY.md / AGENTS.md
+    --vault <path>         Import a markdown-vault FOLDER as kind='raw' notes
+                             (Obsidian/Foam/Dendron). Requires --name <vault>.
+                             [--scope <scope>]
     --dry-run              Preview without writing
     --global               Write to global store ($HIPPO_HOME or ~/.hippo/)
     --tag <tag>            Add extra tag (repeatable)
@@ -7598,7 +7769,7 @@ async function main() {
             break;
         }
         case 'sync':
-            cmdSync(hippoRoot);
+            cmdSync(hippoRoot, flags);
             break;
         case 'share': {
             const shareId = args[0];