hippo-memory 1.71.0 → 2.0.0

package/dist/cli/flags.js

@@ -1,144 +1,9 @@
-// Each verb's flags as data, keyed like the command table: parseArgs needs a flag's kind before the verb's module loads.
+// Each flag's kind, read from the verb table's flags: parseArgs needs a flag's kind before the verb's module loads.
+import { COMMANDS } from './verbs.js';
 // The entry point reads these for every verb, so no verb declares them.
 const GLOBAL_FLAGS = { switches: ['help', 'version'] };
-export const VERB_FLAGS = {
-    init: { switches: ['global', 'no-hooks', 'no-learn', 'no-schedule'], values: ['scan'], numbers: ['days'] },
-    remember: {
-        switches: ['error', 'extract', 'force', 'global', 'inferred', 'observed', 'pin', 'verified'],
-        values: ['artifact-ref', 'kind', 'layer', 'owner', 'scope'],
-        lists: ['tag'],
-    },
-    recall: {
-        switches: ['classic', 'continuity', 'equal-sources', 'evc-adaptive', 'filter-conflicts', 'graph-stream',
-            'include-superseded', 'json', 'multihop', 'no-mmr', 'physics', 'rerank-utility', 'value-aware', 'why'],
-        values: ['as-of', 'budget', 'goal', 'graph-hops', 'graph-seeds', 'hops', 'layer', 'max-neighbors', 'outcome',
-            'reranker', 'salience-threshold', 'scope', 'session-id'],
-        numbers: ['limit', 'local-bump', 'min-results', 'mmr-lambda', 'reranker-top-k'],
-    },
-    drill: { switches: ['json'], values: ['budget', 'depth'], numbers: ['limit'] },
-    assemble: { switches: ['json', 'no-summarize-older'], values: ['budget', 'fresh-tail', 'scope', 'session'] },
-    supersede: { switches: ['pin'], values: ['layer'], lists: ['tag'] },
-    explain: {
-        switches: ['classic', 'equal-sources', 'include-superseded', 'json', 'no-mmr', 'physics'],
-        values: ['as-of', 'budget', 'scope'],
-        numbers: ['limit', 'local-bump', 'mmr-lambda'],
-    },
-    eval: {
-        switches: ['bootstrap', 'equal-sources', 'json', 'no-mmr', 'save-baseline', 'show-cases', 'suite'],
-        values: ['baseline', 'compare', 'out'],
-        numbers: ['embedding-weight', 'local-bump', 'max-cases', 'min-mrr', 'mmr-lambda'],
-    },
-    trace: { switches: ['json'], values: ['outcome', 'session', 'source', 'steps', 'task'], lists: ['tag'] },
-    refine: { switches: ['all', 'dry-run', 'json'], values: ['model'], numbers: ['limit'] },
-    sleep: { switches: ['dry-run', 'no-learn', 'no-share'], values: ['log-file'] },
-    'last-sleep': { switches: ['keep'], values: ['path'] },
-    'session-end': {
-        switches: ['dry-run', 'no-learn', 'no-share', 'turn'],
-        values: ['format', 'log-file', 'runtime', 'session-id', 'transcript'],
-    },
-    '__session-end-worker': {
-        switches: ['dry-run', 'no-learn', 'no-share', 'turn'],
-        values: ['log-file', 'session-id', 'transcript'],
-    },
-    'pre-compact': { values: ['format', 'log-file', 'runtime'] },
-    'post-compact': { values: ['log-file'] },
-    'capture-error': { values: ['format', 'runtime'] },
-    'compact-resume': {},
-    'codex-run': {},
-    '__codex-session-end-worker': { values: ['codex-home', 'history-path', 'log-file', 'start-offset', 'started-at'] },
-    dedup: { switches: ['dry-run'], numbers: ['threshold'] },
-    dag: { switches: ['stats'] },
-    auth: { switches: ['all', 'global', 'json', 'no-expiry'], values: ['label', 'role', 'tenant'], numbers: ['ttl-days'] },
-    goal: {
-        switches: ['all', 'no-propagate'],
-        values: ['level', 'outcome', 'parent', 'policy', 'session-id', 'success', 'tenant-id'],
-    },
-    slack: { switches: ['force'], values: ['channel', 'since', 'team', 'tenant'] },
-    github: { switches: ['force'], values: ['max', 'repo', 'since'] },
-    audit: {
-        switches: ['apply', 'dry-run', 'fix', 'global', 'json'],
-        values: ['older-than', 'op', 'since', 'tenant'],
-        numbers: ['limit'],
-    },
-    'correction-latency': { switches: ['json'] },
-    provenance: { switches: ['json', 'strict'] },
-    status: {},
-    outcome: { switches: ['bad', 'good'], values: ['id'] },
-    conflicts: { switches: ['json'], values: ['status'] },
-    resolve: { switches: ['forget', 'reject-loser'], values: ['keep', 'reason'] },
-    reject: { switches: ['global'], values: ['reason', 'value'] },
-    rejections: { switches: ['global', 'json'] },
-    unreject: { switches: ['global'] },
-    dormant: { switches: ['global', 'json'], numbers: ['limit'] },
-    projects: { switches: ['apply', 'global', 'json'] },
-    quarantine: { switches: ['all', 'global', 'json'] },
-    tokens: { switches: ['global', 'json'], numbers: ['days'] },
-    failures: { switches: ['global', 'json'], numbers: ['days'] },
-    doctor: { switches: ['json'] },
-    'support-bundle': { switches: ['include-logs'], values: ['out'] },
-    snapshot: { switches: ['json'], values: ['id', 'next-step', 'session', 'source', 'status', 'summary', 'task'] },
-    session: {
-        switches: ['json'],
-        values: ['content', 'id', 'outcome', 'session', 'source', 'summary', 'task', 'type'],
-        numbers: ['limit'],
-    },
-    handoff: {
-        switches: ['json'],
-        values: ['card-id', 'id', 'next', 'outcome', 'session', 'summary', 'target-runtime', 'task', 'tests'],
-        lists: ['artifact', 'constraint'],
-    },
-    // Every card subcommand's flags together; card.ts then refuses the ones its subcommand does not read.
-    card: {
-        switches: ['json'],
-        values: ['author', 'body', 'budget', 'contract', 'outcome', 'reason', 'repo', 'run', 'runtime', 'session',
-            'status', 'title'],
-        lists: ['depends-on'],
-    },
-    predict: {
-        values: ['actual', 'class', 'estimate', 'note', 'state', 'status', 'target', 'unit'],
-        numbers: ['limit'],
-    },
-    current: { switches: ['json'] },
-    forget: { switches: ['archive', 'dry-run'], values: ['reason'] },
-    inspect: {},
-    context: {
-        switches: ['auto', 'cross-project', 'pinned-only'],
-        values: ['budget', 'format', 'framing', 'include-recent', 'runtime', 'scope'],
-        numbers: ['limit'],
-    },
-    hook: {},
-    setup: { switches: ['all', 'dry-run', 'no-learn', 'no-schedule'] },
-    'daily-runner': {},
-    embed: { switches: ['global', 'reset-physics', 'status'] },
-    watch: {},
-    learn: { switches: ['git'], values: ['repos'], numbers: ['days'] },
-    promote: {},
-    sync: { switches: ['cross-project'] },
-    share: { switches: ['auto', 'dry-run', 'force'], numbers: ['min-score'] },
-    peers: { switches: ['all-tenants'] },
-    import: {
-        switches: ['agents', 'dry-run', 'global'],
-        values: ['chatgpt', 'claude', 'cursor', 'file', 'markdown', 'name', 'scope', 'vault'],
-        lists: ['tag'],
-    },
-    export: { values: ['format'] },
-    capture: { switches: ['dry-run', 'global', 'last-session', 'stdin'], values: ['file', 'log-file', 'transcript'] },
-    dashboard: { numbers: ['port'] },
-    wm: { switches: ['json'], values: ['content', 'importance', 'scope', 'session', 'task'], numbers: ['limit'] },
-    mcp: {},
-    serve: { values: ['host', 'tls-cert', 'tls-key'], numbers: ['port'] },
-    invalidate: { switches: ['churn', 'dry-run'], values: ['id', 'reason'] },
-    decide: { values: ['context', 'status', 'supersedes'], numbers: ['limit'] },
-    incident: { values: ['context', 'resolution', 'status'], numbers: ['limit'], lists: ['link'] },
-    process: { values: ['change', 'description', 'status'], numbers: ['limit'], lists: ['step'] },
-    policy: { values: ['change', 'from', 'name', 'status', 'text', 'to'], numbers: ['limit'] },
-    skill: { values: ['change', 'instructions', 'status', 'trigger'], numbers: ['limit'] },
-    brief: { switches: ['dry-run'], values: ['change', 'repo', 'status', 'summary'], numbers: ['limit'] },
-    note: { values: ['change', 'customer', 'status', 'text'], numbers: ['limit'] },
-    graph: { switches: ['json', 'open'], values: ['entity', 'format', 'out'] },
-};
 const FIELD_KINDS = [['switches', 'switch'], ['values', 'value'], ['numbers', 'number'], ['lists', 'list']];
