hippo-memory 1.68.0 → 1.70.0

package/dist/cli/shared.js

@@ -1,62 +1,20 @@
-// Helpers two or more CLI verbs use, split from cli.ts so a verb can move to its own file without importing cli.ts.
+// Store and server helpers the CLI verbs share: audit events, init checks, server routing, git learning and the auth root.
 // This module must never import cli.ts.
-import { envApiKey, envClaudeCodeSessionId, envHippoSessionId, envRequireServer } from '../env.js';
-import * as path from 'path';
-import * as fs from 'fs';
-import { execFileSync, execSync } from 'child_process';
-import { installJsonHooks } from '../hooks/json-hooks.js';
-import { CODEX_TRUST_LINE } from '../hooks/shared.js';
-import { confidenceLabel } from '../memory.js';
-import { getHippoRoot, isInitialized } from '../store/open.js';
-import { explainMatch } from '../search/explain.js';
-import { isSharedStore } from '../config.js';
-import { openHippoDb, closeHippoDb, isSqliteBusy, noteStoreBusy, runWithRequestStores, HOOK_DB_WAIT_MS } from '../db.js';
-import { withLedgerDb } from '../ledger-db.js';
-import { sessionPilotArm } from '../pilot-arm.js';
-import { hookPayloadSessionId, hookPayloadString, isSubagentPayload, recordTokenUse } from '../token-ledger.js';
-import { importAtSessionEnd, currentMachine } from '../agent-memories/sync.js';
-import { summaryLine } from '../agent-memories/report.js';
-import { detectChurnStale } from '../invalidation.js';
-import { resolveProjectIdentity } from '../project-identity.js';
-import { getGlobalRoot, initGlobal } from '../shared.js';
-import { DAILY_TASK_NAME, buildDailyRunnerCommand, buildSchtasksCreateArgs, buildWindowsTaskRun } from '../scheduler.js';
-import { sanitizeLogMessage } from '../capture/compact.js';
-import { appendAuditEvent, reportAuditWriteFailure } from '../audit.js';
-import * as client from '../client.js';
-import { detectServer, removePidfileIfOwned } from '../server-detect.js';
-import { resolveTenantId } from '../tenant.js';
-import { adminActor, learn, CLI_LEARN } from '../api.js';
-import { snapshotText, sessionTrailText, handoffText } from '../context-render.js';
-import { errorMessage, log } from '../log.js';
+import { envApiKey, envRequireServer } from '../util/env.js';
+import { execFileSync } from 'child_process';
+import { isSharedStore } from '../core/config.js';
+import { isInitialized } from '../store/open.js';
+import { detectChurnStale } from '../learn/invalidation.js';
+import { resolveProjectIdentity } from '../core/project-identity.js';
+import { getGlobalRoot, initGlobal } from '../sharing/shared.js';
+import { reportAuditWriteFailure } from '../store/audit.js';
+import { sqliteSyncStore } from '../store/sqlite/store.js';
+import * as client from './client.js';
+import { detectServer, removePidfileIfOwned } from '../server/server-detect.js';
+import { resolveTenantId } from '../store/tenant.js';
+import { adminActor, learn, CLI_LEARN } from '../api/index.js';
+import { errorMessage, log } from '../util/log.js';
 import { printError } from './output.js';
