hippo-memory 1.60.0 → 1.61.0

package/dist/cli/shared.js

@@ -1,32 +1,30 @@
 // Helpers two or more CLI verbs use, split from cli.ts so a verb can move to its own file without importing cli.ts.
 // 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, CODEX_TRUST_LINE } from '../hooks.js';
-import { confidenceLabel, computeSchemaFit, createMemory, Layer } from '../memory.js';
-import { isInitialized, loadAllEntries, writeEntry, updateStats } from '../store.js';
-import { RejectedValueError } from '../rejection.js';
-import { explainMatch } from '../search.js';
-import { embedMemory } from '../embeddings.js';
+import { installJsonHooks } from '../hooks/json-hooks.js';
+import { CODEX_TRUST_LINE } from '../hooks/shared.js';
+import { confidenceLabel } from '../memory.js';
+import { isInitialized } from '../store/open.js';
+import { explainMatch } from '../search/explain.js';
 import { loadConfig } from '../config.js';
-import { openHippoDb, closeHippoDb, isSqliteBusy, noteStoreBusy } from '../db.js';
+import { openHippoDb, closeHippoDb, isSqliteBusy, noteStoreBusy, withSharedStoreHandles, HOOK_DB_WAIT_MS } from '../db.js';
+import { ensurePilotArm, hashArm, readPilotArm } from '../pilot-arm.js';
 import { hookPayloadSessionId, isSubagentPayload, recordTokenUse } from '../token-ledger.js';
-import { isGitRepo, fetchGitLog, extractLessons, partitionLessons } from '../autolearn.js';
-import { storedTextKeys, duplicateKey } from '../same-text.js';
 import { importAtSessionEnd, currentMachine } from '../agent-memories/sync.js';
 import { summaryLine } from '../agent-memories/report.js';
-import { detectChurnStale, extractInvalidationTarget, invalidateMatching } from '../invalidation.js';
+import { detectChurnStale } from '../invalidation.js';
 import { resolveProjectIdentity } from '../project-identity.js';
-import { extractPathTags } from '../path-context.js';
 import { getGlobalRoot, initGlobal } from '../shared.js';
 import { DAILY_TASK_NAME, buildDailyRunnerCommand, buildSchtasksCreateArgs, buildWindowsTaskRun } from '../scheduler.js';
-import { sanitizeLogMessage } from '../capture.js';
+import { sanitizeLogMessage } from '../capture/compact.js';
 import { appendAuditEvent, reportAuditWriteFailure } from '../audit.js';
-import { createHash } from 'node:crypto';
 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 { log } from '../log.js';
 import { printError } from './output.js';
