hippo-memory 1.70.0 → 1.71.0

package/dist/cli.d.ts

@@ -1,666 +1,284 @@
 #!/usr/bin/env node
-/**
- * Hippo CLI  - biologically-inspired memory system for AI agents.
- *
- * Commands:
- *   hippo init [--global]
- *   hippo remember <text> [--tag <t>] [--error] [--pin] [--global]
- *   hippo recall <query> [--budget <n>] [--json] [--why]
- *   hippo sleep [--dry-run]
- *   hippo status
- *   hippo outcome --good | --bad [--id <id>]
- *   hippo conflicts [--status <status>] [--json]
- *   hippo snapshot <save|show|clear>
- *   hippo session <log|show|latest|resume|complete>
- *   hippo handoff <create|latest|show>
- *   hippo card <create|show|list|claim|heartbeat|block|review|complete|reclaim|comment>
- *   hippo current <show>
- *   hippo forget <id> [--archive --reason "<why>"]
- *   hippo reject <id>|--value "<text>" --reason "<why>"
- *   hippo rejections
- *   hippo unreject <digest-prefix>
- *   hippo dormant [<query>] [--limit <n>] [--json] | restore <id> | forget <id>
- *   hippo projects [--json] | merge <from> <into> [--apply] | repair [--apply]
- *   hippo tokens [--days <n>] [--json] [--global]
- *   hippo doctor [--json]
- *   hippo inspect <id>
- *   hippo embed [--status]
- *   hippo watch "<command>"
- *   hippo learn --git [--days <n>] [--repos <paths>]
- *   hippo daily-runner
- *   hippo promote <id>
- *   hippo sync
- *   hippo decide "<decision>" [--context "<why>"] [--supersedes <id>]
- *   hippo wm <push|read|clear|flush>
- */
 import { type CliFlags, type CommandContext } from './cli/flag-values.js';
+import { type VerbFlags } from './cli/flags.js';
 export declare function parseArgs(argv: string[]): {
     command: string;
     args: string[];
     flags: CliFlags;
 };
 export declare function shouldAutoRepairCodexWrapper(currentCommand: string, flags: CliFlags): boolean;