-export function parseLimitFlag(value) {
-    if (!value)
-        return Infinity;
-    const parsed = parseInt(String(value), 10);
-    return Number.isFinite(parsed) && parsed >= 1 ? parsed : Infinity;
-}
-export function parseCountFlag(value) {
-    if (!value || value === true || Array.isArray(value))
-        return 0;
-    const parsed = parseInt(String(value), 10);
-    return Number.isFinite(parsed) && parsed >= 1 ? parsed : 0;
-}
-export function parseBudgetFlag(value, fallback) {
-    if (value === undefined)
-        return fallback;
-    // A value-less flag and a junk value are different typos; the --hops guard already splits them.
-    if (typeof value !== 'string') {
-        printError('--budget requires an integer value (e.g. --budget 1500).');
-        process.exit(1);
-    }
-    // Number(), like the --hops guard: parseInt('12abc') is 12, silently accepting what this message rejects.
-    const parsed = Number(value);
-    if (!Number.isInteger(parsed) || parsed < 0) {
-        printError(`Invalid --budget: "${value}". Must be a non-negative integer.`);
-        process.exit(1);
-    }
-    return parsed;
-}
 /**
  * Emit an audit event against `hippoRoot`'s db. Opens its own short-lived
  * connection so callers don't have to thread a db handle. Swallows all errors
@@ -64,19 +22,13 @@ export function parseBudgetFlag(value, fallback) {
  */
 export function emitCliAudit(hippoRoot, op, targetId, metadata) {
     try {
-        const db = openHippoDb(hippoRoot);
-        try {
-            appendAuditEvent(db, {
+        sqliteSyncStore(hippoRoot).appendAuditEvents([{
                 tenantId: resolveTenantId({}),
                 actor: 'cli',
                 op,
                 targetId,
                 metadata,
-            });
-        }
-        finally {
-            closeHippoDb(db);
-        }
+            }]);
     }
     catch (error) {
         // Best effort: the command already did its work.
@@ -102,7 +54,7 @@ export function runChurnStaleForRepo(hippoRoot, dryRun) {
             return { root, result: detectChurnStale(root, repoRoot, { tenantId, projectName, legacyName, dryRun }) };
         }
         catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
+            const message = errorMessage(err);
             return { root, result: { checked: 0, marked: 0, alreadyMarked: 0, skippedPinned: [], dryRun, preview: [], error: message } };
         }
     });
@@ -166,59 +118,6 @@ export async function runViaServerIfAvailable(hippoRoot, httpFn) {
         throw err;
     }
 }
