hippo-memory 1.70.0 → 1.72.0

package/dist/cli/goals.js

@@ -1,46 +1,48 @@
 // `hippo goal`: the per-session goal stack that recall boosts.
-import { envHippoSessionId } from '../util/env.js';
+import { DEFAULT_TENANT_ID, envHippoSessionId } from '../util/env.js';
 import * as api from '../api/index.js';
-import { resolveTenantId } from '../store/tenant.js';
+import { cliApiContext } from './api-context.js';
 import { printError } from './output.js';
-import { boolFlag, flagIsTrue, stringFlag } from './flag-values.js';
-// ---------------------------------------------------------------------------
+import { boolFlag, flagIsTrue, isStringFlag, stringFlag } from './flag-values.js';
+import { CliExit } from './exit.js';
 // `hippo goal <push|list|complete|suspend|resume>`
-// ---------------------------------------------------------------------------
 const GOAL_POLICY_TYPES = [
     'schema-fit-biased',
     'error-prioritized',
     'recency-first',
     'hybrid',
 ];
+function isGoalPolicyType(value) {
+    return GOAL_POLICY_TYPES.some((type) => type === value);
+}
 function sanitizeGoalName(s) {
     // Strip C0 control chars + DEL to prevent terminal escape injection.
-    return s.replace(/[\x00-\x1f\x7f]/g, '?');
+    return s.replace(/[^\x20-\x7e\u0080-\uffff]/g, '?');
 }