-/** Every verb main() dispatches, keyed by name, with its handler, aliases and help blocks. */
-export declare const COMMANDS: {
+/** What a verb's row states; its help blocks and flags are looked up by the row's key. */
+interface VerbHandler {
+    readonly run: (ctx: CommandContext) => void | Promise<void>;
+    readonly aliases?: readonly string[];
+    /** Runs in a request scope, opening each store once; set on api-backed verbs, as hook verbs open their own. */
+    readonly scoped?: true;
+}
+interface CommandSpec extends VerbHandler {
+    readonly usage: readonly string[];
+    /** The flags this verb reads; any other flag still parses, and the verb says it ignores it. */
+    readonly flags: VerbFlags;
+}
+/** Every verb main() dispatches, keyed by name; a verb without a VERB_FLAGS entry, or the reverse, fails to compile. */
+export declare const VERB_HANDLERS: {
     init: {
-        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-            numbers: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     remember: {
         run: (c: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-            lists: string[];
-        };
     };
     recall: {
         run: (c: CommandContext) => Promise<void>;
         scoped: true;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-            numbers: string[];
-        };
     };
     drill: {
         run: (c: CommandContext) => Promise<void>;
         scoped: true;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-            numbers: string[];
-        };
     };
     assemble: {
         run: (c: CommandContext) => Promise<void>;
         scoped: true;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-        };
     };
     supersede: {
         run: (c: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-            lists: string[];
-        };
     };
     explain: {
         run: (c: CommandContext) => Promise<void>;
         scoped: true;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-            numbers: string[];
-        };
     };
     eval: {
         run: (c: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-            numbers: string[];
-        };
     };
     trace: {
         run: (c: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-            lists: string[];
-        };
     };
     refine: {
-        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-            numbers: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     sleep: {
-        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
+        run: (c: CommandContext) => Promise<void>;
         scoped: true;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-        };
     };
     'last-sleep': {
-        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     'session-end': {
-        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     '__session-end-worker': {
-        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
-        usage: never[];
-        flags: {
-            switches: string[];
-            values: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     'pre-compact': {
         run: (c: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            values: string[];
-        };
     };
     'post-compact': {
         run: (c: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            values: string[];
-        };
     };
     'capture-error': {
         run: (c: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            values: string[];
-        };
     };
     'compact-resume': {
         run: (c: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {};
     };
     'codex-run': {
-        run: ({ hippoRoot, args }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {};
+        run: (c: CommandContext) => Promise<void>;
     };
     '__codex-session-end-worker': {
-        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
-        usage: never[];
-        flags: {
-            values: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     dedup: {
-        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            numbers: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     dag: {
-        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     auth: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
+        run: (c: CommandContext) => Promise<void>;
         scoped: true;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-        };
     };
     goal: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
+        run: (c: CommandContext) => Promise<void>;
         scoped: true;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-        };
     };
     slack: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     github: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     audit: {
         run: (c: CommandContext) => Promise<void>;
         scoped: true;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-            numbers: string[];
-        };
     };
     'correction-latency': {
         run: (c: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-        };
     };
     provenance: {
         run: (c: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-        };
     };
     status: {
-        run: ({ hippoRoot }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {};
+        run: (c: CommandContext) => Promise<void>;
     };
     outcome: {
-        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
+        run: (c: CommandContext) => Promise<void>;
         scoped: true;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-        };
     };
     conflicts: {
-        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     resolve: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     reject: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     rejections: {
-        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     unreject: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     dormant: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
+        run: (c: CommandContext) => Promise<void>;
         scoped: true;
-        usage: string[];
-        flags: {
-            switches: string[];
-            numbers: string[];
-        };
     };
     projects: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     quarantine: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
+        run: (c: CommandContext) => Promise<void>;
         scoped: true;
-        usage: string[];
-        flags: {
-            switches: string[];
-        };
     };
     tokens: {
-        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
+        run: (c: CommandContext) => Promise<void>;
         scoped: true;
-        usage: string[];
-        flags: {
-            switches: string[];
-            numbers: string[];
-        };
     };
     failures: {
-        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
+        run: (c: CommandContext) => Promise<void>;
         scoped: true;
-        usage: string[];
-        flags: {
-            switches: string[];
-            numbers: string[];
-        };
     };
     doctor: {
         run: (c: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-        };
     };
     'support-bundle': {
         run: (c: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-        };
     };
     snapshot: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     session: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-            numbers: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     handoff: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-            lists: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     card: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-            lists: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     predict: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            values: string[];
-            numbers: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     current: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     forget: {
         run: (c: CommandContext) => Promise<void>;
         scoped: true;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-        };
     };
     inspect: {
         run: (c: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {};
     };
     context: {
         run: (c: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-            numbers: string[];
-        };
     };
     hook: {
-        run: ({ args }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {};
+        run: (c: CommandContext) => Promise<void>;
     };
     setup: {
-        run: ({ flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     'daily-runner': {
-        run: () => Promise<void>;
-        usage: string[];
-        flags: {};
+        run: (c: CommandContext) => Promise<void>;
     };
     embed: {
-        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     watch: {
         run: (c: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {};
     };
     learn: {
-        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
+        run: (c: CommandContext) => Promise<void>;
         scoped: true;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-            numbers: string[];
-        };
     };
     promote: {
         run: (c: CommandContext) => Promise<void>;
         scoped: true;
-        usage: string[];
-        flags: {};
     };
     sync: {
-        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     share: {
         run: (c: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            numbers: string[];
-        };
     };
     peers: {
         run: (c: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-        };
     };
     import: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-            lists: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     export: {
         run: (c: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            values: string[];
-        };
     };
     capture: {
         run: (c: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-        };
     };
     dashboard: {
         run: (c: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            numbers: string[];
-        };
     };
     wm: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-            numbers: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     mcp: {
         run: () => Promise<void>;
-        usage: string[];
-        flags: {};
     };
     serve: {
         run: (c: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            values: string[];
-            numbers: string[];
-        };
     };
     invalidate: {
         run: (c: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-        };
     };
     decide: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            values: string[];
-            numbers: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     incident: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            values: string[];
-            numbers: string[];
-            lists: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     process: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            values: string[];
-            numbers: string[];
-            lists: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     policy: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            values: string[];
-            numbers: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     skill: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            values: string[];
-            numbers: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
     brief: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
+        run: (c: CommandContext) => Promise<void>;
         aliases: string[];
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-            numbers: string[];
-        };
     };
     note: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
+        run: (c: CommandContext) => Promise<void>;
         aliases: string[];
-        usage: string[];
-        flags: {
-            values: string[];
-            numbers: string[];
-        };
     };
     graph: {
-        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
-        usage: string[];
-        flags: {
-            switches: string[];
-            values: string[];
-        };
+        run: (c: CommandContext) => Promise<void>;
     };
 };
+/** Every verb's handler, aliases, help blocks and flags, keyed by name. */
+export declare const COMMANDS: Readonly<Record<"trace" | "session" | "capture" | "dormant" | "pre-compact" | "post-compact" | "session-end" | "outcome" | "eval" | "recall" | "conflicts" | "remember" | "promote" | "supersede" | "forget" | "quarantine" | "policy" | "status" | "hook" | "context" | "tokens" | "compact-resume" | "reject" | "mcp" | "note" | "snapshot" | "incident" | "process" | "skill" | "slack" | "github" | "failures" | "audit" | "embed" | "current" | "explain" | "auth" | "handoff" | "goal" | "inspect" | "sleep" | "dag" | "brief" | "graph" | "projects" | "doctor" | "init" | "drill" | "assemble" | "refine" | "last-sleep" | "__session-end-worker" | "capture-error" | "codex-run" | "__codex-session-end-worker" | "dedup" | "correction-latency" | "provenance" | "resolve" | "rejections" | "unreject" | "support-bundle" | "card" | "predict" | "setup" | "daily-runner" | "watch" | "learn" | "sync" | "share" | "peers" | "import" | "export" | "dashboard" | "wm" | "serve" | "invalidate" | "decide", CommandSpec>>;
 export declare function usageText(): string;
 /** One verb's help blocks as `hippo <verb> --help` prints them, or null for a verb with none. */
 export declare function verbUsage(verb: string): string | null;
 export declare function runCli(argv?: string[]): Promise<void>;
+export {};
 //# sourceMappingURL=cli.d.ts.map