-export function fmt(n, digits = 2) {
-    return n.toFixed(digits);
-}
-// What `hippo recall` prints for one result; the budget prices this same text.
-export function recallEntryText(r, query, showWhy, isGlobal) {
-    const e = r.entry;
-    const label = confidenceLabel(e);
-    const confLabel = label.warn ? `[${label.text}] ⚠️` : `[${label.text}]`;
-    const bars = Math.round(e.strength * 10);
-    const graphMark = r.graphVia ? ` [graph: ${r.graphVia.hops}hop ${r.graphVia.relType}]` : '';
-    const lines = [
-        `--- ${e.id} [${e.layer}] ${confLabel}${isGlobal ? ' [global]' : ''}${e.superseded_by ? ' [superseded]' : ''}${graphMark} score=${fmt(r.score, 3)} strength=${fmt(e.strength)}`,
-        `    [${'█'.repeat(bars)}${'░'.repeat(10 - bars)}] tags: ${e.tags.join(', ') || 'none'} | retrieved: ${e.retrieval_count}x`,
-    ];
-    if (showWhy) {
-        const explanation = explainMatch(query, r);
-        lines.push(`    source:${isGlobal ? ' [global]' : ' [local]'} | layer: [${e.layer}] | confidence: [${label.text}]`, `    reason: ${explanation.reason}`);
-        const env = explanation.envelope;
-        if (env) {
-            lines.push(`    kind: ${env.kind}`);
-            if (env.scope)
-                lines.push(`    scope: ${env.scope}`);
-            if (env.owner)
-                lines.push(`    owner: ${env.owner}`);
-            if (env.artifact_ref)
-                lines.push(`    artifact_ref: ${env.artifact_ref}`);
-            if (env.session_id)
-                lines.push(`    session_id: ${env.session_id}`);
-            lines.push(`    confidence: ${env.confidence}`);
-        }
-        // The recall trace, e.g. "ranking: base 0.420 -> interference x0.30 -> 0.126 -> goal-boost x1.50 -> 0.189".
-        if (r.rerankTrace && r.rerankTrace.length > 0) {
-            const parts = [`base ${fmt(r.rerankTrace[0].scoreBefore, 3)}`];
-            for (const step of r.rerankTrace) {
-                parts.push(`${step.stage}${step.multiplier !== undefined ? ` x${fmt(step.multiplier, 2)}` : ''}`, fmt(step.scoreAfter, 3));
-            }
-            lines.push(`    ranking: ${parts.join(' -> ')}`);
-        }
-    }
-    lines.push('', e.content, '');
-    return lines.join('\n');
-}
-export function recallHeading(entries, tokens, query) {
-    return `Found ${entries} memories (${tokens} tokens) for: "${query}"\n`;
-}
-/** One line when an agent memory import moved anything; its warnings go to stderr. */
-export function printAgentImport(report, indent = '   ') {
-    const line = summaryLine(report);
-    if (line !== null)
-        console.log(`${indent}${line}`);
-    for (const warning of report.warnings)
-        printError(`hippo: agent memories: ${warning}`);
-}
 /** True, after one line, on a shared store: this account's commits and agent notes are not its members' memories. */
 export function skipLearnOnSharedStore(hippoRoot) {
     if (!isSharedStore(hippoRoot))
@@ -226,240 +125,6 @@ export function skipLearnOnSharedStore(hippoRoot) {
     console.log("Shared store: skipped learning from this account's git commits and coding agents' own memories.");
     return true;
 }
-/** Adds hippo's two Codex hooks and says what changed; each install ends on the trust reminder, since Codex skips an untrusted hook. */
-export function installCodexMemoryHooks(indent) {
-    const result = installJsonHooks('codex');
-    if (result.invalidJson) {
-        console.log(`${indent}WARNING: ${result.settingsPath} is not a hooks file hippo can merge into; fix it, then run \`hippo hook install codex\`.`);
-        return;
-    }
-    const added = [
-        result.installedUserPromptSubmit ? 'UserPromptSubmit' : '',
-        result.installedCompactResume ? 'SessionStart(compact)' : '',
-    ].filter(Boolean);
-    console.log(added.length > 0
-        ? `${indent}Installed hippo's Codex memory hooks (${added.join(', ')}) in ${result.settingsPath}`
-        : `${indent}hippo's Codex memory hooks already in ${result.settingsPath}`);
-    console.log(`${indent}${CODEX_TRUST_LINE}`);
-}
-/** The one line init, hook install, hook uninstall and setup print when Claude Code's settings.json is not JSON hippo can edit and so was left unchanged; true when it printed. */
-export function warnClaudeSettingsUnusable(result, indent, action = 'install') {
-    if (!result.invalidJson)
-        return false;
-    console.log(`${indent}WARNING: ${result.settingsPath} is not a JSON object hippo can merge into, so it was left unchanged; fix it, then run \`hippo hook ${action} claude-code\`.`);
-    return true;
-}
-/**
- * Set up a machine-level daily runner that sweeps all registered Hippo
- * workspaces.
- * Linux/macOS: writes to user crontab.
- * Windows: creates a scheduled task.
- * Skips if already installed.
- */
-export function setupDailySchedule(globalRoot) {
-    const runnerDir = path.resolve(globalRoot);
-    // Reject paths with characters that could break shell/crontab quoting
-    // (backslash is normal on Windows, only dangerous in Unix shell/crontab)
-    const unsafeChars = process.platform === 'win32' ? /["`$%\n\r]/ : /["`$\n\r\\]/;
-    if (unsafeChars.test(runnerDir)) {
-        console.log(`   Skipping schedule: runner path contains unsafe characters.`);
-        return;
-    }
-    const isWindows = process.platform === 'win32';
-    const taskName = DAILY_TASK_NAME;
-    const cmd = buildDailyRunnerCommand(runnerDir);
-    if (isWindows) {
-        // Check if task already exists
-        try {
-            const existing = execSync(`schtasks /query /tn "${taskName}" 2>nul`, { encoding: 'utf-8', windowsHide: true });
-            if (existing.includes(taskName)) {
-                return; // already scheduled
-            }
-        }
-        catch {
-            // Task doesn't exist, create it
-        }
-        try {
-            execFileSync('schtasks', buildSchtasksCreateArgs(taskName, cmd), { stdio: 'pipe', windowsHide: true });
-            console.log(`   Scheduled machine-level daily runner (6:15am) via Task Scheduler: ${taskName}`);
-        }
-        catch {
-            // No admin rights or schtasks unavailable, fall back to printing instructions
-            console.log(`   To schedule the machine-level daily runner, run:`);
-            console.log(`   schtasks /create /tn "${taskName}" /tr "${buildWindowsTaskRun(cmd).replace(/"/g, '\\"')}" /sc daily /st 06:15`);
-        }
-    }
-    else {
-        // Unix: check crontab for existing entry
-        const marker = `# hippo:${taskName}`;
-        try {
-            const existing = execSync('crontab -l 2>/dev/null', { encoding: 'utf-8', windowsHide: true });
-            if (existing.includes(marker)) {
-                return; // already scheduled
-            }
-            const cronLine = `15 6 * * * ${cmd} ${marker}`;
-            const newCrontab = existing.trimEnd() + '\n' + cronLine + '\n';
-            execSync('crontab -', { input: newCrontab, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
-            console.log(`   Scheduled machine-level daily runner (6:15am) via crontab`);
-        }
-        catch {
-            // No crontab or no permission: print the line for the user to add by hand.
-            const cronLine = `15 6 * * * ${cmd}`;
-            console.log(`   To schedule the machine-level daily runner, add to crontab (crontab -e):`);
-            console.log(`   ${cronLine}`);
-        }
-    }
-}
-export function parseAsOfFlag(flags) {
-    const asOf = typeof flags['as-of'] === 'string' ? flags['as-of'] : undefined;
-    if (asOf !== undefined && Number.isNaN(new Date(asOf).getTime())) {
-        printError(`Error: --as-of value "${asOf}" is not a valid ISO date (e.g. 2026-04-22 or 2026-04-22T12:00:00Z).`);
-        process.exit(1);
-    }
-    return asOf;
-}
-/** --physics forces physics, --classic forces BM25+cosine, else physics unless the config turns it off. */
-export function engineFlags(flags, config) {
-    return {
-        usePhysics: Boolean(flags['physics']) || (!flags['classic'] && config.physics.enabled !== false),
-        physicsConfig: config.physics,
-        mmr: !flags['no-mmr'] && config.mmr.enabled,
-        mmrLambda: flags['mmr-lambda'] !== undefined ? parseFloat(String(flags['mmr-lambda'])) : config.mmr.lambda,
-        localBump: flags['equal-sources']
-            ? 1.0
-            : flags['local-bump'] !== undefined ? parseFloat(String(flags['local-bump'])) : config.search.localBump,
-    };
-}
-/**
- * Detached worker that counts re-reads, runs sleep, then capture. Invoked via the internal
- * `__session-end-worker` subcommand (not user-facing). Failures in one stage
- * do not block the other.
- */
-/** A folder without its own store never sleeps at session end, so its project's agent notes go to the global store here. */
-export function logSessionEndImport(logFile, transcriptPath) {
-    try {
-        const report = importAtSessionEnd(process.cwd(), transcriptPath, { machine: currentMachine() });
-        const line = summaryLine(report);
-        if (line !== null)
-            appendSessionEndCloseLog(logFile, line);
-        for (const warning of report.warnings)
-            appendSessionEndCloseLog(logFile, `agent memories: ${warning}`);
-    }
-    catch (err) {
-        appendSessionEndCloseLog(logFile, `agent memory import failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
-}
-/**
- * Best-effort log line for the snapshot-close step in
- * `cmdSessionEndWorker`. `cmdSleep`/`cmdCapture` each tee console output to
- * `logFile` only for their own duration (the tee is restored before this
- * runs), so a plain `console.log` here would be silently discarded under
- * the detached worker's `stdio: 'ignore'` — write straight to the file
- * instead, matching capture.ts's `appendPreCompactLog` convention.
- */
-export function appendSessionEndCloseLog(logFile, message, opts = {}) {
-    if (!logFile)
-        return;
-    try {
-        fs.mkdirSync(path.dirname(logFile), { recursive: true });
-        // sanitizeLogMessage: `message` interpolates the payload-controlled
-        // session_id — same log-forgery guard appendPreCompactLog applies.
-        const write = opts.startFresh ? fs.writeFileSync : fs.appendFileSync;
-        write(logFile, `[hippo] ${new Date().toISOString()} ${sanitizeLogMessage(message)}\n`, 'utf8');
-    }
-    catch {
-        // Best-effort only — never let a log-write failure surface as an error.
-    }
-}
-export function printActiveTaskSnapshot(snapshot) {
-    console.log(snapshotText(snapshot));
-}
-export function printSessionEvents(events) {
-    console.log(events.length === 0 ? 'No session events found.' : sessionTrailText(events));
-}
-export function printHandoff(handoff) {
-    console.log(handoffText(handoff));
-}
-// parseArgs turns a value-less flag into `true`; refuse rather than silently
-// stringifying it (String(true) === 'true'), mirroring cmdHandoff's guard.
-export function cardStringFlag(flags, key) {
-    const v = flags[key];
-    if (v === undefined)
-        return undefined;
-    if (v === true || v === false || Array.isArray(v)) {
-        printError(`--${key} requires a value`);
-        process.exit(1);
-    }
-    return v.trim();
-}
-// Claude Code exports its own session var, not ours; without the fallback agent-run recalls trace with no session.
-export function hostSessionId() {
-    return envHippoSessionId() ?? envClaudeCodeSessionId();
-}
-/**
- * Compaction drops the pinned blocks the per-prompt hook injected
- * earlier, so record a `reset` for the payload's session and the next prompt
- * injects again even if nothing changed. `requiredSource` limits it to hook
- * payloads with that `source` (SessionStart fires for other reasons too).
- * Best-effort and silent: a malformed payload records nothing.
- */
-export function resetHookInjection(hippoRoot, stdinText, requiredSource) {
-    const sessionId = hookPayloadSessionId(stdinText, requiredSource);
-    // A sub-agent's compaction leaves its parent's context, and the blocks in it, as they were.
-    if (sessionId === null || isSubagentPayload(stdinText))
-        return;
-    withLedgerDb(hippoRoot, (db) => recordTokenUse(db, {
-        tenantId: resolveTenantId({}), sessionId, surface: 'hook', event: 'reset', items: 0, tokens: 0,
-    }));
-}
-/**
- * Run `fn` with console.log captured; returns the captured lines joined by
- * newlines (what the same calls would have printed, minus the final newline).
- */
-export function captureConsole(fn) {
-    const lines = [];
-    const realLog = console.log;
-    console.log = (...parts) => { lines.push(parts.map(String).join(' ')); };
-    try {
-        fn();
-    }
-    finally {
-        console.log = realLog;
-    }
-    return lines.join('\n');
-}
-/**
- * The store a Claude Code hook writes to: the project store when there is
- * one, else an existing global store, else the project path (which the hook
- * then skips, since hooks fire in every directory and must not create one).
- * Pre-compact and compact-resume must agree, or a snapshot saved to one store
- * is looked for in the other.
- */
-export function hookStoreRoot(hippoRoot) {
-    if (isInitialized(hippoRoot))
-        return hippoRoot;
-    const globalRoot = getGlobalRoot();
-    return isInitialized(globalRoot) ? globalRoot : hippoRoot;
-}
-/** `--runtime copilot`, or `--format copilot` on `hippo context`, marks a Copilot hook: the flag decides, never the payload. */
-export function hookRuntime(flags) {
-    return flags['runtime'] === 'copilot' || flags['format'] === 'copilot' ? 'copilot' : 'claude-code';
-}
-/** A Copilot hook's project root, from the payload's `cwd`, since VS Code runs user-level hooks in the home folder; other runtimes keep `hippoRoot`. */
-export function payloadCwdRoot(hippoRoot, stdinText, runtime) {
-    const cwd = runtime === 'copilot' ? hookPayloadString(stdinText, 'cwd') : null;
-    if (cwd === null || cwd.trim() === '')
-        return hippoRoot;
-    try {
-        // Moving, not just re-rooting, keeps project identity, scope, handoff evidence and the session-end worker on that folder too.
-        process.chdir(cwd);
-    }
-    catch (err) {
-        log.warn(`hippo: payload cwd ${cwd} is not usable, so the hook stays in ${process.cwd()}: ${errorMessage(err)}`);
-        return hippoRoot;
-    }
-    return getHippoRoot(process.cwd());
-}
 export function learnFromRepo(hippoRoot, repoPath, days, label) {
     const prefix = label ? `[${label}] ` : '';
     const ctx = { hippoRoot, tenantId: resolveTenantId({}), actor: adminActor('cli') };
@@ -490,20 +155,4 @@ export function resolveAuthRoot(hippoRoot, flags) {
     requireInit(hippoRoot);
     return hippoRoot;
 }
-/** Hook commands share one handle per store and wait at most HOOK_DB_WAIT_MS for a lock; a store still busy after that skips the hook's work with one warning, exit 0. */
-export async function runHookWithStores(fn) {
-    try {
-        return await runWithRequestStores(fn, { busyWaitMs: HOOK_DB_WAIT_MS, failFastWhenBusy: true });
-    }
-    catch (error) {
-        if (!isSqliteBusy(error))
-            throw error;
-        noteStoreBusy('hook skipped');
-        return undefined;
-    }
-}
-/** Whether this session sits in the pilot's holdout arm; off at rate 0 and with no session id. */
-export function inPilotHoldout(hippoRoot, tenantId, sessionId, write) {
-    return sessionPilotArm(hippoRoot, tenantId, sessionId, write) === 'holdout';
-}
 //# sourceMappingURL=shared.js.map

package/dist/cli/slack.d.ts

@@ -1,2 +1,3 @@
-export declare function cmdSlack(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
+import { type CliFlags } from './flag-values.js';
+export declare function cmdSlack(hippoRoot: string, args: string[], flags: CliFlags): Promise<void>;
 //# sourceMappingURL=slack.d.ts.map

package/dist/cli/slack.js

@@ -1,19 +1,20 @@
 // `hippo slack`: backfill, dead-letter queue and workspace registry for the Slack connector.
-import { envSlackBotToken, envSlackSigningSecret, envSlackTeamId } from '../env.js';
-import { openHippoDb, closeHippoDb } from '../db.js';
-import * as api from '../api.js';
-import { resolveTenantId } from '../tenant.js';
-import { listDlq, replayDlqEntry } from '../connectors/slack/dlq.js';
+import { envSlackBotToken, envSlackSigningSecret, envSlackTeamId } from '../util/env.js';
+import * as api from '../api/index.js';
+import { resolveTenantId } from '../store/tenant.js';
+import { listDlq } from '../connectors/dlq.js';
+import { replayDlqEntry, slackDlq } from '../connectors/slack/dlq.js';
 import { backfillChannel } from '../connectors/slack/backfill.js';
 import { slackHistoryFetcher } from '../connectors/slack/web-client.js';
 import { addWorkspace as addSlackWorkspace, listWorkspaces as listSlackWorkspaces, removeWorkspace as removeSlackWorkspace, } from '../connectors/slack/workspaces.js';
 import { printError } from './output.js';
 import { printSlackBackfillUsage, printSlackWorkspacesUsage } from './usage.js';
+import { stringFlag } from './flag-values.js';
 // ---------------------------------------------------------------------------
 // Slack subcommands (`hippo slack backfill` / `hippo slack dlq list`)
 // ---------------------------------------------------------------------------
 function cmdSlackBackfill(hippoRoot, flags) {
-    const channel = typeof flags['channel'] === 'string' ? flags['channel'] : undefined;
+    const channel = stringFlag(flags, 'channel');
     if (!channel) {
         printSlackBackfillUsage();
         process.exit(1);
@@ -27,7 +28,7 @@ function cmdSlackBackfill(hippoRoot, flags) {
     // --since is advisory in V1: the slack_cursors row drives resume, so the
     // backfill loop always picks up where it last left off. Honoured-by-cursor
     // semantics keep idempotency clean.
-    const sinceIso = flags['since'];
+    const sinceIso = stringFlag(flags, 'since');
     void sinceIso;
     const fetcher = slackHistoryFetcher(token);
     const ctx = {
@@ -49,19 +50,12 @@ function cmdSlackBackfill(hippoRoot, flags) {
     });
 }
 function cmdSlackDlqList(hippoRoot, _flags) {
-    const db = openHippoDb(hippoRoot);
-    try {
-        const tenantId = resolveTenantId({});
-        const items = listDlq(db, { tenantId });
-        for (const it of items) {
-            console.log(`${it.id}\t${it.receivedAt}\t${it.error}`);
-        }
-    }
-    finally {
-        closeHippoDb(db);
+    const items = listDlq(slackDlq, hippoRoot, { tenantId: resolveTenantId({}) });
+    for (const it of items) {
+        console.log(`${it.id}\t${it.receivedAt}\t${it.error}`);
     }
 }
-function cmdSlackDlqReplay(hippoRoot, args, flags) {
+async function cmdSlackDlqReplay(hippoRoot, args, flags) {
     const idArg = args[2];
     if (!idArg) {
         printError('Usage: hippo slack dlq replay <id> [--force]');
@@ -73,7 +67,7 @@ function cmdSlackDlqReplay(hippoRoot, args, flags) {
         process.exit(1);
     }
     const force = flags.force === true;
-    const result = replayDlqEntry({ hippoRoot }, id, {
+    const result = await replayDlqEntry({ hippoRoot }, id, {
         force,
         signingSecret: envSlackSigningSecret(),
     });
@@ -84,57 +78,39 @@ function cmdSlackDlqReplay(hippoRoot, args, flags) {
     console.log(`replay ok: status=${result.status} memory_id=${result.memoryId ?? '(none)'} retry_count=${result.retryCount}`);
 }
 function cmdSlackWorkspacesAdd(hippoRoot, flags) {
-    const teamId = typeof flags['team'] === 'string' ? flags['team'].trim() : '';
-    const tenantId = typeof flags['tenant'] === 'string' ? flags['tenant'].trim() : '';
+    const teamId = (stringFlag(flags, 'team') ?? '').trim();
+    const tenantId = (stringFlag(flags, 'tenant') ?? '').trim();
     if (!teamId || !tenantId) {
         printError('Usage: hippo slack workspaces add --team <T> --tenant <t>');
         process.exit(1);
     }
-    const db = openHippoDb(hippoRoot);
-    try {
-        const ws = addSlackWorkspace(db, { teamId, tenantId });
-        console.log(`added: ${ws.teamId} -> ${ws.tenantId} (${ws.addedAt})`);
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    const ws = addSlackWorkspace(hippoRoot, { teamId, tenantId });
+    console.log(`added: ${ws.teamId} -> ${ws.tenantId} (${ws.addedAt})`);
 }
 function cmdSlackWorkspacesList(hippoRoot) {
-    const db = openHippoDb(hippoRoot);
-    try {
-        const items = listSlackWorkspaces(db);
-        if (items.length === 0) {
-            console.log('(no registered workspaces; routing via HIPPO_TENANT fallback)');
-            return;
-        }
-        for (const ws of items) {
-            console.log(`${ws.teamId}\t${ws.tenantId}\t${ws.addedAt}`);
-        }
+    const items = listSlackWorkspaces(hippoRoot);
+    if (items.length === 0) {
+        console.log('(no registered workspaces; routing via HIPPO_TENANT fallback)');
+        return;
     }
-    finally {
-        closeHippoDb(db);
+    for (const ws of items) {
+        console.log(`${ws.teamId}\t${ws.tenantId}\t${ws.addedAt}`);
     }
 }
 function cmdSlackWorkspacesRemove(hippoRoot, flags) {
-    const teamId = typeof flags['team'] === 'string' ? flags['team'].trim() : '';
+    const teamId = (stringFlag(flags, 'team') ?? '').trim();
     if (!teamId) {
         printError('Usage: hippo slack workspaces remove --team <T>');
         process.exit(1);
     }
-    const db = openHippoDb(hippoRoot);
-    try {
-        const removed = removeSlackWorkspace(db, teamId);
-        if (!removed) {
-            printError(`no workspace registered for team ${teamId}`);
-            process.exit(1);
-        }
-        console.log(`removed: ${teamId}`);
-    }
-    finally {
-        closeHippoDb(db);
+    const removed = removeSlackWorkspace(hippoRoot, teamId);
+    if (!removed) {
+        printError(`no workspace registered for team ${teamId}`);
+        process.exit(1);
     }
+    console.log(`removed: ${teamId}`);
 }
-export function cmdSlack(hippoRoot, args, flags) {
+export async function cmdSlack(hippoRoot, args, flags) {
     const sub = args[0];
     if (sub === 'backfill') {
         cmdSlackBackfill(hippoRoot, flags);
@@ -145,7 +121,7 @@ export function cmdSlack(hippoRoot, args, flags) {
         return;
     }
     if (sub === 'dlq' && args[1] === 'replay') {
-        cmdSlackDlqReplay(hippoRoot, args, flags);
+        await cmdSlackDlqReplay(hippoRoot, args, flags);
         return;
     }
     if (sub === 'workspaces') {

package/dist/cli/sleep-render.d.ts

@@ -0,0 +1,4 @@
+import type * as api from '../api/index.js';
+/** The lines `hippo sleep` prints for an api.sleep result; pure, so the snapshot tests read them without a console spy. */
+export declare function sleepResultLines(result: api.SleepResult): string[];
+//# sourceMappingURL=sleep-render.d.ts.map

package/dist/cli/sleep-render.js

@@ -0,0 +1,61 @@
+// The text `hippo sleep` prints for an api.sleep result, kept pure so tests read the lines directly.
+import { renderAmbientSummary } from '../core/ambient.js';
+/** The lines `hippo sleep` prints for an api.sleep result; pure, so the snapshot tests read them without a console spy. */
+export function sleepResultLines(result) {
+    return [...sleepCountLines(result), ...(result.dryRun ? ['\n(dry run  - nothing written)'] : []), ...sleepDedupeAndAuditLines(result), ...sleepShareAndGraphLines(result)];
+}
+function sleepCountLines(result) {
+    const lines = [`Running consolidation${result.dryRun ? ' (dry run)' : ''}...`, `\nResults:`, `   Active memories:  ${result.active}`, `   Removed (decayed): ${result.removed}`];
+    // Only when dormant.enabled moved something, so every other render stays byte-identical.
+    if (result.dormant !== undefined && result.dormant > 0) {
+        lines.push(`   Kept dormant:      ${result.dormant}  (hippo dormant to list)`);
+    }
+    if (result.dormantExpired !== undefined && result.dormantExpired > 0) {
+        lines.push(`   Expired dormant:   ${result.dormantExpired}  (past dormant.retentionDays)`);
+    }
+    lines.push(`   Merged episodic:   ${result.mergedEpisodic}`, `   New semantic:      ${result.newSemantic}`);
+    if (result.details && result.details.length > 0)
+        lines.push('\nDetails:', ...result.details);
+    return lines;
+}
+function sleepDedupeAndAuditLines(result) {
+    const lines = [];
+    if (result.deduped && result.deduped.removed > 0) {
+        const { removed, semDups, epiDups, crossDups } = result.deduped;
+        const parts = [];
+        if (semDups > 0)
+            parts.push(`${semDups} redundant semantic patterns`);
+        if (epiDups > 0)
+            parts.push(`${epiDups} duplicate episodic lessons`);
+        if (crossDups > 0)
+            parts.push(`${crossDups} cross-layer duplicates`);
+        lines.push(`\n${result.dryRun ? 'Would dedupe' : 'Deduped'} ${removed} duplicates (${parts.join(', ')}). ${result.dryRun ? 'Would keep' : 'Kept'} stronger copies.`);
+    }
+    if (result.audit) {
+        if (result.audit.errorsRemoved > 0) {
+            lines.push(`\nAudit: ${result.dryRun ? 'would remove' : 'removed'} ${result.audit.errorsRemoved} junk memories (too short/empty).`);
+        }
+        if (result.audit.warningCount > 0) {
+            lines.push(`Audit: ${result.audit.warningCount} low-quality memories detected (run \`hippo audit\` for details).`);
+        }
+    }
+    return lines;
+}
+function sleepShareAndGraphLines(result) {
+    const lines = [];
+    if (result.shared !== undefined && result.shared > 0) {
+        lines.push(`\nAuto-shared ${result.shared} high-value memories to global store.`);
+    }
+    if (result.secretSkipped !== undefined && result.secretSkipped > 0) {
+        // The secret veto is never silent.
+        lines.push(`\nAuto-share: withheld ${result.secretSkipped} secret-flagged ${result.secretSkipped === 1 ? 'memory' : 'memories'} (secret veto).`);
+    }
+    if (result.ambient)
+        lines.push(`\n${renderAmbientSummary(result.ambient)}`);
+    if (result.graph && result.graph.tenants > 0) {
+        const { tenants, entities, relations } = result.graph;
+        lines.push(`\nGraph: rebuilt ${tenants} tenant${tenants === 1 ? '' : 's'} (${entities} entities, ${relations} relations).`);
+    }
+    return lines;
+}
+//# sourceMappingURL=sleep-render.js.map