hippo-memory 1.70.0 → 1.72.0

package/dist/cli/verbs/objects.js

@@ -0,0 +1,254 @@
+// First-class object, server, goal and auth verbs, in `hippo help` order.
+import { DEFAULT_KEY_TTL_DAYS, MAX_TTL_DAYS } from '../../api/auth.js';
+import { DEFAULT_SERVER_HOST, DEFAULT_SERVER_PORT } from '../../server/defaults.js';
+import { verb } from '../verb-row.js';
+export const OBJECT_VERBS = {
+    predict: verb(() => import('../predictions.js'), 'handlePredict', {
+        flags: {
+            values: ['actual', 'class', 'estimate', 'note', 'state', 'status', 'target', 'unit'],
+            numbers: ['limit'],
+        },
+        usage: [`
+  predict "<claim>"        Record a prediction to score against the actual outcome later
+    --class <c>            Reference class (required)
+    --estimate <v>         Numeric estimate
+    --unit <u>             Unit of the estimate
+    --target <YYYY-MM-DD>  When the outcome is due
+  predict close <id>       Close a prediction
+    --state <s>            closed | closed-unknown (required)
+    --actual <v>           The actual value
+    --note "<text>"        Closure note
+  predict list [--class <c>] [--status open|closed|closed-unknown|all] [--limit N]
+                           List predictions (closed and closed-unknown need --class)
+  predict show <id>        Show one prediction
+  predict baserate --class <c>
+                           How past estimates in a class compared with the actuals`],
+    }),
+    decide: verb(() => import('../decisions.js'), 'handleDecide', {
+        flags: { values: ['context', 'status', 'supersedes'], numbers: ['limit'] },
+        usage: [`
+  decide "<decision>"      Record a decision (first-class object + memory mirror)
+    --context "<why>"      Why this decision was made
+    --supersedes <mem-id>  Supersede the decision backed by this memory id
+  decide list [--status active|superseded|closed|all] [--limit N]
+                           List decisions (table is authoritative, survives decay)
+  decide get <id>          Show a decision by its table id
+  decide close <id>        Retire (close) an active decision by its table id`],
+    }),
+    incident: verb(() => import('../incidents.js'), 'handleIncident', {
+        flags: { values: ['context', 'resolution', 'status'], numbers: ['limit'], lists: ['link'] },
+        usage: [`
+  incident "<incident>"    Record an incident (first-class object + memory mirror)
+    --context "<details>"  What happened / surrounding detail
+    --link <mem-id>        Link a memory as evidence (repeatable)
+  incident list [--status open|resolved|closed|all] [--limit N]
+                           List incidents (table is authoritative, survives decay)
+  incident get <id>        Show an incident by its table id
+  incident resolve <id>    Resolve an open incident (open -> resolved)
+    --resolution "<text>"  How it was resolved (required)
+  incident close <id>      Retire (close) an open or resolved incident by its table id`],
+    }),
+    process: verb(() => import('../playbooks.js'), 'handleProcess', {
+        flags: { values: ['change', 'description', 'status'], numbers: ['limit'], lists: ['step'] },
+        usage: [`
+  process new "<name>"     Record a process map (first-class object + memory mirror)
+    --step "<text>"        An ordered step (repeatable)
+    --description "<text>" Optional summary of the process
+  process list [--status active|superseded|closed|all] [--limit N]
+                           List processes (table is authoritative, survives decay)
+  process get <id>         Show a process (with its steps) by its table id
+  process supersede <id>   Record a new version that supersedes an active process
+    --step "<text>"        A step of the new version (repeatable, required)
+    --change "<summary>"   What changed in this version (the delta note)
+    --description "<text>" Optional summary of the new version
+  process close <id>       Retire (close) an active process by its table id`],
+    }),
+    policy: verb(() => import('../playbooks.js'), 'handlePolicy', {
+        flags: { values: ['change', 'from', 'name', 'status', 'text', 'to'], numbers: ['limit'] },
+        usage: [`
+  policy new "<name>"      Record a policy (bi-temporal first-class object + mirror)
+    --text "<rule>"        The policy rule/statement (required)
+    --from "<iso>"         Effective-from date (default: now)
+    --to "<iso>"           Effective-to date (optional; open-ended if omitted)
+  policy list [--status active|superseded|closed|all] [--limit N]
+                           List policies (table is authoritative, survives decay)
+  policy get <id>          Show a policy by its table id
+  policy asof "<iso-date>" Show active policies in force at a valid-time
+    --name "<policy>"      Filter to one policy by name
+  policy supersede <id>    Record a new version that supersedes an active policy
+    --text "<rule>"        The new rule (required)
+    --from "<iso>"         New effective-from (default: now)
+    --to "<iso>"           New effective-to (optional)
+    --change "<summary>"   What changed in this version (the delta note)
+  policy close <id>        Retire (close) an active policy by its table id`],
+    }),
+    skill: verb(() => import('../playbooks.js'), 'handleSkill', {
+        flags: { values: ['change', 'instructions', 'status', 'trigger'], numbers: ['limit'] },
+        usage: [`
+  skill new "<name>"       Record a skill (reusable agent-followable capability)
+    --instructions "<txt>" The skill body (required)
+    --trigger "<when>"     Optional: when to apply this skill
+  skill list [--status active|superseded|closed|all] [--limit N]
+                           List skills (table is authoritative, survives decay)
+  skill get <id>           Show a skill by its table id
+  skill export             Render active skills as an AGENTS.md/CLAUDE.md markdown block
+  skill supersede <id>     Record a new version that supersedes an active skill
+    --instructions "<txt>" The new skill body (required)
+    --trigger "<when>"     Optional new trigger
+    --change "<summary>"   What changed in this version (the delta note)
+  skill close <id>         Retire (close) an active skill by its table id`],
+    }),
+    brief: verb(() => import('../briefs.js'), 'handleProjectBrief', {
+        aliases: ['project-brief'],
+        dryRun: { form: 'refresh', honoured: (args) => args[0] === 'refresh' },
+        flags: { switches: ['dry-run'], values: ['change', 'repo', 'status', 'summary'], numbers: ['limit'] },
+        usage: [`
+  brief new "<repo>"       Record a repo-scoped project brief
+    --summary "<text>"     The brief body (required)
+  brief list [--status active|superseded|closed|all] [--repo "<repo>"] [--limit N]
+                           List project briefs (table is authoritative, survives decay)
+  brief get <id>           Show a project brief by its table id
+  brief supersede <id>     Record a new version that supersedes an active brief
+    --summary "<text>"     The new brief body (required)
+    --change "<summary>"   What changed in this version (the delta note)
+  brief close <id>         Retire (close) an active project brief by its table id
+  brief refresh "<repo>"   Auto-assemble the brief from the repo's receipts (path:<repo>)
+    --dry-run              Print the assembled brief without writing it`],
+    }),
+    note: verb(() => import('../notes.js'), 'handleCustomerNote', {
+        aliases: ['customer-note'],
+        flags: { values: ['change', 'customer', 'status', 'text'], numbers: ['limit'] },
+        usage: [`
+  note new "<customer>"    Record a customer/account-scoped note
+    --text "<note>"        The note body (required)
+  note list [--status active|superseded|closed|all] [--customer "<id>"] [--limit N]
+                           List customer notes (table is authoritative, survives decay)
+  note get <id>            Show a customer note by its table id
+  note supersede <id>      Record a new version that supersedes an active note
+    --text "<note>"        The new note body (required)
+    --change "<summary>"   What changed in this version (the delta note)
+  note close <id>          Retire (close) an active customer note by its table id`],
+    }),
+    graph: verb(() => import('../graph.js'), 'handleGraph', {
+        flags: { switches: ['json', 'open'], values: ['entity', 'format', 'out'] },
+        usage: [`
+  graph extract            Rebuild the entity/relation graph from consolidated objects
+                           (decisions/policies/customer-notes/project-briefs); idempotent`],
+    }),
+    invalidate: verb(() => import('../curate.js'), 'handleInvalidate', {
+        destructive: true,
+        flags: { switches: ['churn', 'dry-run'], values: ['id', 'reason'] },
+        usage: [`
+  invalidate "<pattern>"   Actively weaken memories matching an old pattern
+                           (content overlap, or a tag EXACTLY equal to the
+                           full pattern - never token-level tag matching)
+    --id <memory-id>       Invalidate exactly one memory (instead of a pattern)
+    --dry-run              Preview what would be hit; writes nothing
+                           Note: a pattern equal to the system tag
+                           'invalidated' re-weakens previously invalidated
+                           memories - preview with --dry-run first
+    --reason "<why>"       Optional: what replaced it
+  invalidate --churn       FE2: tag memories 'churn-stale' whose named file
+                           changed or was deleted, or whose named symbol or
+                           npm script was removed, in this repo's git history
+                           since the memory was stored or confirmed
+    --dry-run              Preview what would be tagged; writes nothing`],
+    }),
+    wm: verb(() => import('../continuity.js'), 'handleWm', {
+        flags: { switches: ['json'], values: ['content', 'importance', 'scope', 'session', 'task'], numbers: ['limit'] },
+        usage: [`
+  wm <sub>                 Working memory — bounded buffer for current state
+    wm push                Push a working memory entry
+      --scope <scope>      Scope name (default: default)
+      --content <text>     Content to store (required)
+      --importance <n>     Priority 0-1 (default: 0.5)
+      --session <id>       Session ID
+      --task <id>          Task ID
+    wm read                Read working memory entries
+      --scope <scope>      Filter by scope
+      --session <id>       Filter by session
+      --limit <n>          Max entries (default: 20)
+      --json               Output as JSON
+    wm clear               Clear working memory entries
+      --scope <scope>      Filter by scope
+      --session <id>       Filter by session
+    wm flush               Same as clear; nothing runs it at session end
+      --scope <scope>      Filter by scope
+      --session <id>       Filter by session`],
+    }),
+    dashboard: verb(() => import('../serve.js'), 'handleDashboard', {
+        flags: { numbers: ['port'] },
+        usage: [`
+  dashboard                Open web dashboard for memory health
+    --port <n>             Port to serve on (default: 3333)`],
+    }),
+    mcp: verb(() => import('../serve.js'), 'handleMcp', {
+        flags: {},
+        usage: [`
+  mcp                      Start MCP server (stdio transport)`],
+    }),
+    serve: verb(() => import('../serve.js'), 'handleServe', {
+        flags: { values: ['host', 'tls-cert', 'tls-key'], numbers: ['port'] },
+        usage: [`
+  serve                    Start the HTTP API server for this store (Ctrl+C stops it)
+    --port <n>             Port to serve on (default: $HIPPO_PORT or ${DEFAULT_SERVER_PORT})
+    --host <host>          Address to bind (default: ${DEFAULT_SERVER_HOST})
+    --tls-cert <file>      PEM certificate; serve HTTPS only (or $HIPPO_TLS_CERT)
+    --tls-key <file>       PEM private key for it; give both (or $HIPPO_TLS_KEY)
+                           Every request needs an API key (hippo auth create).
+                           $HIPPO_ALLOW_KEYLESS_LOCAL=1 lets requests from this machine
+                           in without one; $HIPPO_REQUIRE_AUTH=1 wins over it.`],
+    }),
+    goal: verb(() => import('../goals.js'), 'handleGoal', {
+        scoped: true,
+        flags: {
+            switches: ['all', 'no-propagate'],
+            values: ['level', 'outcome', 'parent', 'policy', 'session-id', 'success', 'tenant-id'],
+        },
+        usage: [`
+  goal <sub>               dlPFC goal stack (B3) — scoped per session
+    goal push <name>       Push a new active goal; prints the new goal id
+      --policy <type>      schema-fit-biased | error-prioritized |
+                           recency-first | hybrid
+      --success "<cond>"   Optional success condition text
+      --level <n>          Goal level (default: 0)
+      --parent <goalId>    Parent goal id (for sub-goals)
+      --session-id <s>     Override session (defaults to HIPPO_SESSION_ID)
+      --tenant-id <t>      Override tenant (defaults to HIPPO_TENANT)
+    goal list              Show active goals as a table
+      --all                Include suspended/completed goals
+    goal complete <id>     Mark a goal completed
+      --outcome <0..1>     Outcome score; >=0.7 boosts, <0.3 decays recalled mems
+      --no-propagate       Close the goal without applying strength side-effects
+    goal suspend <id>      Move an active goal to suspended
+    goal resume <id>       Move a suspended goal back to active (depth-capped)`],
+    }),
+    auth: verb(() => import('../auth.js'), 'handleAuth', {
+        scoped: true,
+        flags: { switches: ['all', 'global', 'json', 'no-expiry'], values: ['label', 'role', 'tenant'], numbers: ['ttl-days'] },
+        usage: [`
+  auth <sub>               Manage API keys (A5 stub auth)
+    auth create            Mint a new API key (plaintext shown ONCE)
+      --label <s>          Optional human label
+      --role <r>           admin | member (default: member; member blocked from /v1/sleep)
+      --ttl-days <n>       Days until the key expires (default: ${DEFAULT_KEY_TTL_DAYS}, at most ${MAX_TTL_DAYS})
+      --no-expiry          Mint a key that never expires
+      --tenant <id>        Override tenant (defaults to HIPPO_TENANT)
+      --json               Output as JSON
+      --global             Operate on the global store
+    auth list              List API keys (active by default)
+      --all                Include revoked and expired keys
+      --json               Output as JSON
+      --global             Operate on the global store
+    auth revoke <key_id>   Revoke an API key (subsequent validate fails)
+      --json               Output as JSON
+      --global             Operate on the global store
+    auth grant <key_id> <scope>    Let a member key read one restricted scope
+      --json               Output as JSON
+      --global             Operate on the global store
+    auth ungrant <key_id> <scope>  Remove a scope grant
+      --json               Output as JSON
+      --global             Operate on the global store`],
+    }),
+};
+//# sourceMappingURL=objects.js.map

