hippo-memory 1.71.0 → 2.0.0

package/dist/cli/sleep.js

@@ -9,8 +9,7 @@ import * as api from '../api/index.js';
 import { cliApiContext } from './api-context.js';
 import { sleepResultLines } from './sleep-render.js';
 import { errorMessage, log } from '../util/log.js';
-import { closeHippoDb, openHippoDb } from '../db/index.js';
-import { repairOnceOnSleep } from '../sharing/project-merge.js';
+import { teeStdStreams } from '../util/stream-tee.js';
 import { boolFlag, stringFlag } from './flag-values.js';
 import { requireInit, learnFromRepo, runChurnStaleForRepo, skipLearnOnSharedStore } from './shared.js';
 import { printAgentImport } from './print.js';
@@ -25,31 +24,7 @@ export async function cmdSleep(hippoRoot, tenantId, flags) {
         try {
             fs.mkdirSync(path.dirname(logFile), { recursive: true });
             fs.writeFileSync(logFile, `[hippo] ${new Date().toISOString()} consolidating memory...\n`, 'utf8');
-            const origStdoutWrite = process.stdout.write.bind(process.stdout);
-            const origStderrWrite = process.stderr.write.bind(process.stderr);
-            const tee = (chunk) => {
-                try {
-                    const buf = Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk);
-                    fs.appendFileSync(logFile, buf, 'utf8');
-                }
-                catch {
-                    // log failures are non-fatal — still write to the real stream
-                }
-            };
-            // SAFETY: the wrapper forwards chunk, enc and cb untouched to the original write, so it keeps write's contract.
-            process.stdout.write = ((chunk, enc, cb) => {
-                tee(chunk);
-                return origStdoutWrite(chunk, enc, cb);
-            });
-            // SAFETY: the wrapper forwards chunk, enc and cb untouched to the original write, so it keeps write's contract.
-            process.stderr.write = ((chunk, enc, cb) => {
-                tee(chunk);
-                return origStderrWrite(chunk, enc, cb);
-            });
-            restoreStdout = () => {
-                process.stdout.write = origStdoutWrite;
-                process.stderr.write = origStderrWrite;
-            };
+            restoreStdout = teeStdStreams(logFile);
         }
         catch (err) {
             log.warn(`could not open log file ${logFile}: ${errorMessage(err)}`);
@@ -79,10 +54,8 @@ function renderSleepResult(result) {
 }
 /** Fault-isolated: a failed repair warns and runs again next sleep, and never stops the sleep. */
 function repairProjectTagsOnce(hippoRoot, tenantId) {
-    let db;
     try {
-        db = openHippoDb(hippoRoot);
-        const r = repairOnceOnSleep(db, hippoRoot, tenantId);
+        const r = api.repairProjectNamesOnce(cliApiContext(hippoRoot, tenantId));
         if (r === null)
             return;
         const parts = [
@@ -95,10 +68,6 @@ function repairProjectTagsOnce(hippoRoot, tenantId) {
     catch (err) {
         log.warn(`project tag repair skipped, retried next sleep: ${errorMessage(err)}`);
     }
-    finally {
-        if (db)
-            closeHippoDb(db);
-    }
 }
 async function cmdSleepCore(hippoRoot, tenantId, flags) {
     requireInit(hippoRoot);
@@ -111,13 +80,13 @@ async function cmdSleepCore(hippoRoot, tenantId, flags) {
     else if (learn) {
         const config = loadConfig(hippoRoot);
         if (config.autoLearnOnSleep && isGitRepo(process.cwd())) {
-            const { added } = learnFromRepo(hippoRoot, process.cwd(), 1);
+            const { added } = await learnFromRepo(hippoRoot, tenantId, process.cwd(), 1);
             if (added > 0)
                 console.log(`Auto-learned ${added} lessons from today's git commits.`);
         }
         // Opt-in code-churn staleness, off by default (config.churnStaleness.enabled).
         if (config.churnStaleness.enabled && isGitRepo(process.cwd())) {
-            for (const { root, result } of runChurnStaleForRepo(hippoRoot, false)) {
+            for (const { root, result } of runChurnStaleForRepo(hippoRoot, tenantId, false)) {
                 if (result.marked > 0)
                     console.log(`Tagged ${result.marked} memories churn-stale in ${root}.`);
                 if (result.error)
@@ -132,7 +101,7 @@ async function cmdSleepCore(hippoRoot, tenantId, flags) {
         if (finished > 0)
             console.log(`Finished saving ${finished} compaction${finished === 1 ? '' : 's'} left over from earlier sessions.`);
         repairProjectTagsOnce(hippoRoot, tenantId);
-        repairQualityOnceAt(hippoRoot);
+        await repairQualityOnceAt(hippoRoot, tenantId);
     }
     // Phase 2-6: Pure-storage pipeline (consolidate + dedup + audit + share + ambient).
     const ctx = cliApiContext(hippoRoot, tenantId);

package/dist/cli/status.d.ts

@@ -1,14 +1,14 @@
 import { type PhysicsParticle } from '../core/physics.js';
 import { type CommandContext } from './flag-values.js';
-export declare function handleStatus({ hippoRoot }: CommandContext): void;
+export declare function handleStatus({ hippoRoot, tenantId }: CommandContext): void;
 export declare function physicsEnergyText(particles: PhysicsParticle[], gMemory: number): string;
 /** `hippo tokens [--days <n>] [--json] [--global]`: the token ledger per surface, tokens saved by skipped unchanged blocks, and re-read hook tokens.
  * Counts are estimates (characters / 4), the same estimate every budget uses. */
 export declare function handleTokens({ hippoRoot, tenantId, flags }: CommandContext): void;
 /** `hippo failures [--days <n>] [--json] [--global]`: failed tool calls by outcome, and repeats across sessions. */
 export declare function handleFailures({ hippoRoot, tenantId, flags }: CommandContext): void;
-export declare function handleCorrectionLatency({ hippoRoot, flags }: CommandContext): void;
-export declare function handleProvenance({ hippoRoot, flags }: CommandContext): void;
+export declare function handleCorrectionLatency({ hippoRoot, tenantId, flags }: CommandContext): void;
+export declare function handleProvenance({ hippoRoot, tenantId, flags }: CommandContext): void;
 export declare function handleDoctor({ flags }: CommandContext): void;
 export declare function handleSupportBundle({ flags }: CommandContext): void;
 export declare function handleInspect({ hippoRoot, tenantId, args }: CommandContext): Promise<void>;

package/dist/cli/status.js

@@ -1,17 +1,12 @@
 // Read-only report verbs: status, inspect, tokens, failures, provenance, correction latency, doctor and support bundle.
 import { envHomeDir } from '../util/env.js';
-import { evalNow } from '../core/ablation.js';
+import { evalNow, strengthAblation } from '../core/ablation.js';
 import * as path from 'path';
 import * as fs from 'fs';
 import * as os from 'os';
 import { fileURLToPath } from 'node:url';
 import { calculateStrength, calculateRewardFactor, resolveConfidence, Layer } from '../core/memory.js';
-import { loadCorrectionEntries, loadRawEntries } from '../store/report-reads.js';
-import { loadStats } from '../store/index-and-stats.js';
-import { loadStatusCounts } from '../store/candidates.js';
-import { embeddingModelRequiresReindex } from '../store/embeddings/index.js';
-import { resolveEmbeddingProvider } from '../store/embeddings/provider.js';
-import { loadStoredParticles, storedVectorSummary } from '../store/vector-index.js';
+import { resolveEmbeddingProvider } from '../embeddings/provider.js';
 import { computeSystemEnergy, vecNorm } from '../core/physics.js';
 import { loadConfig } from '../core/config.js';
 import { runDoctor, formatDoctor } from '../doctor.js';
@@ -19,10 +14,9 @@ import { buildSupportBundle, TAIL_MAX_LINES } from '../support-bundle.js';
 import { PACKAGE_VERSION } from '../util/version.js';
 import { FAILURE_LOG_RETENTION_DAYS } from '../store/failure-log.js';
 import { getGlobalRoot } from '../sharing/global-store.js';
-import { buildProvenanceCoverage } from './provenance-coverage.js';
-import { buildCorrectionLatency } from './correction-latency.js';
 import * as api from '../api/index.js';
 import { getMemory } from '../api/memories.js';
+import { correctionLatencyReport, embeddingReindexNeeded, provenanceCoverageReport, storeStatus, storedParticles, vectorSummary, } from '../api/status.js';
 import { cliApiContext } from './api-context.js';
 import { errorMessage, log } from '../util/log.js';
 import { printError } from './output.js';
@@ -31,12 +25,12 @@ import { requireInit, resolveAuthRoot } from './shared.js';
 import { fmt } from './print.js';
 import { isJsonObject } from '../util/json.js';
 import { hookStoreRoot } from './hook-runtime.js';
-import { DAY_MS } from '../util/time.js';
+import { DAY_MS, HOUR_MS, MINUTE_MS } from '../util/time.js';
 import { CliExit } from './exit.js';
-export function handleStatus({ hippoRoot }) {
+export function handleStatus({ hippoRoot, tenantId }) {
     requireInit(hippoRoot);
-    const stats = loadStats(hippoRoot);
-    const counts = loadStatusCounts(hippoRoot, evalNow(), 0.2);
+    const ctx = cliApiContext(hippoRoot, tenantId);
+    const { stats, counts } = storeStatus(ctx, evalNow(), 0.2);
     const { byLayer, byConfidence, pinned, atRisk, agedOut, avgStrength } = counts;
     console.log('Hippo Status');
     console.log('---------------------------');
@@ -68,14 +62,14 @@ export function handleStatus({ hippoRoot }) {
     else {
         console.log(`Last sleep:        never`);
     }
-    printEmbeddingStatus(hippoRoot, counts);
-    printPhysicsStatus(hippoRoot);
+    printEmbeddingStatus(ctx, counts);
+    printPhysicsStatus(ctx);
 }
 // Embedding status (provider-aware)
-function printEmbeddingStatus(hippoRoot, counts) {
+function printEmbeddingStatus(ctx, counts) {
     const embedProvider = (() => {
         try {
-            return resolveEmbeddingProvider(hippoRoot);
+            return resolveEmbeddingProvider(ctx.hippoRoot);
         }
         catch {
             // Status reports a bad provider config as "misconfigured" below instead of failing.
@@ -87,7 +81,7 @@ function printEmbeddingStatus(hippoRoot, counts) {
         console.log(`Embeddings:        misconfigured (check embeddings.provider / apiBaseUrl), BM25 only`);
         return;
     }
-    const embeddingsDisabled = loadConfig(hippoRoot).embeddings.enabled === false;
+    const embeddingsDisabled = loadConfig(ctx.hippoRoot).embeddings.enabled === false;
     const embAvail = embedProvider.isAvailable();
     if (embeddingsDisabled) {
         console.log(`Embeddings:        disabled in config (embeddings.enabled = false), BM25 only`);
@@ -103,7 +97,7 @@ function printEmbeddingStatus(hippoRoot, counts) {
     }
     // 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 { ids: embeddedIds, dims } = storedVectorSummary(hippoRoot);
+    const { ids: embeddedIds, dims } = vectorSummary(ctx);
     if (!embAvail && embeddedIds.size === 0)
         return;
     const orphaned = embeddedIds.size - counts.embedded;
@@ -114,23 +108,24 @@ function printEmbeddingStatus(hippoRoot, counts) {
         line += ` (${orphaned} orphaned, run \`hippo embed\` to prune)`;
     console.log(line);
     // No index argument: the check then asks SQLite whether any vector exists instead of loading them.
-    if (embeddingModelRequiresReindex(hippoRoot, embedProvider.id)) {
+    if (embeddingReindexNeeded(ctx, embedProvider.id)) {
         console.log(`                   model changed, run \`hippo embed\` to reindex`);
     }
 }
 // The all-pairs energy sum is quadratic, so a large particle set skips it.
 const PHYSICS_ENERGY_STATUS_MAX = 2000;
 // Physics status
-function printPhysicsStatus(hippoRoot) {
+function printPhysicsStatus(ctx) {
     try {
-        const particles = loadStoredParticles(hippoRoot);
+        const particles = storedParticles(ctx);
         if (particles.length > 0) {
             let sumVelMag = 0;
             for (const p of particles)
                 sumVelMag += vecNorm(p.velocity);
             const avgVelMag = sumVelMag / particles.length;
             console.log('');
-            console.log(`Physics: ${particles.length} particles, ${physicsEnergyText(particles, loadConfig(hippoRoot).physics.G_memory)}, avg vel: ${fmt(avgVelMag, 4)}`);
+            console.log(`Physics: ${particles.length} particles, ` +
+                `${physicsEnergyText(particles, loadConfig(ctx.hippoRoot).physics.G_memory)}, avg vel: ${fmt(avgVelMag, 4)}`);
         }
     }
     catch (err) {
@@ -152,7 +147,7 @@ async function cmdInspect(hippoRoot, tenantId, id) {
         throw new CliExit(1);
     }
     const now = evalNow();
-    const currentStrength = calculateStrength(entry, now);
+    const currentStrength = calculateStrength(entry, now, { ablation: strengthAblation() });
     const lastRetrieved = new Date(entry.last_retrieved);
     const created = new Date(entry.created);
     const ageDays = (now.getTime() - created.getTime()) / DAY_MS;
@@ -171,7 +166,7 @@ async function cmdInspect(hippoRoot, tenantId, id) {
     console.log(`Schema fit:       ${entry.schema_fit}`);
     console.log(`Pinned:           ${entry.pinned}`);
     console.log(`Tags:             ${entry.tags.join(', ') || 'none'}`);
-    const rewardFactor = calculateRewardFactor(entry);
+    const rewardFactor = calculateRewardFactor(entry, strengthAblation());
     const pos = entry.outcome_positive ?? 0;
     const neg = entry.outcome_negative ?? 0;
     const outcomeLabel = pos === 0 && neg === 0
@@ -257,9 +252,9 @@ export function handleFailures({ hippoRoot, tenantId, flags }) {
         console.log(`\n  Repeats: ${summary.repeats} of ${summary.rated} errors first happened in another session.${unrated}`);
     }
 }
-export function handleCorrectionLatency({ hippoRoot, flags }) {
+export function handleCorrectionLatency({ hippoRoot, tenantId, flags }) {
     requireInit(hippoRoot);
-    const report = buildCorrectionLatency(loadCorrectionEntries(hippoRoot));
+    const report = correctionLatencyReport(cliApiContext(hippoRoot, tenantId));
     if (flags['json']) {
         console.log(JSON.stringify(report, null, 2));
     }
@@ -272,11 +267,11 @@ export function handleCorrectionLatency({ hippoRoot, flags }) {
                 return 'n/a';
             if (ms < 1000)
                 return `${ms}ms`;
-            if (ms < 60_000)
+            if (ms < MINUTE_MS)
                 return `${(ms / 1000).toFixed(1)}s`;
-            if (ms < 3_600_000)
-                return `${(ms / 60_000).toFixed(1)}m`;
-            return `${(ms / 3_600_000).toFixed(1)}h`;
+            if (ms < HOUR_MS)
+                return `${(ms / MINUTE_MS).toFixed(1)}m`;
+            return `${(ms / HOUR_MS).toFixed(1)}h`;
         };
         console.log(`Corrections: ${report.count} total (${report.extractionCount} extraction-driven, ${report.manualCount} manual)`);
         console.log(`Latency p50: ${fmt(report.p50Ms)}, p95: ${fmt(report.p95Ms)}, max: ${fmt(report.maxMs)}`);
@@ -286,9 +281,9 @@ export function handleCorrectionLatency({ hippoRoot, flags }) {
         }
     }
 }
-export function handleProvenance({ hippoRoot, flags }) {
+export function handleProvenance({ hippoRoot, tenantId, flags }) {
     requireInit(hippoRoot);
-    const coverage = buildProvenanceCoverage(loadRawEntries(hippoRoot));
+    const coverage = provenanceCoverageReport(cliApiContext(hippoRoot, tenantId));
     if (flags['json']) {
         console.log(JSON.stringify(coverage, null, 2));
     }
@@ -345,8 +340,10 @@ export function handleSupportBundle({ flags }) {
     const kb = Math.round(Buffer.byteLength(json) / 1024);
     console.log(`Wrote ${file} (${kb} KB).`);
     console.log(includeLogs
-        ? `It holds versions, doctor checks, config with secrets removed, store counts, and the last ${TAIL_MAX_LINES} lines of each hippo log with known secret shapes removed. Those log lines can quote memory text. Read it before you attach it to a ticket.`
-        : 'It holds versions, doctor checks, config with secrets removed, store counts and log file names. It never holds memory text. Read it before you attach it to a ticket.');
+        ? `It holds versions, doctor checks, config with secrets removed, store counts, and the last ${TAIL_MAX_LINES} lines of ` +
+            'each hippo log with known secret shapes removed. Those log lines can quote memory text. Read it before you attach it to a ticket.'
+        : 'It holds versions, doctor checks, config with secrets removed, store counts and log file names. It never holds memory text. Read it before you ' +
+            'attach it to a ticket.');
 }
 export async function handleInspect({ hippoRoot, tenantId, args }) {
     const id = args[0];

package/dist/cli/transfer.d.ts

@@ -1,8 +1,8 @@
 import { type CommandContext } from './flag-values.js';
-export declare function handleLearn({ hippoRoot, flags }: CommandContext): void;
-export declare function handleImport({ hippoRoot, tenantId, args, flags }: CommandContext): void;
+export declare function handleLearn({ hippoRoot, tenantId, flags }: CommandContext): Promise<void>;
+export declare function handleImport({ hippoRoot, tenantId, args, flags }: CommandContext): Promise<void>;
 export declare function handleSync({ hippoRoot, flags }: CommandContext): void;
-export declare function handleWatch({ hippoRoot, tenantId, args }: CommandContext): Promise<void>;
+export declare function handleWatch({ hippoRoot, tenantId, args, flags }: CommandContext): Promise<void>;
 export declare function handlePromote({ hippoRoot, tenantId, args }: CommandContext): Promise<void>;
 export declare function handleShare({ hippoRoot, tenantId, args, flags }: CommandContext): Promise<void>;
 export declare function handlePeers({ tenantId, flags }: CommandContext): void;

package/dist/cli/transfer.js

@@ -1,40 +1,57 @@
 // Verbs that move memories in and out: watch, learn, import, export, promote, sync, share and peers.
 import * as path from 'path';
 import * as fs from 'fs';
-import { isInitialized } from '../store/open.js';
-import { loadAllEntries } from '../store/entry-reads.js';
-import { RejectedValueError } from '../store/rejection.js';
-import { embedAll } from '../store/embeddings/index.js';
-import { loadEmbeddingIndex } from '../store/vector-index.js';
+import { isInitialized } from '../core/project-identity.js';
+import { RejectedValueError } from '../core/api-errors.js';
+import { embedCoverage, embedMissingMemories } from '../api/embeddings.js';
 import { captureError, runWatched } from '../learn/autolearn.js';
 import { currentMachine, importAtSessionEnd, importForStore } from '../agent-memories/sync.js';
 import { detailLines } from '../agent-memories/report.js';
 import { getGlobalRoot, initGlobal } from '../sharing/global-store.js';
-import { shareMemory, listPeers, autoShare, transferScore } from '../sharing/share.js';
+import { AUTO_SHARE_MIN_SCORE, shareMemory, listPeers, autoShare, transferScore } from '../sharing/share.js';
 import { syncGlobalToLocal } from '../sharing/global-sync.js';
 import { importChatGPT, importClaude, importCursor, importGenericFile, } from '../importers/sources.js';
 import { importMarkdown } from '../importers/markdown.js';
 import { importVault } from '../importers/vault.js';
 import * as api from '../api/index.js';
-import { getMemory } from '../api/memories.js';
+import { getMemory, listMemories } from '../api/memories.js';
 import * as client from './client.js';
 import { cliApiContext } from './api-context.js';
 import { printError } from './output.js';
 import { errorMessage, log } from '../util/log.js';
 import { requireInit, runViaServerIfAvailable, learnFromRepo } from './shared.js';
 import { fmt } from './print.js';
-import { boolFlag, flagIsTrue, isStringFlag, nonEmptyStringFlag } from './flag-values.js';
+import { boolFlag, flagIsTrue, isStringFlag, nonEmptyStringFlag, numberFlag } from './flag-values.js';
 import { CONTENT_PREVIEW_CHARS, DATE_PREFIX_CHARS } from '../util/token-text.js';
 import { CliExit } from './exit.js';
 const STDERR_PREVIEW_CHARS = 80;
 const MAX_ENTRIES_SHOWN = 10;
 // Watch command
-async function cmdWatch(command, hippoRoot, tenantId) {
-    if (!command) {
-        printError('Usage: hippo watch "<command>"');
+const WATCH_USAGE = 'Usage: hippo watch -- <command> [args...], or hippo watch --shell "<command line>"';
+/** The argv to run and whether a shell parses it: `--shell` takes one command line, anything else is argv as given. */
+function watchedCommand(args, flags) {
+    if (flags['shell'] !== undefined) {
+        const line = nonEmptyStringFlag(flags, 'shell');
+        if (line === undefined) {
+            printError(WATCH_USAGE);
+            throw new CliExit(1);
+        }
+        return { argv: [line], shell: true };
+    }
+    if (args.length === 0) {
+        printError(WATCH_USAGE);
+        throw new CliExit(1);
+    }
+    // A quoted 1.x command line would now run as one program name, so it is refused rather than guessed at.
+    if (args.length === 1 && /\s/.test(args[0])) {
+        printError(`hippo watch: "${args[0]}" is one argument with spaces. Use \`hippo watch -- cmd args\` or \`hippo watch --shell "<command line>"\`.`);
         throw new CliExit(1);
     }
-    const { exitCode, stderr } = await runWatched(command);
+    return { argv: [...args], shell: false };
+}
+async function cmdWatch(argv, shell, hippoRoot, tenantId) {
+    const command = argv.join(' ');
+    const { exitCode, stderr } = await runWatched(argv, undefined, { shell });
     if (exitCode === 0) {
         // Success: no noise
         return;
@@ -48,7 +65,7 @@ async function cmdWatch(command, hippoRoot, tenantId) {
     // A rejection-guard refusal of a failed command's output must not crash the watcher:
     // skip with the message below and still exit with the wrapped command's real exit code.
     try {
-        api.rememberLocally(cliApiContext(hippoRoot, tenantId), {
+        await api.rememberLocally(cliApiContext(hippoRoot, tenantId), {
             content: failure.content,
             tags: failure.tags,
             layer: failure.layer,
@@ -71,13 +88,13 @@ async function cmdWatch(command, hippoRoot, tenantId) {
     throw new CliExit(exitCode);
 }
 // Learn command
-export function handleLearn({ hippoRoot, flags }) {
+export async function handleLearn({ hippoRoot, tenantId, flags }) {
     requireInit(hippoRoot);
     if (!flags['git']) {
         printError('Usage: hippo learn --git [--days <n>] [--repos <paths>]');
         throw new CliExit(1);
     }
-    const days = parseInt(String(flags['days'] ?? '7'), 10);
+    const days = numberFlag(flags, 'days') ?? 7;
     console.log(`Scanning git log for the last ${days} days...`);
     const reposFlag = nonEmptyStringFlag(flags, 'repos');
     if (reposFlag) {
@@ -86,35 +103,41 @@ export function handleLearn({ hippoRoot, flags }) {
         let totalSkipped = 0;
         for (const repo of repos) {
             const label = path.basename(repo);
-            const { added, skipped } = learnFromRepo(hippoRoot, repo, days, label);
+            const { added, skipped } = await learnFromRepo(hippoRoot, tenantId, repo, days, label);
             totalAdded += added;
             totalSkipped += skipped;
         }
         console.log(`Git learn complete: ${totalAdded} new lessons added, ${totalSkipped} duplicates skipped across ${repos.length} repos.`);
     }
     else {
-        const { added, skipped } = learnFromRepo(hippoRoot, process.cwd(), days);
+        const { added, skipped } = await learnFromRepo(hippoRoot, tenantId, process.cwd(), days);
         console.log(`Git learn complete: ${added} new lessons added, ${skipped} duplicates skipped.`);
     }
 }
 // Import command
 /** The rows are saved either way; a failed backfill only delays vectors, so it warns with how many wait and the command that finishes them. */
-function warnBackfillFailed(root, embedCommand, err) {
+function warnBackfillFailed(ctx, embedCommand, err) {
     let waiting;
     try {
-        const vectors = loadEmbeddingIndex(root);
-        waiting = String(loadAllEntries(root).filter((entry) => !Object.hasOwn(vectors, entry.id)).length);
+        const { memoryIds, vectorIds } = embedCoverage(ctx);
+        const embedded = new Set(vectorIds);
+        waiting = String(memoryIds.filter((id) => !embedded.has(id)).length);
     }
     catch (countErr) {
         waiting = `an unknown number of (count failed: ${errorMessage(countErr)})`;
     }
     log.warn(`import: embedding backfill failed (${errorMessage(err)}); ${waiting} rows have no vector; run '${embedCommand}' to backfill`);
 }
+/** Batch-embed freshly imported rows. The floating promise is deliberate: libuv keeps the process alive until it settles, and awaiting
+ *  would block the CLI on model load; `hippo embed` is the backstop if interrupted. */
+function backfillVectors(ctx, embedCommand) {
+    void embedMissingMemories(ctx).catch((err) => warnBackfillFailed(ctx, embedCommand, err));
+}
 function warnRedacted(count) {
     if (count)
         printError(`Warning: secret-shaped text was redacted from ${count} imported ${count === 1 ? 'entry' : 'entries'} before storing`);
 }
-export function handleImport({ hippoRoot, tenantId, args, flags }) {
+export async function handleImport({ hippoRoot, tenantId, args, flags }) {
     const useGlobal = boolFlag(flags, 'global');
     const dryRun = boolFlag(flags, 'dry-run');
     const extraTags = Array.isArray(flags['tag'])
@@ -140,8 +163,8 @@ export function handleImport({ hippoRoot, tenantId, args, flags }) {
     // Vault import is a FOLDER importer that dispatches apart from the single-file slot below; it writes through tenant-scoped api calls,
     // so the tenant is resolved and passed through. --global is unsupported (the connector raw-archive path is tenant-local).
     if (flags['vault'])
-        return importVaultFolder(hippoRoot, tenantId, flags, importOptions, useGlobal, dryRun);
-    importFromFile(targetRoot, args, flags, { importOptions, useGlobal, dryRun });
+        return await importVaultFolder(hippoRoot, tenantId, flags, importOptions, useGlobal, dryRun);
+    importFromFile(targetRoot, args, flags, { importOptions, useGlobal, dryRun, tenantId });
 }
 // Determine which importer to use based on flag
 function pickImporter(args, flags) {
@@ -161,7 +184,7 @@ function pickImporter(args, flags) {
     return { filePath: undefined, importer: undefined, importerName: '' };
 }
 function importFromFile(targetRoot, args, flags, options) {
-    const { importOptions, useGlobal, dryRun } = options;
+    const { importOptions, useGlobal, dryRun, tenantId } = options;
     const { filePath, importer, importerName } = pickImporter(args, flags);
     if (!filePath || !importer) {
         printError('Usage: hippo import <--chatgpt|--claude|--cursor|--file|--markdown|--vault> <path>, or hippo import --agents [--dry-run]');
@@ -172,10 +195,9 @@ function importFromFile(targetRoot, args, flags, options) {
         throw new CliExit(1);
     }
     const result = importer(filePath, importOptions);
-    // Batch-embed newly imported rows in one pass (the importers' writeEntry sites don't embed). The floating promise is deliberate: libuv keeps the process
-    // alive until it settles; do not await it, that would block the CLI on model load. `hippo embed` is the backstop if interrupted.
+    // The importers' writeEntry sites don't embed, so the new rows are embedded here in one pass.
     if (!dryRun && result.imported >= 1) {
-        void embedAll(targetRoot).catch((err) => warnBackfillFailed(targetRoot, useGlobal ? 'hippo embed --global' : 'hippo embed', err));
+        backfillVectors(cliApiContext(targetRoot, tenantId), useGlobal ? 'hippo embed --global' : 'hippo embed');
     }
     const storeLabel = useGlobal ? `global (${getGlobalRoot()})` : targetRoot;
     printFileImportSummary(result, importerName, filePath, storeLabel, dryRun);
@@ -216,7 +238,7 @@ function importAgentMemories(hippoRoot, useGlobal, dryRun) {
     for (const warning of report.warnings)
         printError(`hippo: agent memories: ${warning}`);
 }
-function importVaultFolder(hippoRoot, tenantId, flags, importOptions, useGlobal, dryRun) {
+async function importVaultFolder(hippoRoot, tenantId, flags, importOptions, useGlobal, dryRun) {
     const folderPath = String(flags['vault']);
     checkVaultArgs(folderPath, flags, useGlobal);
     const vaultOptions = {
@@ -225,8 +247,8 @@ function importVaultFolder(hippoRoot, tenantId, flags, importOptions, useGlobal,
         name: flags['name'] ? String(flags['name']) : undefined,
         scope: flags['scope'] ? String(flags['scope']) : undefined,
     };
-    const vaultResult = importVault(folderPath, vaultOptions);
-    printVaultSummary(vaultResult, folderPath, hippoRoot, dryRun);
+    const vaultResult = await importVault(folderPath, vaultOptions);
+    printVaultSummary(vaultResult, folderPath, cliApiContext(hippoRoot, tenantId), dryRun);
 }
 function checkVaultArgs(folderPath, flags, useGlobal) {
     if (!fs.existsSync(folderPath) || !fs.statSync(folderPath).isDirectory()) {
@@ -250,7 +272,7 @@ function checkVaultArgs(folderPath, flags, useGlobal) {
         throw new CliExit(1);
     }
 }
-function printVaultSummary(vaultResult, folderPath, hippoRoot, dryRun) {
+function printVaultSummary(vaultResult, folderPath, ctx, dryRun) {
     console.log(`\nImport Vault: ${folderPath}${dryRun ? ' (dry run - no writes)' : ''}`);
     console.log(`  Notes found:           ${vaultResult.total}`);
     console.log(`  ${dryRun ? 'Would import:         ' : 'Imported:             '}${vaultResult.imported}`);
@@ -260,12 +282,10 @@ function printVaultSummary(vaultResult, folderPath, hippoRoot, dryRun) {
     }
     warnRedacted(vaultResult.redacted);
     console.log(`  ${dryRun ? 'Would archive:        ' : 'Archived (removed):   '}${vaultResult.archived ?? 0}`);
-    console.log(`  Store:                 ${hippoRoot}`);
-    // Batch producer, same contract as the single-file import above: vault rows write through api.remember (which never embeds), so backfill them here.
-    // The floating promise is deliberate; see the single-file site.
-    if (!dryRun && vaultResult.imported >= 1) {
-        void embedAll(hippoRoot).catch((err) => warnBackfillFailed(hippoRoot, 'hippo embed', err));
-    }
+    console.log(`  Store:                 ${ctx.hippoRoot}`);
+    // Vault rows write through api.remember, which never embeds, so backfill them as the single-file import does.
+    if (!dryRun && vaultResult.imported >= 1)
+        backfillVectors(ctx, 'hippo embed');
 }
 // Promote command
 function cmdPromote(hippoRoot, tenantId, id) {
@@ -296,11 +316,12 @@ export function handleSync({ hippoRoot, flags }) {
     // v39: other-project rows are skipped by default; secrets always are.
     const includeCrossProject = flagIsTrue(flags, 'cross-project');
     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)'}`);
+    console.log(`Synced ${count} global memories into local project.${includeCrossProject ? '' : ' (other-project rows skipped; use --cross-project to ' +
+        'include them)'}`);
 }
-export async function handleWatch({ hippoRoot, tenantId, args }) {
-    const watchCmd = args.join(' ').trim();
-    await cmdWatch(watchCmd, hippoRoot, tenantId);
+export async function handleWatch({ hippoRoot, tenantId, args, flags }) {
+    const { argv, shell } = watchedCommand(args, flags);
+    await cmdWatch(argv, shell, hippoRoot, tenantId);
 }
 export async function handlePromote({ hippoRoot, tenantId, args }) {
     const id = args[0];
@@ -327,7 +348,7 @@ export async function handleShare({ hippoRoot, tenantId, args, flags }) {
     if (shareId === '--auto' || flags['auto']) {
         // Auto-share mode
         requireInit(hippoRoot);
-        const minScore = parseFloat(String(flags['min-score'] ?? '0.6'));
+        const minScore = numberFlag(flags, 'min-score') ?? AUTO_SHARE_MIN_SCORE;
         const dryRun = boolFlag(flags, 'dry-run');
         const results = autoShare(hippoRoot, { minScore, dryRun, tenantId });
         if (results.length === 0) {
@@ -393,7 +414,7 @@ export function handleExport({ hippoRoot, tenantId, args, flags }) {
     requireInit(hippoRoot);
     const format = String(flags['format'] || 'json');
     const outputPath = args[0] || null;
-    const entries = loadAllEntries(hippoRoot, tenantId);
+    const entries = listMemories(cliApiContext(hippoRoot, tenantId));
     let output;
     if (format === 'markdown' || format === 'md') {
         output = entries.map(e => {