-function resolveGoalSession(flags) {
+function resolveGoalSession(flags, defaultTenantId) {
     const sessionId = (flags['session-id'] !== undefined
         ? String(flags['session-id'])
         : envHippoSessionId() ?? '').trim();
     if (!sessionId) {
         printError('session id required (set HIPPO_SESSION_ID or pass --session-id)');
-        process.exit(1);
+        throw new CliExit(1);
     }
     const tenantId = (flags['tenant-id'] !== undefined
         ? String(flags['tenant-id'])
-        : resolveTenantId({})).trim() || 'default';
+        : defaultTenantId).trim() || DEFAULT_TENANT_ID;
     return { sessionId, tenantId };
 }
 function readGoalPolicy(flags) {
     const policyRaw = flags['policy'];
     if (policyRaw === true) {
         printError('--policy requires a value (e.g., --policy error-prioritized)');
-        process.exit(1);
+        throw new CliExit(1);
     }
-    if (typeof policyRaw !== 'string')
+    if (!isStringFlag(policyRaw))
         return undefined;
-    if (!GOAL_POLICY_TYPES.includes(policyRaw)) {
+    if (!isGoalPolicyType(policyRaw)) {
         printError(`Unknown --policy '${policyRaw}'. Expected one of: ${GOAL_POLICY_TYPES.join(' | ')}.`);
-        process.exit(1);
+        throw new CliExit(1);
     }
     return { policyType: policyRaw };
 }
@@ -48,44 +50,44 @@ function readGoalLevel(flags) {
     const levelRaw = flags['level'];
     if (levelRaw === true) {
         printError('--level requires a value (e.g., --level 1)');
-        process.exit(1);
+        throw new CliExit(1);
     }
     if (levelRaw === undefined)
         return undefined;
     const parsed = Number(levelRaw);
     if (!Number.isFinite(parsed) || parsed < 0 || parsed > 2 || !Number.isInteger(parsed)) {
         printError('--level must be an integer in [0, 2]');
-        process.exit(1);
+        throw new CliExit(1);
     }
     return parsed;
 }
-function cmdGoalPush(hippoRoot, args, flags) {
+function cmdGoalPush(hippoRoot, defaultTenantId, args, flags) {
     const rawName = args.join(' ').trim();
     if (!rawName) {
         printError('Usage: hippo goal push <name> [--policy <type>] [--success "<condition>"] [--level N] [--parent <goalId>]');
-        process.exit(1);
+        throw new CliExit(1);
     }
     // Sanitize at WRITE time so corrupt names never enter the DB.
     const name = sanitizeGoalName(rawName);
     if (name !== rawName) {
         printError('note: stripped control characters from goal name');
     }
-    const { sessionId, tenantId } = resolveGoalSession(flags);
+    const { sessionId, tenantId } = resolveGoalSession(flags, defaultTenantId);
     const policy = readGoalPolicy(flags);
     const successRaw = flags['success'];
     if (successRaw === true) {
         printError('--success requires a value (e.g., --success "<condition>")');
-        process.exit(1);
+        throw new CliExit(1);
     }
     const successCondition = stringFlag(flags, 'success');
     const level = readGoalLevel(flags);
     const parentRaw = flags['parent'];
     if (parentRaw === true) {
         printError('--parent requires a value (e.g., --parent <goalId>)');
-        process.exit(1);
+        throw new CliExit(1);
     }
     const parentGoalId = stringFlag(flags, 'parent');
-    const goal = api.goalPush(goalContext(hippoRoot, tenantId), {
+    const goal = api.goalPush(cliApiContext(hippoRoot, tenantId), {
         sessionId,
         goalName: name,
         level,
@@ -95,21 +97,15 @@ function cmdGoalPush(hippoRoot, args, flags) {
     });
     console.log(goal.id);
 }
-function goalContext(hippoRoot, tenantId = resolveTenantId({})) {
-    return { hippoRoot, tenantId, actor: api.adminActor('cli') };
-}
-function cmdGoalList(hippoRoot, flags) {
-    const { sessionId, tenantId } = resolveGoalSession(flags);
+function cmdGoalList(hippoRoot, defaultTenantId, flags) {
+    const { sessionId, tenantId } = resolveGoalSession(flags, defaultTenantId);
     const showAll = boolFlag(flags, 'all');
-    const goals = api.goalList(goalContext(hippoRoot, tenantId), { sessionId, all: showAll });
+    const goals = api.goalList(cliApiContext(hippoRoot, tenantId), { sessionId, all: showAll });
     if (goals.length === 0) {
         console.log('(no goals)');
         return;
     }
-    // 4-column table: id, status, goal_name, outcome. Plan calls it a "2-column"
-    // table but the assertion list (id, status, goal_name, outcome) needs four;
-    // tests check for substrings ('active', '0.9', name) so column count is
-    // observably four but not asserted.
+    // Four columns (id, status, goal_name, outcome); tests only check substrings, so the count is not asserted.
     const rows = goals.map(g => ({
         id: g.id,
         status: g.status,
@@ -128,74 +124,74 @@ function cmdGoalList(hippoRoot, flags) {
         console.log(`${pad(r.id, widths.id)}  ${pad(r.status, widths.status)}  ${pad(r.name, widths.name)}  ${pad(r.outcome, widths.outcome)}`);
     }
 }
-function cmdGoalComplete(hippoRoot, args, flags) {
+function cmdGoalComplete(hippoRoot, tenantId, args, flags) {
     const id = args[0];
     if (!id) {
         printError('Usage: hippo goal complete <id> [--outcome <0..1>] [--no-propagate]');
-        process.exit(1);
+        throw new CliExit(1);
     }
     let outcomeScore;
     const outcomeRaw = flags['outcome'];
     if (outcomeRaw === true) {
         printError('--outcome requires a value (e.g., --outcome 0.9)');
-        process.exit(1);
+        throw new CliExit(1);
     }
     if (outcomeRaw !== undefined) {
         const parsed = Number(outcomeRaw);
         if (!Number.isFinite(parsed) || parsed < 0 || parsed > 1) {
             printError('--outcome must be a number in [0, 1]');
-            process.exit(1);
+            throw new CliExit(1);
         }
         outcomeScore = parsed;
     }
     const noPropagate = flagIsTrue(flags, 'no-propagate');
-    api.goalComplete(goalContext(hippoRoot), id, { outcomeScore, noPropagate });
+    api.goalComplete(cliApiContext(hippoRoot, tenantId), id, { outcomeScore, noPropagate });
     console.log('ok');
 }
-function cmdGoalSuspend(hippoRoot, args) {
+function cmdGoalSuspend(hippoRoot, tenantId, args) {
     const id = args[0];
     if (!id) {
         printError('Usage: hippo goal suspend <id>');
-        process.exit(1);
+        throw new CliExit(1);
     }
-    api.goalSuspend(goalContext(hippoRoot), id);
+    api.goalSuspend(cliApiContext(hippoRoot, tenantId), id);
     console.log('ok');
 }
-function cmdGoalResume(hippoRoot, args) {
+function cmdGoalResume(hippoRoot, tenantId, args) {
     const id = args[0];
     if (!id) {
         printError('Usage: hippo goal resume <id>');
-        process.exit(1);
+        throw new CliExit(1);
     }
-    api.goalResume(goalContext(hippoRoot), id);
+    api.goalResume(cliApiContext(hippoRoot, tenantId), id);
     console.log('ok');
 }
-export function cmdGoal(hippoRoot, args, flags) {
+export function handleGoal({ hippoRoot, tenantId, args, flags }) {
     const sub = args[0];
     if (!sub) {
         printError('Usage: hippo goal <push|list|complete|suspend|resume> [args]');
-        process.exit(1);
+        throw new CliExit(1);
     }
     const subArgs = args.slice(1);
     switch (sub) {
         case 'push':
-            cmdGoalPush(hippoRoot, subArgs, flags);
+            cmdGoalPush(hippoRoot, tenantId, subArgs, flags);
             return;
         case 'list':
-            cmdGoalList(hippoRoot, flags);
+            cmdGoalList(hippoRoot, tenantId, flags);
             return;
         case 'complete':
-            cmdGoalComplete(hippoRoot, subArgs, flags);
+            cmdGoalComplete(hippoRoot, tenantId, subArgs, flags);
             return;
         case 'suspend':
-            cmdGoalSuspend(hippoRoot, subArgs);
+            cmdGoalSuspend(hippoRoot, tenantId, subArgs);
             return;
         case 'resume':
-            cmdGoalResume(hippoRoot, subArgs);
+            cmdGoalResume(hippoRoot, tenantId, subArgs);
             return;
         default:
             printError(`Unknown goal subcommand: ${sub}. Expected: push | list | complete | suspend | resume.`);
-            process.exit(1);
+            throw new CliExit(1);
     }
 }
 //# sourceMappingURL=goals.js.map

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,48 +1,28 @@
 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 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.
- */
+/** 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. */
 export declare function logSessionEndImport(logFile: string | null, transcriptPath: string | undefined): void;
-/**
- * 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.
- */
+/** Best-effort log line for the cmdSessionEndWorker snapshot-close step: cmdSleep/cmdCapture restore their console tee before this runs,
+ * so console.log would be lost under the worker's `stdio: 'ignore'`; write to the file directly. */
 export declare function appendSessionEndCloseLog(logFile: string | null, message: string, opts?: {
     startFresh?: boolean;
 }): void;
+/** A session-end step that failed: one warn line, and the same text in the session log, the only place a detached worker's output survives. */
+export declare function reportSessionEndFailure<E>(logFile: string | null, step: string, err: E): void;
 export declare function hostSessionId(): string | undefined;
-/**
- * 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 declare function resetHookInjection(hippoRoot: string, stdinText: string | undefined, requiredSource: string | null): void;
-/**
- * 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.
- */
+/** 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, 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;

package/dist/cli/hook-runtime.js

@@ -2,27 +2,17 @@
 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 { getGlobalRoot } from '../sharing/shared.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';
-import { printError } from './output.js';
-/**
- * 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.
- */
+/** 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. */
 export function logSessionEndImport(logFile, transcriptPath) {
     try {
@@ -37,14 +27,8 @@ export function logSessionEndImport(logFile, transcriptPath) {
         appendSessionEndCloseLog(logFile, `agent memory import failed: ${errorMessage(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.
- */
+/** Best-effort log line for the cmdSessionEndWorker snapshot-close step: cmdSleep/cmdCapture restore their console tee before this runs,
+ * so console.log would be lost under the worker's `stdio: 'ignore'`; write to the file directly. */
 export function appendSessionEndCloseLog(logFile, message, opts = {}) {
     if (!logFile)
         return;
@@ -60,33 +44,29 @@ export function appendSessionEndCloseLog(logFile, message, opts = {}) {
         log.debug(`session-end log not written: ${errorMessage(err)}`);
     }
 }
+/** A session-end step that failed: one warn line, and the same text in the session log, the only place a detached worker's output survives. */
+export function reportSessionEndFailure(logFile, step, err) {
+    const line = `${step} failed: ${errorMessage(err)}`;
+    log.warn(line);
+    appendSessionEndCloseLog(logFile, line);
+}
 // 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) {
+/** 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, 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,
     });
 }
-/**
- * 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.
- */
+/** 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 function hookStoreRoot(hippoRoot) {
     if (isInitialized(hippoRoot))
         return hippoRoot;
@@ -97,30 +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) {
-        // The hook's one-line stderr contract pins this exact text, so it bypasses the leveled logger.
-        printError(`[hippo] 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;
@@ -136,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 });

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 CliFlags } from './flag-values.js';
-export declare function cmdInit(hippoRoot: string, flags: CliFlags): void;
+import { type CommandContext } from './flag-values.js';
+export declare function handleInit({ hippoRoot, tenantId, flags }: CommandContext): void;
 //# sourceMappingURL=init.d.ts.map