-const DECLARED = new Map([GLOBAL_FLAGS, ...Object.values(VERB_FLAGS)].map((verb) => [
+const DECLARED = new Map([GLOBAL_FLAGS, ...Object.values(COMMANDS).map((row) => row.flags)].map((verb) => [
     verb,
     new Map(FIELD_KINDS.flatMap(([field, kind]) => (verb[field] ?? []).map((name) => [name, kind]))),
 ]));

package/dist/cli/graph.d.ts

@@ -0,0 +1,3 @@
+import { type CommandContext } from './flag-values.js';
+export declare function handleGraph({ hippoRoot, tenantId, args, flags }: CommandContext): void;
+//# sourceMappingURL=graph.d.ts.map

package/dist/cli/graph.js

@@ -0,0 +1,83 @@
+// The entity graph verbs: rebuild it from the consolidated objects, print it, or write it out as a diagram.
+import * as fs from 'fs';
+import { extractGraph } from '../graph/extract.js';
+import { buildGraphModel, renderGraphHtml, renderGraphCanvas, DEFAULT_VIEW_LIMIT } from '../graph/view.js';
+import { printError } from './output.js';
+import { stringFlag } from './flag-values.js';
+import { requireInit } from './shared.js';
+import { CliExit } from './exit.js';
+import { openInBrowser } from './open-browser.js';
+function graphExtract(hippoRoot, tenantId) {
+    const result = extractGraph(hippoRoot, tenantId);
+    const byType = Object.entries(result.byType)
+        .map(([t, n]) => `${t} ${n}`)
+        .join(', ');
+    const supersedes = result.relations - result.references;
+    const relations = `${result.relations} relations (${supersedes} supersedes, ${result.references} references)`;
+    console.log(`Graph extracted: ${result.entities} entities (${byType}) + ${relations}.`);
+    if (result.truncated.length > 0) {
+        printError(`WARNING: under-extracted (hit the per-type cap): ${result.truncated.join(', ')}. The graph is incomplete for those types.`);
+    }
+}
+function graphShow(hippoRoot, tenantId, entity, flags) {
+    const model = buildGraphModel(hippoRoot, tenantId, { entity, limit: DEFAULT_VIEW_LIMIT });
+    if (flags['json']) {
+        console.log(JSON.stringify(model, null, 2));
+        return;
+    }
+    if (model.nodes.length === 0) {
+        console.log(entity ? `No entity named "${entity}".` : 'Graph is empty. Run `hippo graph extract` first.');
+        return;
+    }
+    console.log(`Graph: ${model.nodes.length} entities, ${model.edges.length} relations${model.truncated ? ' (truncated)' : ''}`);
+    const byType = new Map();
+    for (const n of model.nodes) {
+        const arr = byType.get(n.type) ?? [];
+        arr.push({ id: n.id, name: n.name });
+        byType.set(n.type, arr);
+    }
+    for (const [type, ns] of byType) {
+        console.log(`\n${type} (${ns.length}):`);
+        for (const n of ns)
+            console.log(`  [${n.id}] ${n.name}`);
+    }
+    if (model.edges.length > 0) {
+        const nameById = new Map(model.nodes.map((n) => [n.id, n.name]));
+        console.log('\nrelations:');
+        for (const e of model.edges) {
+            console.log(`  ${nameById.get(e.from)} --${e.relType}--> ${nameById.get(e.to)}`);
+        }
+    }
+}
+function graphView(hippoRoot, tenantId, entity, flags) {
+    const format = stringFlag(flags, 'format') ?? 'html';
+    if (format !== 'html' && format !== 'canvas') {
+        printError("graph view: --format must be 'html' or 'canvas'");
+        throw new CliExit(1);
+    }
+    const model = buildGraphModel(hippoRoot, tenantId, { entity, limit: DEFAULT_VIEW_LIMIT });
+    const content = format === 'canvas' ? renderGraphCanvas(model) : renderGraphHtml(model);
+    const defaultOut = format === 'canvas' ? 'hippo-graph.canvas' : 'hippo-graph.html';
+    const out = stringFlag(flags, 'out') ?? defaultOut;
+    fs.writeFileSync(out, content, 'utf8');
+    console.log(`Wrote ${model.nodes.length} entities + ${model.edges.length} relations to ${out}${model.truncated ? ' (truncated)' : ''}`);
+    if (flags['open'] && format === 'html')
+        openInBrowser(out);
+}
+export function handleGraph({ hippoRoot, tenantId, args, flags }) {
+    requireInit(hippoRoot);
+    const subcommand = args[0] ?? '';
+    if (subcommand === 'extract')
+        return graphExtract(hippoRoot, tenantId);
+    const entity = stringFlag(flags, 'entity');
+    if (subcommand === 'show')
+        return graphShow(hippoRoot, tenantId, entity, flags);
+    if (subcommand === 'view')
+        return graphView(hippoRoot, tenantId, entity, flags);
+    printError('Usage:\n' +
+        '  hippo graph extract                     Rebuild the entity/relation graph from consolidated objects\n' +
+        '  hippo graph show [--entity NAME] [--json]   Inspect entities + their edges (text or JSON)\n' +
+        '  hippo graph view [--out FILE] [--open] [--format html|canvas] [--entity NAME]   Generate an interactive node-link diagram');
+    throw new CliExit(1);
+}
+//# sourceMappingURL=graph.js.map

package/dist/cli/hook-runtime.d.ts

@@ -1,5 +1,4 @@
 import type { HookRuntime } from '../core/capture-contract.js';
-import { type DeliveryEventType, type DeliveryRecorder } from '../store/delivery-recorder.js';
 import type { CliFlags } from './flag-values.js';
 /** Detached worker (internal `__session-end-worker`): counts re-reads, runs sleep, then capture; one stage failing does 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. */
@@ -14,18 +13,19 @@ export declare function reportSessionEndFailure<E>(logFile: string | null, step:
 export declare function hostSessionId(): string | undefined;
 /** Compaction drops the pinned blocks the per-prompt hook injected, so record a `reset` for the payload's session and the next prompt injects again.
  * `requiredSource` limits it to payloads with that `source`; best-effort and silent on a malformed payload. */
-export declare function resetHookInjection(hippoRoot: string, stdinText: string | undefined, requiredSource: string | null): void;
+export declare function resetHookInjection(hippoRoot: string, tenantId: string, stdinText: string | undefined, requiredSource: string | null): void;
 /** Store a hook writes to: the project store, else an existing global one, else the project path (skipped: hooks must not create a store).
  * Pre-compact and compact-resume must agree, or a snapshot is looked for in the other store. */
 export declare function hookStoreRoot(hippoRoot: string): string;
 /** `--runtime copilot`, or `--format copilot` on `hippo context`, marks a Copilot hook: the flag decides, never the payload. */
 export declare function hookRuntime(flags: CliFlags): HookRuntime;
-/** A delivery recorder when the ledger store enables one, else null; never throws. */
-export declare function startDeliveryRecorder(hippoRoot: string, stdinText: string | undefined, runtime: HookRuntime, eventType?: DeliveryEventType): DeliveryRecorder | null;
 /** 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 declare function payloadCwdRoot(hippoRoot: string, stdinText: string | undefined, runtime: HookRuntime): string;
-/** 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. */
+/** 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 declare function runHookWithStores<T>(fn: () => T | Promise<T>): Promise<T | undefined>;
 /** Whether this session sits in the pilot's holdout arm; off at rate 0 and with no session id. */
-export declare function inPilotHoldout(hippoRoot: string, tenantId: string, sessionId: string | undefined, write: boolean): boolean;
+export declare function inPilotHoldout(hippoRoot: string, tenantId: string, sessionId: string | undefined, opts: {
+    write: boolean;
+}): boolean;
 //# sourceMappingURL=hook-runtime.d.ts.map

package/dist/cli/hook-runtime.js

@@ -2,20 +2,15 @@
 import { envClaudeCodeSessionId, envHippoSessionId } from '../util/env.js';
 import * as path from 'path';
 import * as fs from 'fs';
-import { getHippoRoot, isInitialized } from '../store/open.js';
-import { loadConfig } from '../core/config.js';
-import { createDeliveryRecorder } from '../store/delivery-recorder.js';
 import { isSqliteBusy, noteStoreBusy, runWithRequestStores, HOOK_DB_WAIT_MS } from '../db/index.js';
-import { bookTokenUse, ledgerRoot } from '../api/ledger-db.js';
+import { bookTokenUse } from '../api/ledger-db.js';
 import { sessionPilotArm } from '../api/pilot-arm.js';
-import { hookPayloadSessionId, hookPayloadString, isSubagentPayload } from '../store/token-ledger.js';
-import { blockHash } from '../util/token-text.js';
+import { hookPayloadSessionId, hookPayloadString, isSubagentPayload } from '../util/hook-payload.js';
 import { importAtSessionEnd, currentMachine } from '../agent-memories/sync.js';
 import { summaryLine } from '../agent-memories/report.js';
-import { isGlobalStoreRoot } from '../core/project-identity.js';
+import { getHippoRoot, isInitialized } from '../core/project-identity.js';
 import { getGlobalRoot } from '../sharing/global-store.js';
 import { sanitizeLogMessage } from '../capture/compact.js';
-import { resolveTenantId } from '../store/tenant.js';
 import { errorMessage, log } from '../util/log.js';
 /** Detached worker (internal `__session-end-worker`): counts re-reads, runs sleep, then capture; one stage failing does 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. */
@@ -61,13 +56,13 @@ export function hostSessionId() {
 }
 /** Compaction drops the pinned blocks the per-prompt hook injected, so record a `reset` for the payload's session and the next prompt injects again.
  * `requiredSource` limits it to payloads with that `source`; best-effort and silent on a malformed payload. */
-export function resetHookInjection(hippoRoot, stdinText, requiredSource) {
+export function resetHookInjection(hippoRoot, tenantId, 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;
     bookTokenUse(hippoRoot, {
-        tenantId: resolveTenantId({}), sessionId, surface: 'hook', event: 'reset', items: 0, tokens: 0,
+        tenantId, sessionId, surface: 'hook', event: 'reset', items: 0, tokens: 0,
     });
 }
 /** Store a hook writes to: the project store, else an existing global one, else the project path (skipped: hooks must not create a store).
@@ -82,29 +77,6 @@ export function hookStoreRoot(hippoRoot) {
 export function hookRuntime(flags) {
     return flags['runtime'] === 'copilot' || flags['format'] === 'copilot' ? 'copilot' : 'claude-code';
 }
-/** A delivery recorder when the ledger store enables one, else null; never throws. */
-export function startDeliveryRecorder(hippoRoot, stdinText, runtime, eventType) {
-    try {
-        // The same store withLedgerDb writes the token ledger to, so its config governs both.
-        const root = ledgerRoot(hippoRoot);
-        if (root === null || !loadConfig(root).deliveryLedger.enabled)
-            return null;
-        return createDeliveryRecorder({
-            root,
-            storeHash: blockHash(path.resolve(root)),
-            writeStore: isGlobalStoreRoot(root) ? 'global' : 'local',
-            tenantId: resolveTenantId({}),
-            stdinText,
-            envSessionId: hostSessionId(),
-            runtime: runtime === 'copilot' ? 'copilot' : undefined,
-            eventType,
-        });
-    }
-    catch (error) {
-        log.warn(`delivery ledger skipped: ${errorMessage(error)}`);
-        return null;
-    }
-}
 /** 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;
@@ -120,7 +92,8 @@ export function payloadCwdRoot(hippoRoot, stdinText, runtime) {
     }
     return getHippoRoot(process.cwd());
 }
-/** 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. */
+/** 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 });
@@ -133,7 +106,7 @@ export async function runHookWithStores(fn) {
     }
 }
 /** 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';
+export function inPilotHoldout(hippoRoot, tenantId, sessionId, opts) {
+    return sessionPilotArm(hippoRoot, tenantId, sessionId, opts.write) === 'holdout';
 }
 //# sourceMappingURL=hook-runtime.js.map

package/dist/cli/incidents.d.ts

@@ -0,0 +1,3 @@
+import { type CommandContext } from './flag-values.js';
+export declare function handleIncident({ hippoRoot, tenantId, args, flags }: CommandContext): void;
+//# sourceMappingURL=incidents.d.ts.map

package/dist/cli/incidents.js

@@ -0,0 +1,112 @@
+// First-class object verbs for incidents: open one, resolve it, close it.
+import { extractPathTags } from '../search/path-context.js';
+import * as incidentsModule from '../objects/incidents.js';
+import { printError } from './output.js';
+import { nonEmptyStringFlag, isStringFlag, stringFlag } from './flag-values.js';
+import { requireInit } from './shared.js';
+import { closeObject, foundOrExit, idArgOrExit, listObjects } from './object-verbs.js';
+import { CliExit } from './exit.js';
+const INCIDENT = { cmd: 'incident', noun: 'Incident', idLabel: 'incident' };
+function printIncidentRow(inc) {
+    const linkPart = inc.linkedMemoryIds.length > 0 ? ` links=${inc.linkedMemoryIds.length}` : '';
+    console.log(`#${inc.id} [${inc.status}]${linkPart} memory=${inc.memoryId ?? '-'}`);
+    console.log(`    ${inc.incidentText}`);
+    if (inc.context)
+        console.log(`    context: ${inc.context}`);
+}
+function incidentList(hippoRoot, tenantId, flags) {
+    listObjects(flags, {
+        plural: 'incidents',
+        states: incidentsModule.VALID_INCIDENT_STATES,
+        load: (opts) => incidentsModule.loadIncidents(hippoRoot, tenantId, opts),
+        printRow: printIncidentRow,
+    });
+}
+function incidentGet(hippoRoot, tenantId, args) {
+    const id = idArgOrExit(args, 'Usage: hippo incident get <id>', INCIDENT.idLabel);
+    const incident = foundOrExit(incidentsModule.loadIncidentById(hippoRoot, tenantId, id), INCIDENT.noun, id);
+    console.log(`Incident #${incident.id}`);
+    console.log(`  status: ${incident.status}`);
+    console.log(`  text: ${incident.incidentText}`);
+    if (incident.context)
+        console.log(`  context: ${incident.context}`);
+    if (incident.resolutionText)
+        console.log(`  resolution: ${incident.resolutionText}`);
+    if (incident.resolvedAt)
+        console.log(`  resolved_at: ${incident.resolvedAt}`);
+    if (incident.closedAt)
+        console.log(`  closed_at: ${incident.closedAt}`);
+    if (incident.linkedMemoryIds.length > 0) {
+        console.log(`  linked memories: ${incident.linkedMemoryIds.join(', ')}`);
+    }
+    if (incident.memoryId)
+        console.log(`  memory: ${incident.memoryId}`);
+    console.log(`  created: ${incident.createdAt}`);
+}
+function incidentResolve(hippoRoot, tenantId, args, flags) {
+    const id = idArgOrExit(args, 'Usage: hippo incident resolve <id> --resolution "<text>"', INCIDENT.idLabel);
+    const resolutionRaw = stringFlag(flags, 'resolution');
+    if (!resolutionRaw?.trim()) {
+        printError('--resolution requires a non-empty value, e.g. hippo incident resolve <id> --resolution "root cause fixed".');
+        throw new CliExit(1);
+    }
+    const resolved = incidentsModule.resolveIncident(hippoRoot, tenantId, id, resolutionRaw);
+    console.log(`Incident #${resolved.id} resolved.`);
+}
+function incidentClose(hippoRoot, tenantId, args) {
+    closeObject(args, INCIDENT, (id) => incidentsModule.closeIncident(hippoRoot, tenantId, id));
+}
+export function handleIncident({ hippoRoot, tenantId, args, flags }) {
+    requireInit(hippoRoot);
+    const subcommand = args[0] ?? '';
+    if (subcommand === 'list')
+        return incidentList(hippoRoot, tenantId, flags);
+    if (subcommand === 'get')
+        return incidentGet(hippoRoot, tenantId, args);
+    if (subcommand === 'resolve')
+        return incidentResolve(hippoRoot, tenantId, args, flags);
+    if (subcommand === 'close')
+        return incidentClose(hippoRoot, tenantId, args);
+    // Default subcommand is open (create): accept both `incident open "<text>"` and bare `incident "<text>"`;
+    // for the `open` keyword the text is args[1], otherwise args[0] is the text.
+    incidentCreate(hippoRoot, tenantId, subcommand === 'open' ? (args[1] ?? '') : subcommand, flags);
+}
+function incidentCreate(hippoRoot, tenantId, incidentText, flags) {
+    if (!incidentText) {
+        printError('Usage: hippo incident "<incident>" [--context "<details>"] [--link <memory-id>]...');
+        printError('       hippo incident list [--status open|resolved|closed|all] [--limit N]');
+        printError('       hippo incident get <id>');
+        printError('       hippo incident resolve <id> --resolution "<text>"');
+        printError('       hippo incident close <id>');
+        throw new CliExit(1);
+    }
+    const context = nonEmptyStringFlag(flags, 'context');
+    // --link is a repeatable flag (collected into an array by parseArgs). A
+    // single --link <id> yields a string; normalize both to string[].
+    const linkRaw = flags['link'];
+    let linkedMemoryIds;
+    if (Array.isArray(linkRaw)) {
+        linkedMemoryIds = linkRaw;
+    }
+    else if (isStringFlag(linkRaw)) {
+        linkedMemoryIds = [linkRaw];
+    }
+    else if (linkRaw === true) {
+        printError('--link requires a memory id, e.g. hippo incident "<text>" --link mem_abc123.');
+        throw new CliExit(1);
+    }
+    const incidentPathTags = extractPathTags(process.cwd());
+    const created = incidentsModule.saveIncident(hippoRoot, tenantId, {
+        incidentText,
+        context,
+        linkedMemoryIds,
+        extraTags: incidentPathTags,
+    });
+    console.log(`Incident recorded: #${created.id}`);
+    if (created.memoryId)
+        console.log(`  memory: ${created.memoryId}`);
+    if (created.linkedMemoryIds.length > 0) {
+        console.log(`  linked memories: ${created.linkedMemoryIds.join(', ')}`);
+    }
+}
+//# sourceMappingURL=incidents.js.map

package/dist/cli/init.d.ts

@@ -1,3 +1,3 @@
 import { type CommandContext } from './flag-values.js';
-export declare function handleInit({ hippoRoot, flags }: CommandContext): void;
+export declare function handleInit({ hippoRoot, tenantId, flags }: CommandContext): Promise<void>;
 //# sourceMappingURL=init.d.ts.map

package/dist/cli/init.js

@@ -8,18 +8,23 @@ import { writeFileAtomic } from '../util/atomic-write.js';
 import { isCodexPresent } from '../hooks/shared.js';
 import { isCodexWrapperInstalled } from '../hooks/codex-wrapper.js';
 import { installOpencodePlugin } from '../hooks/opencode.js';
-import { isInitialized, initStore } from '../store/open.js';
-import { loadAllEntries } from '../store/entry-reads.js';
+import { initMemoryStore } from '../api/store-init.js';
+import { isInitialized } from '../core/project-identity.js';
+import { listMemories } from '../api/memories.js';
+import { cliApiContext } from './api-context.js';
 import { isGitRepo } from '../learn/autolearn.js';
 import { currentMachine, importForStore, importProjectMemories, importUserMemories } from '../agent-memories/sync.js';
 import { emptyReport, mergeReports } from '../agent-memories/report.js';
 import { getGlobalRoot, initGlobal } from '../sharing/global-store.js';
 import { registerWorkspace } from './scheduler.js';
-import { stringFlag } from './flag-values.js';
+import { numberFlag, stringFlag } from './flag-values.js';
 import { printAgentImport } from './print.js';
+import { errorCode, errorMessage, log } from '../util/log.js';
 import { installCodexMemoryHooks, setupDailySchedule, warnClaudeSettingsUnusable } from './install-steps.js';
 import { learnFromRepo, skipLearnOnSharedStore } from './shared.js';
 import { HOOK_MARKERS, HOOKS, hippoBlock } from '../hooks/hook-blocks.js';
+// An unreadable or vanished folder is expected while scanning; any other failure is worth a line.
+const QUIET_SCAN_ERRORS = new Set(['EACCES', 'EPERM', 'ENOENT', 'ENOTDIR']);
 function scanForGitRepos(rootDir, maxDepth = 2) {
     const repos = [];
     function walk(dir, depth) {
@@ -40,7 +45,11 @@ function scanForGitRepos(rootDir, maxDepth = 2) {
                     walk(full, depth + 1);
             }
         }
-        catch { /* permission denied, etc */ }
+        catch (err) {
+            const code = errorCode(err);
+            if (!QUIET_SCAN_ERRORS.has(code))
+                log.warn(`repo scan skipped ${dir}`, { code: code || 'unknown', reason: errorMessage(err) });
+        }
     }
     // Check if rootDir itself is a git repo
     if (fs.existsSync(path.join(rootDir, '.git')))
@@ -49,22 +58,22 @@ function scanForGitRepos(rootDir, maxDepth = 2) {
     return repos;
 }
 /** Creates the repo's store when absent and registers it; returns whether it already existed. */
-function initScannedRepo(repo, globalRoot) {
+function initScannedRepo(repo, tenantId, globalRoot) {
     const repoHippo = path.join(repo, '.hippo');
     const alreadyExists = isInitialized(repoHippo);
     if (!alreadyExists) {
-        initStore(repoHippo);
+        initMemoryStore(cliApiContext(repoHippo, tenantId));
     }
     registerWorkspace(globalRoot, repo);
     return alreadyExists;
 }
 /** Seeds one scanned repo from git history and its agents' notes, unless --no-learn. */
-function learnScannedRepo(repo, seedDays, learn, machine, agentImport) {
+async function learnScannedRepo(repo, tenantId, seedDays, learn, machine, agentImport) {
     const repoHippo = path.join(repo, '.hippo');
     let added = 0;
     let lowInfo = 0;
     if (learn && isGitRepo(repo)) {
-        const result = learnFromRepo(repoHippo, repo, seedDays, path.basename(repo));
+        const result = await learnFromRepo(repoHippo, tenantId, repo, seedDays, path.basename(repo));
         added = result.added;
         lowInfo = result.lowInfo;
     }
@@ -93,7 +102,7 @@ function printScanSummary(repoCount, totalLessons, totalLowInfo) {
         (totalLowInfo > 0 ? `, ${totalLowInfo} low-information subject(s) dropped` : '') +
         '.');
 }
-function cmdInitScan(scanDir, flags) {
+async function cmdInitScan(scanDir, tenantId, flags) {
     const resolved = path.resolve(scanDir);
     console.log(`Scanning ${resolved} for git repositories...\n`);
     const repos = scanForGitRepos(resolved);
@@ -106,17 +115,17 @@ function cmdInitScan(scanDir, flags) {
     let totalLessons = 0;
     // Rolled up so the cross-repo summary reports the gate too: a dropped subject is never invisible.
     let totalLowInfo = 0;
-    const seedDays = parseInt(String(flags['days'] ?? '365'), 10);
+    const seedDays = numberFlag(flags, 'days') ?? 365;
     const machine = currentMachine();
     const agentImport = emptyReport();
     const learn = !flags['no-learn'];
     for (const repo of repos) {
-        const alreadyExists = initScannedRepo(repo, globalRoot);
-        const { added, lowInfo } = learnScannedRepo(repo, seedDays, learn, machine, agentImport);
+        const alreadyExists = initScannedRepo(repo, tenantId, globalRoot);
+        const { added, lowInfo } = await learnScannedRepo(repo, tenantId, seedDays, learn, machine, agentImport);
         totalLessons += added;
         totalLowInfo += lowInfo;
         const status = alreadyExists ? 'existing' : 'new';
-        const entries = loadAllEntries(path.join(repo, '.hippo'));
+        const entries = listMemories(cliApiContext(path.join(repo, '.hippo'), tenantId), { everyTenant: true });
         console.log(`  ${path.basename(repo).padEnd(25)} ${status.padEnd(10)} ${entries.length} memories${added > 0 ? ` (+${added} from git)` : ''}`);
     }
     printScanSummary(repos.length, totalLessons, totalLowInfo);
@@ -144,12 +153,12 @@ function initGlobalOnly(flags) {
     if (!flags['no-learn'])
         printAgentImport(importUserMemories(globalRoot, { machine: currentMachine() }));
 }
-function seedFromGitHistory(hippoRoot) {
+async function seedFromGitHistory(hippoRoot, tenantId) {
     if (!isGitRepo(process.cwd()))
         return;
     const seedDays = 30;
     console.log(`\n   Seeding memories from last ${seedDays} days of git history...`);
-    const { added, skipped } = learnFromRepo(hippoRoot, process.cwd(), seedDays);
+    const { added, skipped } = await learnFromRepo(hippoRoot, tenantId, process.cwd(), seedDays);
     if (added > 0) {
         console.log(`   Learned ${added} lessons from git (${skipped} duplicates skipped).`);
     }
@@ -157,11 +166,11 @@ function seedFromGitHistory(hippoRoot) {
         console.log(`   No matching commits found in git history.`);
     }
 }
-export function handleInit({ hippoRoot, flags }) {
+export async function handleInit({ hippoRoot, tenantId, flags }) {
     // Handle --scan mode
     if (flags['scan']) {
         const scanDir = stringFlag(flags, 'scan') ?? os.homedir();
-        cmdInitScan(scanDir, flags);
+        await cmdInitScan(scanDir, tenantId, flags);
         return;
     }
     if (flags['global']) {
@@ -173,7 +182,7 @@ export function handleInit({ hippoRoot, flags }) {
         console.log('Already initialized at', hippoRoot);
     }
     else {
-        initStore(hippoRoot);
+        initMemoryStore(cliApiContext(hippoRoot, tenantId));
         console.log('Initialized Hippo at', hippoRoot);
         console.log('   Directories: buffer/ episodic/ semantic/ conflicts/');
         console.log('   Files: hippo.db stats.json');
@@ -190,7 +199,7 @@ export function handleInit({ hippoRoot, flags }) {
     const learn = !flags['no-learn'] && !skipLearnOnSharedStore(hippoRoot);
     // Seed with git history on first init (unless --no-learn)
     if (!alreadyExists && learn && !flags['global'])
-        seedFromGitHistory(hippoRoot);
+        await seedFromGitHistory(hippoRoot, tenantId);
     // Every run, not only the first: an agent's notes change between inits.
     if (learn)
         printAgentImport(importForStore(hippoRoot, { machine: currentMachine() }));

package/dist/cli/install-steps.d.ts

@@ -1,7 +1,8 @@
 import { type InstallResult } from '../hooks/json-hooks.js';
 /** Adds hippo's two Codex hooks and says what changed; each install ends on the trust reminder, since Codex skips an untrusted hook. */
 export declare function installCodexMemoryHooks(indent: string): void;
-/** 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. */
+/** 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 declare function warnClaudeSettingsUnusable(result: Pick<InstallResult, 'settingsPath' | 'invalidJson'>, indent: string, action?: 'install' | 'uninstall'): boolean;
 export declare function setupDailySchedule(globalRoot: string): void;
 //# sourceMappingURL=install-steps.d.ts.map