hippo-memory 1.68.0 → 1.70.0

package/dist/cli.d.ts

@@ -33,346 +33,630 @@
  *   hippo decide "<decision>" [--context "<why>"] [--supersedes <id>]
  *   hippo wm <push|read|clear|flush>
  */
-import type { CommandContext } from './cli/shared.js';
-export declare const BOOLEAN_FLAGS: ReadonlySet<string>;
-export declare const KNOWN_FLAGS: ReadonlySet<string>;
+import { type CliFlags, type CommandContext } from './cli/flag-values.js';
 export declare function parseArgs(argv: string[]): {
     command: string;
     args: string[];
-    flags: Record<string, string | boolean | string[]>;
+    flags: CliFlags;
 };
-export declare function shouldAutoRepairCodexWrapper(currentCommand: string, flags: Record<string, string | boolean | string[]>): boolean;
+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: {
     init: {
         run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
         usage: string[];
+        flags: {
+            switches: string[];
+            values: string[];
+            numbers: string[];
+        };
     };
     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[];
+        };
     };
     sleep: {
         run: ({ hippoRoot, flags }: 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[];
+        };
     };
     'session-end': {
         run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
         usage: string[];
+        flags: {
+            switches: string[];
+            values: string[];
+        };
     };
     '__session-end-worker': {
         run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
         usage: never[];
+        flags: {
+            switches: string[];
+            values: string[];
+        };
     };
     '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: {};
     };
     '__codex-session-end-worker': {
         run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
         usage: never[];
+        flags: {
+            values: string[];
+        };
     };
     dedup: {
         run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
         usage: string[];
+        flags: {
+            switches: string[];
+            numbers: string[];
+        };
     };
     dag: {
         run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
         usage: string[];
+        flags: {
+            switches: string[];
+        };
     };
     auth: {
         run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
         scoped: true;
         usage: string[];
+        flags: {
+            switches: string[];
+            values: string[];
+        };
     };
     goal: {
         run: ({ hippoRoot, args, flags }: 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[];
+        };
     };
     github: {
         run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
         usage: string[];
+        flags: {
+            switches: string[];
+            values: string[];
+        };
     };
     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: {};
     };
     outcome: {
         run: ({ hippoRoot, flags }: 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[];
+        };
     };
     resolve: {
         run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
         usage: string[];
+        flags: {
+            switches: string[];
+            values: string[];
+        };
     };
     reject: {
         run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
         usage: string[];
+        flags: {
+            switches: string[];
+            values: string[];
+        };
     };
     rejections: {
         run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
         usage: string[];
+        flags: {
+            switches: string[];
+        };
     };
     unreject: {
         run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
         usage: string[];
+        flags: {
+            switches: string[];
+        };
     };
     dormant: {
         run: ({ hippoRoot, args, flags }: 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[];
+        };
     };
     quarantine: {
         run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
         scoped: true;
         usage: string[];
+        flags: {
+            switches: string[];
+        };
     };
     tokens: {
         run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
         scoped: true;
         usage: string[];
+        flags: {
+            switches: string[];
+            numbers: string[];
+        };
     };
     failures: {
         run: ({ hippoRoot, flags }: 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[];
+        };
     };
     session: {
         run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
         usage: string[];
+        flags: {
+            switches: string[];
+            values: string[];
+            numbers: string[];
+        };
     };
     handoff: {
         run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
         usage: string[];
+        flags: {
+            switches: string[];
+            values: string[];
+            lists: string[];
+        };
     };
     card: {
         run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
         usage: string[];
+        flags: {
+            switches: string[];
+            values: string[];
+            lists: string[];
+        };
     };
     predict: {
         run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
         usage: string[];
+        flags: {
+            values: string[];
+            numbers: string[];
+        };
     };
     current: {
         run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
         usage: string[];
+        flags: {
+            switches: string[];
+        };
     };
     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: {};
     };
     setup: {
         run: ({ flags }: CommandContext) => Promise<void>;
         usage: string[];
+        flags: {
+            switches: string[];
+        };
     };
     'daily-runner': {
         run: () => Promise<void>;
         usage: string[];
+        flags: {};
     };
     embed: {
         run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
         usage: string[];
+        flags: {
+            switches: string[];
+        };
     };
     watch: {
         run: (c: CommandContext) => Promise<void>;
         usage: string[];
+        flags: {};
     };
     learn: {
         run: ({ hippoRoot, flags }: 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[];
+        };
     };
     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[];
+        };
     };
     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[];
+        };
     };
     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[];
+        };
     };
     incident: {
         run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
         usage: string[];
+        flags: {
+            values: string[];
+            numbers: string[];
+            lists: string[];
+        };
     };
     process: {
         run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
         usage: string[];
+        flags: {
+            values: string[];
+            numbers: string[];
+            lists: string[];
+        };
     };
     policy: {
         run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
         usage: string[];
+        flags: {
+            values: string[];
+            numbers: string[];
+        };
     };
     skill: {
         run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
         usage: string[];
+        flags: {
+            values: string[];
+            numbers: string[];
+        };
     };
     brief: {
         run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
         aliases: string[];
         usage: string[];
+        flags: {
+            switches: string[];
+            values: string[];
+            numbers: string[];
+        };
     };
     note: {
         run: ({ hippoRoot, args, flags }: 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[];
+        };
     };
 };
 export declare function usageText(): string;