package/dist/cli/verbs/sessions.d.ts

@@ -0,0 +1,31 @@
+import { type VerbSpec } from '../verb-row.js';
+export declare const SESSION_VERBS: {
+    snapshot: VerbSpec;
+    session: VerbSpec;
+    handoff: VerbSpec;
+    card: VerbSpec;
+    current: VerbSpec;
+    forget: VerbSpec;
+    inspect: VerbSpec;
+    embed: VerbSpec;
+    watch: VerbSpec;
+    learn: VerbSpec;
+    promote: VerbSpec;
+    share: VerbSpec;
+    peers: VerbSpec;
+    sync: VerbSpec;
+    import: VerbSpec;
+    export: VerbSpec;
+    capture: VerbSpec;
+    setup: VerbSpec;
+    'last-sleep': VerbSpec;
+    'session-end': VerbSpec;
+    '__session-end-worker': VerbSpec;
+    'pre-compact': VerbSpec;
+    'compact-resume': VerbSpec;
+    'post-compact': VerbSpec;
+    'codex-run': VerbSpec;
+    '__codex-session-end-worker': VerbSpec;
+    hook: VerbSpec;
+};
+//# sourceMappingURL=sessions.d.ts.map

package/dist/cli/verbs/sessions.js

@@ -0,0 +1,312 @@
+// Continuity, transfer, capture and agent-hook verbs, in `hippo help` order.
+import { boolFlag } from '../flag-values.js';
+import { verb } from '../verb-row.js';
+export const SESSION_VERBS = {
+    snapshot: verb(() => import('../continuity.js'), 'handleSnapshot', {
+        flags: { switches: ['json'], values: ['id', 'next-step', 'session', 'source', 'status', 'summary', 'task'] },
+        usage: [`
+  snapshot <sub>           Persist or inspect the current active task
+    snapshot save          Save active task state
+      --task <task>
+      --summary <summary>
+      --next-step <step>
+      --source <source>    Optional source label
+      --session <id>       Link snapshot to a session trail
+    snapshot show          Show the active task snapshot
+      --json               Output as JSON
+    snapshot clear         Clear the active task snapshot
+      --status <status>    Mark final status (default: cleared)`],
+    }),
+    session: verb(() => import('../continuity.js'), 'handleSession', {
+        flags: {
+            switches: ['json'],
+            values: ['content', 'id', 'outcome', 'session', 'source', 'summary', 'task', 'type'],
+            numbers: ['limit'],
+        },
+        usage: [`
+  session <sub>            Append or inspect short-term session history
+    session log            Append a structured session event
+      --id <session-id>
+      --content <text>
+      --type <type>        Event type (default: note)
+      --task <task>        Optional task label
+      --source <source>    Optional source label
+    session show           Show recent events for a session or task
+      --id <session-id>
+      --task <task>
+      --limit <n>          Event limit (default: 8)
+      --json               Output as JSON
+    session latest         Show latest task snapshot + events
+      --id <session-id>   Filter by session
+      --json               Output as JSON
+    session resume         Re-inject latest handoff as context output
+      --id <session-id>   Filter by session`],
+    }),
+    handoff: verb(() => import('../continuity.js'), 'handleHandoff', {
+        flags: {
+            switches: ['json'],
+            values: ['card-id', 'id', 'next', 'outcome', 'session', 'summary', 'target-runtime', 'task', 'tests'],
+            lists: ['artifact', 'constraint'],
+        },
+        usage: [`
+  handoff <sub>            Manage session handoffs for continuity
+    handoff create         Create a new session handoff
+      --summary <text>     Handoff summary (required)
+      --next <text>        Next action for successor
+      --session <id>       Session ID (auto-generated if omitted)
+      --task <id>          Associated task ID
+      --artifact <path>    Related file path (repeatable)
+      --constraint <text>  Constraint for the successor to respect (repeatable)
+      --outcome <o>        success | failure | partial
+      --target-runtime <n> Name of the runtime the successor will run in
+      --card-id <id>       Associated card/ticket ID
+      --tests <status>     pass | fail | unknown (default: unknown)
+    handoff latest         Show the most recent handoff
+      --session <id>       Filter by session
+      --json               Output as JSON
+    handoff show <id>      Show a specific handoff by ID`],
+    }),
+    card: verb(() => import('../card.js'), 'handleCard', {
+        // Every card subcommand's flags together; card.ts then refuses the ones its subcommand does not read.
+        flags: {
+            switches: ['json'],
+            values: ['author', 'body', 'budget', 'contract', 'outcome', 'reason', 'repo', 'run', 'runtime', 'session',
+                'status', 'title'],
+            lists: ['depends-on'],
+        },
+        usage: [`
+  card <sub>                Manage claimable work-queue cards
+    card create             Create a new card
+      --title <text>        Card title (required)
+      --repo <name>         Associated repo
+      --contract <text>     Associated contract
+      --budget <n>           Token/step budget
+      --depends-on <id>     Parent card id (repeatable)
+    card show <id>          Show a card, its deps, runs, comments and latest handoff
+      --json                 Output as JSON
+    card list                List cards, newest-updated first
+      --status <status>     Filter by status
+    card claim <id>          Claim a ready or blocked card; prints its run id and lease
+      --runtime <name>       Claiming runtime (required)
+      --session <id>         Session ID
+    card heartbeat <id>       Extend a running card's lease
+      --run <n>              Your run id, as card claim printed it (required)
+    card block <id>           Block a running card
+      --reason "<why>"       Reason recorded as a card comment (required)
+      --run <n>              Refuse unless <n> is the card's live run
+    card review <id>          Move a running card to review
+      --run <n>              Refuse unless <n> is the card's live run
+    card complete <id>       Complete a card in review
+      --outcome <o>          success | failure | partial (required)
+      --run <n>              Refuse unless <n> is the card's live run
+    card reclaim              Return every running card whose lease has expired to ready
+    card comment <id>         Add a comment to a card
+      --body <text>          Comment body (required)
+      --author <name>       Comment author (default: cli)`],
+    }),
+    current: verb(() => import('../continuity.js'), 'handleCurrent', {
+        flags: { switches: ['json'] },
+        usage: [`
+  current <sub>            Show compact current state for agent injection
+    current show           Active task + recent session events (default)
+      --json               Output as JSON`],
+    }),
+    forget: verb(() => import('../curate.js'), 'handleForget', {
+        destructive: true,
+        scoped: true,
+        flags: { switches: ['archive', 'dry-run'], values: ['reason'] },
+        usage: [`
+  forget <id>              Force remove a memory
+    --archive              Archive a raw (append-only) memory instead of deleting
+    --reason "<why>"       Reason recorded on the archive (required with --archive)`],
+    }),
+    inspect: verb(() => import('../status.js'), 'handleInspect', {
+        flags: {},
+        usage: [`
+  inspect <id>             Show full memory detail`],
+    }),
+    embed: verb(() => import('../maintenance.js'), 'handleEmbed', {
+        flags: { switches: ['global', 'reset-physics', 'status'] },
+        usage: [`
+  embed                    Embed all memories for semantic search
+    --status               Show embedding coverage`],
+    }),
+    watch: verb(() => import('../transfer.js'), 'handleWatch', {
+        flags: {},
+        usage: [`
+  watch "<command>"        Run command, auto-learn from failures`],
+    }),
+    learn: verb(() => import('../transfer.js'), 'handleLearn', {
+        scoped: true,
+        flags: { switches: ['git'], values: ['repos'], numbers: ['days'] },
+        usage: [`
+  learn                    Learn lessons from repository history
+    --git                  Scan recent git commits for lessons
+    --days <n>             Scan this many days back (default: 7)
+    --repos <paths>        Comma-separated repo paths to scan`],
+    }),
+    promote: verb(() => import('../transfer.js'), 'handlePromote', {
+        scoped: true,
+        flags: {},
+        usage: [`
+  promote <id>             Copy a local memory to the global store`],
+    }),
+    share: verb(() => import('../transfer.js'), 'handleShare', {
+        dryRun: { form: '--auto', honoured: (args, flags) => args[0] === '--auto' || boolFlag(flags, 'auto') },
+        flags: { switches: ['auto', 'dry-run', 'force'], numbers: ['min-score'] },
+        usage: [`
+  share <id>               Share a memory with attribution + transfer scoring
+    --force                Share even if transfer score is low
+    --auto                 Auto-share all high-transfer-score memories
+    --dry-run              Preview what would be shared
+    --min-score <n>        Minimum transfer score (default: 0.6)`],
+    }),
+    peers: verb(() => import('../transfer.js'), 'handlePeers', {
+        flags: { switches: ['all-tenants'] },
+        usage: [`
+  peers                    List projects contributing to global store`],
+    }),
+    sync: verb(() => import('../transfer.js'), 'handleSync', {
+        flags: { switches: ['cross-project'] },
+        usage: [`
+  sync                     Pull global memories into local project`],
+    }),
+    import: verb(() => import('../transfer.js'), 'handleImport', {
+        flags: {
+            switches: ['agents', 'dry-run', 'global'],
+            values: ['chatgpt', 'claude', 'cursor', 'file', 'markdown', 'name', 'scope', 'vault'],
+            lists: ['tag'],
+        },
+        usage: [`
+  import                   Import memories from other AI tools
+    --chatgpt <path>       Import from ChatGPT memory export (JSON or txt)
+    --claude <path>        Import from CLAUDE.md or Claude memory.json
+    --cursor <path>        Import from .cursorrules or .cursor/rules
+    --file <path>          Import from any markdown or text file
+    --markdown <path>      Import from structured MEMORY.md / AGENTS.md
+    --vault <path>         Import a markdown-vault FOLDER as kind='raw' notes
+                             (Obsidian/Foam/Dendron). Requires --name <vault>.
+                             [--scope <scope>]
+    --agents               Sync every coding agent's own memories (Claude Code, Codex,
+                             Gemini CLI, Copilot, OpenClaw, Qwen Code) now; with
+                             --dry-run, print each tool's folders and what would change.
+                             HIPPO_AGENT_MEMORY_TOOLS=<ids> or config agentMemories.tools
+                             picks the tools; "none" or [] turns the import off
+    --dry-run              Preview without writing
+    --global               Write to global store ($HIPPO_HOME or ~/.hippo/)
+    --tag <tag>            Add extra tag (repeatable)`],
+    }),
+    export: verb(() => import('../transfer.js'), 'handleExport', {
+        flags: { values: ['format'] },
+        usage: [`
+  export [file]            Export all memories (default: stdout)
+    --format <fmt>         Output format: json (default) or markdown`],
+    }),
+    capture: verb(() => import('../session-hooks.js'), 'handleCapture', {
+        flags: { switches: ['dry-run', 'global', 'last-session', 'stdin'], values: ['file', 'log-file', 'transcript'] },
+        usage: [`
+  capture                  Extract memories from conversation text
+    --stdin                Read from piped input
+    --file <path>          Read from a file
+    --last-session         Read the transcript a hook names on stdin, else the newest
+                           Claude Code one from any project
+    --transcript <path>    Explicit transcript path (implies --last-session)
+    --log-file <path>      Tee output to a log file (paired with 'hippo last-sleep')
+    --dry-run              Preview without writing
+    --global               Write to global store ($HIPPO_HOME or ~/.hippo/)`],
+    }),
+    setup: verb(() => import('../setup.js'), 'handleSetup', {
+        flags: { switches: ['all', 'dry-run', 'no-learn', 'no-schedule'] },
+        usage: [`
+  setup                    One-shot: detect installed AI tools and install their hooks:
+                           claude-code gets 7 hooks in $CLAUDE_CONFIG_DIR/settings.json
+                           (~/.claude by default), opencode a plugin, codex 2 hooks in
+                           its hooks.json plus a launcher wrapper, copilot 4 hooks, the
+                           MCP server and an instructions block under $COPILOT_HOME
+                           (~/.copilot by default); other tools get a
+                           hint. Then imports each agent's
+                           user-level memories into the global store
+    --all                  Install for every JSON-hook tool, even if not detected
+    --dry-run              Show what would be installed without writing
+    --no-schedule          Skip installing or repairing the daily runner
+    --no-learn             Skip the agent memory import`],
+    }),
+    'last-sleep': verb(() => import('../last-sleep.js'), 'handleLastSleep', {
+        flags: { switches: ['keep'], values: ['path'] },
+        usage: [`
+  last-sleep               Show the last sleep log on stderr, one problems line to the user, and clear it
+    --path <p>             Log path (default: ~/.hippo/logs/last-sleep.log)
+    --keep                 Print without clearing`],
+    }),
+    'session-end': verb(() => import('../session-hooks.js'), 'handleSessionEnd', {
+        // Its sleep step reads --dry-run, but the capture after it writes for real.
+        dryRun: false,
+        flags: {
+            switches: ['dry-run', 'no-learn', 'no-share', 'turn'],
+            values: ['format', 'log-file', 'runtime', 'session-id', 'transcript'],
+        },
+        usage: [`
+  session-end              SessionEnd hook: count this session's re-read tokens, run sleep, then
+                           capture from the session's last 20 user and 10 assistant messages,
+                           in a detached worker
+    --log-file <path>      Tee the worker's output to a log file (paired with 'hippo last-sleep')
+    --runtime copilot      The payload came from a Copilot hook: use the store of its cwd and find
+                           the Copilot CLI session log by session id; with no --log-file, log to
+                           ~/.hippo/logs/copilot-sleep.log
+    --turn                 VS Code Stop hook, after each reply: capture only the new turns, sleep
+                           only at the auto-sleep threshold, and keep the session's snapshot; does
+                           nothing for any other payload`],
+    }),
+    '__session-end-worker': verb(() => import('../session-hooks.js'), 'handleSessionEndWorker', {
+        dryRun: false,
+        flags: {
+            switches: ['dry-run', 'no-learn', 'no-share', 'turn'],
+            values: ['log-file', 'session-id', 'transcript'],
+        },
+    }),
+    'pre-compact': verb(() => import('../session-hooks.js'), 'handlePreCompact', {
+        flags: { values: ['format', 'log-file', 'runtime'] },
+        usage: [`
+  pre-compact              PreCompact hook: record the compaction, save a working-state snapshot, and
+                           ask the summariser to end with a "Memories for hippo" list
+    --log-file <p>         Diagnostic log path (default: ~/.hippo/logs/pre-compact.log)
+    --runtime copilot      The payload came from a Copilot hook: use the store of its cwd and save
+                           the snapshot only (Copilot has no PostCompact hook to close a record)`],
+    }),
+    'compact-resume': verb(() => import('../session-hooks.js'), 'handleCompactResume', {
+        flags: {},
+        usage: [`
+  compact-resume           SessionStart(compact) hook: re-print the snapshot, if under 15 minutes old`],
+    }),
+    'post-compact': verb(() => import('../session-hooks.js'), 'handlePostCompact', {
+        flags: { values: ['log-file'] },
+        usage: [`
+  post-compact             PostCompact hook: keep that list as memories (a busy store leaves the save to
+                           the next hippo sleep) and print one line saying how many
+    --log-file <p>         Same log path as pre-compact (default: ~/.hippo/logs/pre-compact.log)`],
+    }),
+    'codex-run': verb(() => import('../session-hooks.js'), 'handleCodexRun', {
+        flags: {},
+        usage: [`
+  codex-run [-- ...args]   Launch real Codex behind Hippo's session-end wrapper`],
+    }),
+    '__codex-session-end-worker': verb(() => import('../session-hooks.js'), 'handleCodexSessionEndWorker', {
+        flags: { values: ['codex-home', 'history-path', 'log-file', 'start-offset', 'started-at'] },
+    }),
+    hook: verb(() => import('../setup.js'), 'handleHook', {
+        flags: {},
+        usage: [`
+  hook <sub> [target]      Manage framework integrations
+    hook list              Show available hooks
+    hook install <target>  Install hook (claude-code|codex|copilot|cursor|openclaw|opencode|pi)
+                           claude-code adds 7 hooks to $CLAUDE_CONFIG_DIR/settings.json
+                           (~/.claude by default); opencode installs a plugin; codex
+                           adds 2 hooks to $CODEX_HOME/hooks.json (trust them once in /hooks) and
+                           wraps the detected launcher in place; copilot writes
+                           hooks/hippo.json, the "hippo" MCP server and an instructions
+                           block under $COPILOT_HOME (~/.copilot by default); all but
+                           claude-code and copilot also patch an existing AGENTS.md
+    hook uninstall <target> Remove hook; for copilot, only what hippo wrote`],
+    }),
+};
+//# sourceMappingURL=sessions.js.map