@@ -92,7 +90,7 @@ export function requireInit(hippoRoot) {
 }
 /** Runs detectChurnStale against every store this repo's memories can live in. */
 export function runChurnStaleForRepo(hippoRoot, dryRun) {
-    const repoRoot = execFileSync('git', ['rev-parse', '--show-toplevel'], { cwd: process.cwd(), encoding: 'utf8', windowsHide: true }).trim();
+    const repoRoot = execFileSync('git', ['rev-parse', '--show-toplevel'], { cwd: process.cwd(), encoding: 'utf8', timeout: 10_000, windowsHide: true }).trim();
     const projectName = resolveProjectIdentity(process.cwd()).name;
     const globalRoot = getGlobalRoot();
     const roots = globalRoot !== hippoRoot && isInitialized(globalRoot) ? [hippoRoot, globalRoot] : [hippoRoot];
@@ -116,7 +114,7 @@ export function runChurnStaleForRepo(hippoRoot, dryRun) {
  * promote); every other command opens the store directly, knob or not.
  */
 function failIfServerRequired(reason) {
-    if (process.env['HIPPO_REQUIRE_SERVER']) {
+    if (envRequireServer()) {
         throw new Error(`hippo: HIPPO_REQUIRE_SERVER is set but ${reason}. ` +
             `Start \`hippo serve\`, or unset HIPPO_REQUIRE_SERVER to allow direct-mode fallback.`);
     }
@@ -142,7 +140,7 @@ export async function runViaServerIfAvailable(hippoRoot, httpFn) {
         failIfServerRequired('no running server was detected for this hippoRoot');
         return false;
     }
-    const apiKey = process.env['HIPPO_API_KEY'];
+    const apiKey = envApiKey();
     try {
         await httpFn(info, apiKey);
         return true;
@@ -220,19 +218,6 @@ export function printAgentImport(report, indent = '   ') {
     for (const warning of report.warnings)
         printError(`hippo: agent memories: ${warning}`);
 }
-/** The first hippo block in `text` and the agent whose current or shipped text it is; `owner` is undefined for an edited block. */
-export function hippoBlock(text) {
-    const at = text.indexOf(HOOK_MARKERS.start);
-    const start = at + HOOK_MARKERS.start.length;
-    const end = text.indexOf(HOOK_MARKERS.end, start);
-    if (at < 0 || end < 0)
-        return null;
-    // git autocrlf checks these files out with CRLF: match as LF, write back in the file's own ending.
-    const raw = text.slice(start, end);
-    const inner = raw.replace(/\r\n/g, '\n').trim();
-    const owner = Object.keys(HOOKS).find((k) => HOOKS[k].content === inner) ?? SHIPPED_HOOK_HASHES.get(createHash('sha256').update(inner).digest('hex'));
-    return { start, end, eol: raw.includes('\r\n') ? '\r\n' : '\n', inner, owner };
-}
 /** 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');
@@ -420,7 +405,7 @@ export function cardStringFlag(flags, key) {
 }
 // Claude Code exports its own session var, not ours; without the fallback agent-run recalls trace with no session.
 export function hostSessionId() {
-    return process.env.HIPPO_SESSION_ID?.trim() || process.env.CLAUDE_CODE_SESSION_ID?.trim() || undefined;
+    return envHippoSessionId()?.trim() || envClaudeCodeSessionId()?.trim() || undefined;
 }
 /**
  * Compaction drops the pinned blocks the per-prompt hook injected
@@ -505,106 +490,19 @@ export function withLedgerDb(hippoRoot, fn) {
 }
 export function learnFromRepo(hippoRoot, repoPath, days, label) {
     const prefix = label ? `[${label}] ` : '';
-    if (!isGitRepo(repoPath)) {
+    const ctx = { hippoRoot, tenantId: resolveTenantId({}), actor: adminActor('cli') };
+    const result = learn(ctx, { repoPath, days, profile: CLI_LEARN });
+    if (result.status === 'not-a-repo') {
         console.log(`${prefix}No git history found (or not a git repository).`);
         return { added: 0, skipped: 0, lowInfo: 0 };
     }
-    const gitLog = fetchGitLog(repoPath, days);
-    if (!gitLog.trim()) {
-        console.log(`${prefix}No fix/revert/bug commits found in the specified period.`);
-        return { added: 0, skipped: 0, lowInfo: 0 };
-    }
-    // Same patterns as MCP hippo_learn: config.gitLearnPatterns (whose default
-    // equals extractLessons' built-in list) so a custom list applies everywhere.
-    const config = loadConfig(hippoRoot);
-    const parsedLessons = extractLessons(gitLog, config.gitLearnPatterns);
-    if (parsedLessons.length === 0) {
+    if (result.status !== 'scanned') {
         console.log(`${prefix}No fix/revert/bug commits found in the specified period.`);
         return { added: 0, skipped: 0, lowInfo: 0 };
     }
-    // The admission gate lives at the write path, not in extractLessons
-    // (a published API surface that only parses). Bare subjects like "fixed
-    // signals" are dropped here, before they ever become a memory.
-    // The gate filters the loop INPUT, so a dropped lesson neither stores nor
-    // invalidates. That is deliberate, and it was argued both ways.
-    //
-    // One review called the lost invalidation serious: a migration subject
-    // too thin to store ("replace webpack with vite") would stop weakening
-    // stale webpack memories. True. So the loop was widened to walk every
-    // parsed lesson with the gate on the write alone.
-    //
-    // A second review found the cure was worse. STORAGE is what makes invalidation
-    // idempotent here: a stored lesson is recognised by its same-text key on
-    // the next scan and short-circuits before invalidating again. A lesson that
-    // invalidates but is never stored has no such record, so every rescan
-    // re-invalidates, and invalidateMatching halves half_life_days each time.
-    // Measured: 7 -> 3 -> 1 over two runs. That is compounding data damage.
-    //
-    // Measured frequency decided it. Across 413 real auto-learn rows in 4
-    // stores, 24 are gated and ZERO of those carry an invalidation target; the
-    // 45 lessons that do carry targets all pass the gate and are unaffected
-    // either way. Both failure modes are empty on real data, so the tie breaks
-    // on which one is benign if it ever fires: not invalidating is a missed
-    // improvement, re-invalidating forever is damage.
-    //
-    // Documented limitation, pinned by test: a migration subject too thin to
-    // store also does not invalidate. Making invalidateMatching idempotent
-    // would allow both, and is backlogged - it is a latent issue for the manual
-    // `hippo invalidate` path too, not just this one.
-    const { kept: lessons, dropped } = partitionLessons(parsedLessons);
-    const lowInfo = dropped.length;
-    let added = 0;
-    let skipped = 0;
-    // Containment: per-lesson refusal must not abort the rest
-    // of the git-log scan. No signature change (added/skipped return shape
-    // used by cmdLearn + cmdSleepCore callers) — counted locally, folded into
-    // the existing summary line.
-    let rejected = 0;
-    const gitLearnTags = ['error', 'git-learned'];
-    const existingForSchema = loadAllEntries(hippoRoot, resolveTenantId({}));
-    const keys = storedTextKeys(existingForSchema);
-    for (const lesson of lessons) {
-        if (keys.has(duplicateKey(lesson))) {
-            skipped++;
-            continue;
-        }
-        const target = extractInvalidationTarget(lesson);
-        if (target) {
-            const invResult = invalidateMatching(hippoRoot, target, resolveTenantId({}));
-            if (invResult.invalidated > 0) {
-                console.log(`${prefix}   Invalidated ${invResult.invalidated} memories referencing "${target.from}"`);
-            }
-        }
-        const schemaFitVal = computeSchemaFit(lesson, gitLearnTags, existingForSchema);
-        const entry = createMemory(lesson, {
-            layer: Layer.Episodic,
-            tags: [...gitLearnTags],
-            source: 'git-learn',
-            confidence: 'observed',
-            schema_fit: schemaFitVal,
-            tenantId: resolveTenantId({}),
-            baseHalfLifeDays: config.defaultHalfLifeDays,
-        });
-        // Auto-tag with path context from the repo being learned
-        const learnPathTags = extractPathTags(repoPath);
-        for (const pt of learnPathTags) {
-            if (!entry.tags.includes(pt))
-                entry.tags.push(pt);
-        }
-        try {
-            writeEntry(hippoRoot, entry);
-        }
-        catch (err) {
-            if (err instanceof RejectedValueError) {
-                rejected++;
-                continue;
-            }
-            throw err;
-        }
-        updateStats(hippoRoot, { remembered: 1 });
-        keys.add(duplicateKey(lesson));
-        void embedMemory(hippoRoot, entry);
-        added++;
+    const { added, skipped, rejected, lowInfo } = result;
+    for (const { from, count } of result.invalidations) {
+        console.log(`${prefix}   Invalidated ${count} memories referencing "${from}"`);
     }
     console.log(`${prefix}${added} new lessons added, ${skipped} duplicates skipped` +
         (rejected > 0 ? `, ${rejected} rejected value(s) skipped` : '') +
@@ -612,223 +510,6 @@ export function learnFromRepo(hippoRoot, repoPath, days, label) {
         '.');
     return { added, skipped, lowInfo };
 }
-export const HOOK_MARKERS = {
-    start: '<!-- hippo:start -->',
-    end: '<!-- hippo:end -->',
-};
-export const HOOKS = {
-    'claude-code': {
-        file: 'CLAUDE.md',
-        description: 'Claude Code',
-        content: `
-## Project Memory (Hippo)
-
-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
-\`\`\`
-
-When you find out why something failed, record it right then, while you
-work, never as a closing step:
-\`\`\`bash
-hippo remember "<what went wrong and why>" --error
-\`\`\`
-
-The installed hooks store failed tool calls and capture the session when it
-ends, so there is nothing to run before you finish.
-`.trim(),
-    },
-    'codex': {
-        file: 'AGENTS.md',
-        description: 'OpenAI Codex',
-        content: `
-## Project Memory (Hippo)
-
-At the start of every task, run:
-\`\`\`bash
-hippo context --auto --budget 1500
-\`\`\`
-Read the output before writing any code.
-
-On errors or unexpected behaviour, record it right then, while you work,
-never as a closing step:
-\`\`\`bash
-hippo remember "<description of what went wrong>" --error
-\`\`\`
-
-When you learn something that should outlive this session (a decision and
-its reason, a user preference, a lesson), record it right then, while you
-work, never as a closing step. Leave out secrets and personal details:
-\`\`\`bash
-hippo remember "<what you learned and why>"
-\`\`\`
-
-When Hippo's Codex wrapper is installed, session-end capture runs automatically.
-If the wrapper is not installed, capture a brief summary manually:
-\`\`\`bash
-hippo capture --stdin <<< '<decisions, errors, lessons: 2-5 bullets>'
-\`\`\`
-`.trim(),
-    },
-    'cursor': {
-        file: 'AGENTS.md',
-        description: 'Cursor',
-        content: `
-## Project Memory (Hippo)
-
-At the start of every task, run:
-\`\`\`bash
-hippo context --auto --budget 1500
-\`\`\`
-Read the output before writing any code.
-
-On errors or unexpected behaviour, record it right then, while you work,
-never as a closing step:
-\`\`\`bash
-hippo remember "<description of what went wrong>" --error
-\`\`\`
-
-When you learn something that should outlive this session (a decision and
-its reason, a user preference, a lesson), record it right then, while you
-work, never as a closing step. Leave out secrets and personal details:
-\`\`\`bash
-hippo remember "<what you learned and why>"
-\`\`\`
-
-When ending a session, capture a brief summary:
-\`\`\`bash
-hippo capture --stdin <<< '<decisions, errors, lessons: 2-5 bullets>'
-\`\`\`
-`.trim(),
-    },
-    'openclaw': {
-        file: 'AGENTS.md',
-        description: 'OpenClaw',
-        content: `
-## Project Memory (Hippo)
-
-At the start of every session, run:
-\`\`\`bash
-hippo context --auto --budget 1500
-\`\`\`
-Read the output before writing any code.
-
-On errors or unexpected behaviour, record it right then, while you work,
-never as a closing step:
-\`\`\`bash
-hippo remember "<description of what went wrong>" --error
-\`\`\`
-
-When you learn something that should outlive this session (a decision and
-its reason, a user preference, a lesson), record it right then, while you
-work, never as a closing step. Leave out secrets and personal details:
-\`\`\`bash
-hippo remember "<what you learned and why>"
-\`\`\`
-
-When ending a session, capture a brief summary:
-\`\`\`bash
-hippo capture --stdin <<< '<decisions, errors, lessons: 2-5 bullets>'
-\`\`\`
-`.trim(),
-    },
-    'opencode': {
-        file: 'AGENTS.md',
-        description: 'OpenCode',
-        content: `
-## Project Memory (Hippo)
-
-At the start of every task, run:
-\`\`\`bash
-hippo context --auto --budget 1500
-\`\`\`
-Read the output before writing any code.
-
-On errors or unexpected behaviour, record it right then, while you work,
-never as a closing step:
-\`\`\`bash
-hippo remember "<description of what went wrong>" --error
-\`\`\`
-
-When you learn something that should outlive this session (a decision and
-its reason, a user preference, a lesson), record it right then, while you
-work, never as a closing step. Leave out secrets and personal details:
-\`\`\`bash
-hippo remember "<what you learned and why>"
-\`\`\`
-
-When stuck or repeating yourself, check if this happened before:
-\`\`\`bash
-hippo recall "<what's going wrong>" --budget 2000
-\`\`\`
-
-When ending a session, capture a brief summary:
-\`\`\`bash
-hippo capture --stdin <<< '<decisions, errors, lessons: 2-5 bullets>'
-\`\`\`
-`.trim(),
-    },
-    'pi': {
-        file: 'AGENTS.md',
-        description: 'Pi',
-        content: `
-## Project Memory (Hippo)
-
-At the start of every session, run:
-\`\`\`bash
-hippo context --auto --budget 1500
-\`\`\`
-Read the output before writing any code.
-
-On errors or unexpected behaviour, record it right then, while you work,
-never as a closing step:
-\`\`\`bash
-hippo remember "<description of what went wrong>" --error
-\`\`\`
-
-When you learn something that should outlive this session (a decision and
-its reason, a user preference, a lesson), record it right then, while you
-work, never as a closing step. Leave out secrets and personal details:
-\`\`\`bash
-hippo remember "<what you learned and why>"
-\`\`\`
-
-When ending a session, capture a brief summary:
-\`\`\`bash
-hippo capture --stdin <<< '<decisions, errors, lessons: 2-5 bullets>'
-\`\`\`
-
-For full integration, copy the hippo-memory Pi extension to \`~/.pi/agent/extensions/hippo-memory/\`.
-`.trim(),
-    },
-};
-// sha256 of each trimmed block an earlier hippo wrote, so init refreshes only blocks nobody edited. Add the old hash when a block changes.
-const SHIPPED_HOOK_HASHES = new Map([
-    ['c04e48f2896a4fee9ae98f8f832e2d26a3910269df3beb5bcd6baee3cd9db68e', 'claude-code'],
-    ['e6b12bd8983c032e5ca8e95a97aeff4178a5a05026d10acad5b2e1b25d5656dd', 'claude-code'],
-    ['4c64e11d3e5be68fa547c9248d7553feb645a02f7cf13ba02f7275e1854baf44', 'claude-code'],
-    ['293bd319bbc86225a0ee027490a3322a0336257f5832f7fade65e4ffb2530654', 'claude-code'],
-    ['15abcece9712279fb4721f7a8f0ba117457400278977beb5cf5b5d7ba49f7b1a', 'codex'],
-    ['0c81a6b2c21473313001f624b80ea870e661aecbfda9bfe8503febc0d5f34533', 'codex'],
-    ['88e45358aba4f17912f113221c991dc758275991335d1daa4aa1974a69c46769', 'codex'],
-    ['e61632fe177450a06541c148a9a4f9182530d8df667806927a99792825903298', 'codex'],
-    ['a1415ecda9b2f8f317c233738e4a5ac16e6b2cc385a017c0c8ecfbfacbcab6a3', 'cursor'],
-    ['a38c428bbdfc14ec50f6f7b9183785170a4eae1ce9cde60257cca6efc7206b3a', 'cursor'],
-    ['0ec9f556abfd55e94f9e6fb47ece0fc5acb841977d144b35a2371e03645d8636', 'cursor'],
-    ['40524c3bd5a2eb04036567cc761451961d950995768bccd93a9900b0f75eafea', 'openclaw'],
-    ['7b3518e8c0feaa7b8b454cde7743f7598ad14cd9979e1680d0954484e2464aae', 'openclaw'],
-    ['1137dcf04568caf011e41db77bc55324faee88bc29c3a5fcc98ab687cd952a16', 'openclaw'],
-    ['4601c67c31f41cd5b1324cfccdb1afc66872b7fb0bc1e7c5789ecabb1f6bd942', 'opencode'],
-    ['90d9e21d8d1ecbe99a0fc7b7f2d9f8af7b5315a6b4b0203df4f7a9bdc0699b98', 'opencode'],
-    ['ca4e00284f1397ed2f2fcc53210c27f63b90edf6b37fd66dad5ee58b94ea3eee', 'opencode'],
-    ['8b8f5986d7f7ed15f06e68720d8913c3cab23d94366b411935ca2bbaa334553b', 'pi'],
-    ['37767b355e18beac726b05b9e2b898dab8c6135fd7b98f3aa52edc734d5dd283', 'pi'],
-    ['6e85a5cccb3cfeaa9a080713754936db730f96376f94cc9a9888a746149c7268', 'pi'],
-]);
 export function resolveAuthRoot(hippoRoot, flags) {
     if (flags['global']) {
         initGlobal();
@@ -837,4 +518,32 @@ 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 withSharedStoreHandles(fn, { busyWaitMs: HOOK_DB_WAIT_MS });
+    }
+    catch (error) {
+        if (!isSqliteBusy(error))
+            throw error;
+        noteStoreBusy('hook skipped');
+        return undefined;
+    }
+}
+/**
+ * Whether this session sits in the pilot's holdout arm (src/pilot-arm.ts). Off at rate 0 and with no session id.
+ * `write` books the arm row; a read-only caller (env-only id, sub-agent) follows the stored arm, else the hash.
+ */
+export function inPilotHoldout(hippoRoot, tenantId, sessionId, write) {
+    if (sessionId === undefined || sessionId.trim() === '')
+        return false;
+    const root = isInitialized(hippoRoot) ? hippoRoot : isInitialized(getGlobalRoot()) ? getGlobalRoot() : null;
+    if (root === null)
+        return false;
+    const rate = loadConfig(root).pilot.holdoutRateBp;
+    if (rate <= 0)
+        return false;
+    const arm = withLedgerDb(hippoRoot, (db) => write ? ensurePilotArm(db, tenantId, sessionId, rate) : readPilotArm(db, sessionId) ?? hashArm(sessionId, rate));
+    return (arm ?? hashArm(sessionId, rate)) === 'holdout';
+}
 //# sourceMappingURL=shared.js.map

package/dist/cli/slack.d.ts

@@ -0,0 +1,2 @@
+export declare function cmdSlack(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
+//# sourceMappingURL=slack.d.ts.map

package/dist/cli/slack.js

@@ -0,0 +1,171 @@
+// `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 { 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';
+// ---------------------------------------------------------------------------
+// Slack subcommands (E1.3 — `hippo slack backfill` / `hippo slack dlq list`)
+// ---------------------------------------------------------------------------
+function cmdSlackBackfill(hippoRoot, flags) {
+    const channel = typeof flags['channel'] === 'string' ? flags['channel'] : undefined;
+    if (!channel) {
+        printSlackBackfillUsage();
+        process.exit(1);
+    }
+    // Real fetcher requires SLACK_BOT_TOKEN with channels:history scope.
+    const token = envSlackBotToken();
+    if (!token) {
+        printError('SLACK_BOT_TOKEN is not set. Backfill requires a Slack bot token with channels:history scope.');
+        process.exit(2);
+    }
+    // --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'];
+    void sinceIso;
+    const fetcher = slackHistoryFetcher(token);
+    const ctx = {
+        hippoRoot,
+        tenantId: resolveTenantId({}),
+        actor: api.adminActor('cli:slack-backfill'),
+    };
+    backfillChannel(ctx, {
+        teamId: envSlackTeamId() ?? 'T_UNKNOWN',
+        channel: { id: channel, is_private: false },
+        fetcher,
+    })
+        .then((r) => {
+        console.log(`backfill ${channel}: ${r.ingested} new messages across ${r.pages} pages`);
+    })
+        .catch((e) => {
+        printError('backfill failed:', e.message);
+        process.exit(3);
+    });
+}
+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);
+    }
+}
+function cmdSlackDlqReplay(hippoRoot, args, flags) {
+    const idArg = args[2];
+    if (!idArg) {
+        printError('Usage: hippo slack dlq replay <id> [--force]');
+        process.exit(1);
+    }
+    const id = Number(idArg);
+    if (!Number.isFinite(id) || !Number.isInteger(id) || id < 1) {
+        printError(`replay: invalid id ${idArg}`);
+        process.exit(1);
+    }
+    const force = flags.force === true;
+    const result = replayDlqEntry({ hippoRoot }, id, {
+        force,
+        signingSecret: envSlackSigningSecret(),
+    });
+    if (!result.ok) {
+        printError(`replay failed: status=${result.status} retry_count=${result.retryCount}${result.reason ? ` reason=${result.reason}` : ''}`);
+        process.exit(1);
+    }
+    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() : '';
+    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);
+    }
+}
+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}`);
+        }
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+function cmdSlackWorkspacesRemove(hippoRoot, flags) {
+    const teamId = typeof flags['team'] === 'string' ? 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);
+    }
+}
+export function cmdSlack(hippoRoot, args, flags) {
+    const sub = args[0];
+    if (sub === 'backfill') {
+        cmdSlackBackfill(hippoRoot, flags);
+        return;
+    }
+    if (sub === 'dlq' && args[1] === 'list') {
+        cmdSlackDlqList(hippoRoot, flags);
+        return;
+    }
+    if (sub === 'dlq' && args[1] === 'replay') {
+        cmdSlackDlqReplay(hippoRoot, args, flags);
+        return;
+    }
+    if (sub === 'workspaces') {
+        const action = args[1];
+        if (action === 'add') {
+            cmdSlackWorkspacesAdd(hippoRoot, flags);
+            return;
+        }
+        if (action === 'list') {
+            cmdSlackWorkspacesList(hippoRoot);
+            return;
+        }
+        if (action === 'remove') {
+            cmdSlackWorkspacesRemove(hippoRoot, flags);
+            return;
+        }
+        printSlackWorkspacesUsage();
+        process.exit(1);
+    }
+    printError('Usage: hippo slack <backfill|dlq list|dlq replay <id> [--force]|workspaces add|workspaces list|workspaces remove> [...]');
+    process.exit(1);
+}
+//# sourceMappingURL=slack.js.map

package/dist/cli/status.d.ts

@@ -0,0 +1,18 @@
+import { type CommandContext } from './shared.js';
+export declare function cmdStatus(hippoRoot: string): void;
+/**
+ * `hippo tokens [--days <n>] [--json] [--global]`: the token ledger
+ * (ROADMAP TE0). Tokens of memory text handed to agents per surface, blocks
+ * the per-prompt hook skipped as unchanged (TE2) and the tokens that saved,
+ * and the hook blocks' tokens later model calls re-read, counted when each session ends.
+ * Counts are estimates (characters / 4), the same estimate every budget uses.
+ */
+export declare function cmdTokens(hippoRoot: string, flags: Record<string, string | boolean | string[]>): void;
+/** `hippo failures [--days <n>] [--json] [--global]`: failed tool calls by outcome, and repeats across sessions (CD13). */
+export declare function cmdFailures(hippoRoot: string, flags: Record<string, string | boolean | string[]>): void;
+export declare function handleCorrectionLatency({ hippoRoot, flags }: CommandContext): void;
+export declare function handleProvenance({ hippoRoot, flags }: CommandContext): void;
+export declare function handleDoctor({ flags }: CommandContext): void;
+export declare function handleSupportBundle({ flags }: CommandContext): void;
+export declare function handleInspect({ hippoRoot, args }: CommandContext): void;
+//# sourceMappingURL=status.d.ts.map