hippo-memory 1.71.0 → 1.72.0

package/dist/cli/flags.d.ts

@@ -6,295 +6,6 @@ export interface VerbFlags {
     readonly numbers?: readonly string[];
     readonly lists?: readonly string[];
 }
-export declare const VERB_FLAGS: {
-    init: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    remember: {
-        switches: string[];
-        values: string[];
-        lists: string[];
-    };
-    recall: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    drill: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    assemble: {
-        switches: string[];
-        values: string[];
-    };
-    supersede: {
-        switches: string[];
-        values: string[];
-        lists: string[];
-    };
-    explain: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    eval: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    trace: {
-        switches: string[];
-        values: string[];
-        lists: string[];
-    };
-    refine: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    sleep: {
-        switches: string[];
-        values: string[];
-    };
-    'last-sleep': {
-        switches: string[];
-        values: string[];
-    };
-    'session-end': {
-        switches: string[];
-        values: string[];
-    };
-    '__session-end-worker': {
-        switches: string[];
-        values: string[];
-    };
-    'pre-compact': {
-        values: string[];
-    };
-    'post-compact': {
-        values: string[];
-    };
-    'capture-error': {
-        values: string[];
-    };
-    'compact-resume': {};
-    'codex-run': {};
-    '__codex-session-end-worker': {
-        values: string[];
-    };
-    dedup: {
-        switches: string[];
-        numbers: string[];
-    };
-    dag: {
-        switches: string[];
-    };
-    auth: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    goal: {
-        switches: string[];
-        values: string[];
-    };
-    slack: {
-        switches: string[];
-        values: string[];
-    };
-    github: {
-        switches: string[];
-        values: string[];
-    };
-    audit: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    'correction-latency': {
-        switches: string[];
-    };
-    provenance: {
-        switches: string[];
-    };
-    status: {};
-    outcome: {
-        switches: string[];
-        values: string[];
-    };
-    conflicts: {
-        switches: string[];
-        values: string[];
-    };
-    resolve: {
-        switches: string[];
-        values: string[];
-    };
-    reject: {
-        switches: string[];
-        values: string[];
-    };
-    rejections: {
-        switches: string[];
-    };
-    unreject: {
-        switches: string[];
-    };
-    dormant: {
-        switches: string[];
-        numbers: string[];
-    };
-    projects: {
-        switches: string[];
-    };
-    quarantine: {
-        switches: string[];
-    };
-    tokens: {
-        switches: string[];
-        numbers: string[];
-    };
-    failures: {
-        switches: string[];
-        numbers: string[];
-    };
-    doctor: {
-        switches: string[];
-    };
-    'support-bundle': {
-        switches: string[];
-        values: string[];
-    };
-    snapshot: {
-        switches: string[];
-        values: string[];
-    };
-    session: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    handoff: {
-        switches: string[];
-        values: string[];
-        lists: string[];
-    };
-    card: {
-        switches: string[];
-        values: string[];
-        lists: string[];
-    };
-    predict: {
-        values: string[];
-        numbers: string[];
-    };
-    current: {
-        switches: string[];
-    };
-    forget: {
-        switches: string[];
-        values: string[];
-    };
-    inspect: {};
-    context: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    hook: {};
-    setup: {
-        switches: string[];
-    };
-    'daily-runner': {};
-    embed: {
-        switches: string[];
-    };
-    watch: {};
-    learn: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    promote: {};
-    sync: {
-        switches: string[];
-    };
-    share: {
-        switches: string[];
-        numbers: string[];
-    };
-    peers: {
-        switches: string[];
-    };
-    import: {
-        switches: string[];
-        values: string[];
-        lists: string[];
-    };
-    export: {
-        values: string[];
-    };
-    capture: {
-        switches: string[];
-        values: string[];
-    };
-    dashboard: {
-        numbers: string[];
-    };
-    wm: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    mcp: {};
-    serve: {
-        values: string[];
-        numbers: string[];
-    };
-    invalidate: {
-        switches: string[];
-        values: string[];
-    };
-    decide: {
-        values: string[];
-        numbers: string[];
-    };
-    incident: {
-        values: string[];
-        numbers: string[];
-        lists: string[];
-    };
-    process: {
-        values: string[];
-        numbers: string[];
-        lists: string[];
-    };
-    policy: {
-        values: string[];
-        numbers: string[];
-    };
-    skill: {
-        values: string[];
-        numbers: string[];
-    };
-    brief: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    note: {
-        values: string[];
-        numbers: string[];
-    };
-    graph: {
-        switches: string[];
-        values: string[];
-    };
-};
 /** How parseArgs reads `--name` on the verb with these flags; `undefined` is a command the table lacks. */
 export declare function flagKind(verb: VerbFlags | undefined, name: string): FlagKind;
 /** Whether any verb, or the entry point, reads `--name`. */

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,17 +13,16 @@ 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;

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 });

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