hippo-memory 1.71.0 → 2.0.0

package/dist/cli/verb-row.d.ts

@@ -0,0 +1,34 @@
+import type { CliFlags, CommandContext } from './flag-values.js';
+import type { VerbFlags } from './flags.js';
+type Handler = (ctx: CommandContext) => void | Promise<void>;
+/** A verb that honours --dry-run in one form only, where every other form writes for real. */
+export interface DryRunForm {
+    /** Printed after `hippo <verb>` in the refusal, so an alias names itself. */
+    readonly form: string;
+    readonly honoured: (args: readonly string[], flags: CliFlags) => boolean;
+}
+/** What a verb declares; its key in the table is its name, and the table's order is the help listing's. */
+export interface VerbRow {
+    /** The flags this verb reads; any other flag still parses, and the verb says it ignores it. */
+    readonly flags: VerbFlags;
+    /** Help blocks, each opening with a newline so the full listing is their concatenation. */
+    readonly usage?: readonly string[];
+    /** Help blocks the full listing prints after every verb's own; `hippo <verb> --help` prints them last. */
+    readonly listedLast?: readonly string[];
+    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;
+    /** Routine verbs after which a previously installed codex wrapper is repaired (never first-installed). */
+    readonly repairsCodexWrapper?: true;
+    /** Deletes or hides memories: an unknown flag stops the run instead of being ignored. */
+    readonly destructive?: true;
+    /** Unset: --dry-run is honoured exactly when the verb declares it; `false` refuses it even so. */
+    readonly dryRun?: false | DryRunForm;
+}
+export interface VerbSpec extends VerbRow {
+    readonly run: (ctx: CommandContext) => Promise<void>;
+}
+/** A row whose module loads on its first run; `handler` must be an export of that module taking a CommandContext. */
+export declare function verb<K extends string, M extends Readonly<Record<K, Handler>>>(load: () => Promise<M>, handler: K, row: VerbRow): VerbSpec;
+export {};
+//# sourceMappingURL=verb-row.d.ts.map

package/dist/cli/verb-row.js

@@ -0,0 +1,6 @@
+// The shape of one row of the verb table, and the helper that builds it with a type-checked lazy import.
+/** A row whose module loads on its first run; `handler` must be an export of that module taking a CommandContext. */
+export function verb(load, handler, row) {
+    return { ...row, run: async (ctx) => { await (await load())[handler](ctx); } };
+}
+//# sourceMappingURL=verb-row.js.map

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

@@ -0,0 +1,27 @@
+import { type VerbSpec } from '../verb-row.js';
+export declare const HEALTH_VERBS: {
+    status: VerbSpec;
+    audit: VerbSpec;
+    github: VerbSpec;
+    slack: VerbSpec;
+    provenance: VerbSpec;
+    dag: VerbSpec;
+    drill: VerbSpec;
+    assemble: VerbSpec;
+    'correction-latency': VerbSpec;
+    outcome: VerbSpec;
+    conflicts: VerbSpec;
+    resolve: VerbSpec;
+    reject: VerbSpec;
+    rejections: VerbSpec;
+    unreject: VerbSpec;
+    dormant: VerbSpec;
+    projects: VerbSpec;
+    quarantine: VerbSpec;
+    'capture-error': VerbSpec;
+    doctor: VerbSpec;
+    'support-bundle': VerbSpec;
+    tokens: VerbSpec;
+    failures: VerbSpec;
+};
+//# sourceMappingURL=health.d.ts.map

package/dist/cli/verbs/health.js

@@ -0,0 +1,234 @@
+// Store health, connectors, the summary tree and curation verbs, in `hippo help` order.
+import { TAIL_MAX_LINES } from '../../support-bundle.js';
+import { DEFAULT_ASSEMBLE_BUDGET } from '../../api/assemble.js';
+import { verb } from '../verb-row.js';
+export const HEALTH_VERBS = {
+    status: verb(() => import('../status.js'), 'handleStatus', {
+        repairsCodexWrapper: true,
+        flags: {},
+        usage: [`
+  status                   Show memory health stats`],
+    }),
+    audit: verb(() => import('../audit.js'), 'handleAudit', {
+        destructive: true,
+        scoped: true,
+        flags: {
+            switches: ['apply', 'dry-run', 'fix', 'global', 'json'],
+            values: ['older-than', 'op', 'since', 'tenant'],
+            numbers: ['limit'],
+        },
+        usage: [`
+  audit [--fix]            Check memory quality (--fix removes junk)
+    audit repair [--apply] Preview repair of memories hippo wrote itself; --apply moves certain
+                           defects to dormant storage. Sleep and the daily runner apply it once
+                           per store after an upgrade
+      --json              Report ids, reasons, protections and schema blockers as JSON
+      --global             Operate on the global store without changing its schema
+                           Writes a database backup first; undo with hippo dormant restore <id>,
+                           which marks the memory verified so repair leaves it alone. Sleep's
+                           dormant retention still applies; the backup stays until you remove it.`],
+        listedLast: [`
+  audit <sub>              Query the append-only audit log (A5 stub auth)
+    audit list             List audit events for the active tenant
+      --op <op>            Filter by op (remember | recall | promote |
+                           supersede | forget | archive_raw | auth_revoke)
+      --since <iso>        Lower bound on ts (ISO timestamp)
+      --limit <n>          Max events (default: 100, max: 10000)
+      --json               Output as JSON
+      --global             Operate on the global store`],
+    }),
+    github: verb(() => import('../github.js'), 'handleGitHub', {
+        flags: { switches: ['force'], values: ['max', 'repo', 'since'] },
+        usage: [`
+  github                   GitHub connector subcommands (backfill, dlq)
+    backfill --repo <owner/name> [--since ISO] [--max <N>]
+                           Paginated backfill of issues + comments
+    dlq list               List DLQ entries for the active tenant
+    dlq replay <id> [--force]
+                           Re-ingest a DLQ entry (--force skips sig check)`],
+    }),
+    slack: verb(() => import('../slack.js'), 'handleSlack', {
+        flags: { switches: ['force'], values: ['channel', 'since', 'team', 'tenant'] },
+        usage: [`
+  slack                    Slack connector subcommands (backfill, dlq, workspaces)
+    backfill --channel <id> [--since ISO]
+                           Backfill a channel's history (needs SLACK_BOT_TOKEN)
+    dlq list               List DLQ entries for the active tenant
+    dlq replay <id> [--force]
+                           Re-ingest a DLQ entry (--force skips sig check)
+    workspaces <add|list|remove>
+                           Map Slack workspaces (team ids) to tenants`],
+    }),
+    provenance: verb(() => import('../status.js'), 'handleProvenance', {
+        flags: { switches: ['json', 'strict'] },
+        usage: [`
+  provenance               Provenance coverage gate for kind='raw' rows
+    --json                 Output as JSON
+    --strict               Exit non-zero when coverage < 100%`],
+    }),
+    dag: verb(() => import('../dag.js'), 'handleDag', {
+        flags: { switches: ['stats'] },
+        usage: [`
+  dag                      Show the summary tree: entity profiles, topic summaries, facts
+    --stats                Count memories per DAG level instead`],
+    }),
+    drill: verb(() => import('../dag.js'), 'handleDrill', {
+        scoped: true,
+        flags: { switches: ['json'], values: ['budget', 'depth'], numbers: ['limit'] },
+        usage: [`
+  drill <summary-id>       Walk down a DAG level-2 summary to its children
+    --limit N              Cap children list (default 50)
+    --budget N             Token budget for the printed children (≈ chars/4)
+    --json                 Output as JSON`],
+    }),
+    assemble: verb(() => import('../dag.js'), 'handleAssemble', {
+        scoped: true,
+        flags: { switches: ['json', 'no-summarize-older'], values: ['budget', 'fresh-tail', 'scope', 'session'] },
+        usage: [`
+  assemble --session <id>  Build a session's chronological context window
+    --budget N             Token budget for the printed window (default ${DEFAULT_ASSEMBLE_BUDGET})
+    --fresh-tail N         Recent rows always kept verbatim (default 10)
+    --no-summarize-older   Disable older-row summary substitution
+    --scope <s>            Restrict to exact scope (default: deny *:private:*)
+    --json                 Output as JSON`],
+    }),
+    'correction-latency': verb(() => import('../status.js'), 'handleCorrectionLatency', {
+        flags: { switches: ['json'] },
+        usage: [`
+  correction-latency       Wall-clock lag from receipt to supersession (p50/p95/max)
+    --json                 Output as JSON`],
+    }),
+    outcome: verb(() => import('../curate.js'), 'handleOutcome', {
+        repairsCodexWrapper: true,
+        scoped: true,
+        flags: { switches: ['bad', 'good'], values: ['id'] },
+        usage: [`
+  outcome                  Apply feedback to last recall
+    --good                 Memories were helpful
+    --bad                  Memories were irrelevant
+    --id <id>              Target a specific memory`],
+    }),
+    conflicts: verb(() => import('../curate.js'), 'handleConflicts', {
+        flags: { switches: ['json'], values: ['status'] },
+        usage: [`
+  conflicts                List detected open memory conflicts
+    --status <status>      Filter by status (default: open)
+    --json                 Output as JSON`],
+    }),
+    resolve: verb(() => import('../curate.js'), 'handleResolve', {
+        destructive: true,
+        flags: { switches: ['forget', 'reject-loser'], values: ['keep', 'reason'] },
+        usage: [`
+  resolve <conflict_id>    Resolve a memory conflict
+    --keep <memory_id>     Memory to keep (required)
+    --forget               Delete the losing memory (default: halve half-life)
+    --reject-loser         Tombstone the loser's value too (implies removal)
+    --reason "<why>"       Reason for --reject-loser (default: conflict context)`],
+    }),
+    reject: verb(() => import('../curate.js'), 'handleReject', {
+        destructive: true,
+        flags: { switches: ['global'], values: ['reason', 'value'] },
+        usage: [`
+  reject <memory-id>       Tombstone a value so it refuses re-ingestion
+    reject --value "<t>"   Pre-emptive form: tombstone a value not (currently) stored
+    --reason "<why>"       Required. The tombstone stores no content — this
+                           is its only human-readable identity.
+    --global               Reject in the global store`],
+    }),
+    rejections: verb(() => import('../curate.js'), 'handleRejections', {
+        flags: { switches: ['global', 'json'] },
+        usage: [`
+  rejections               List rejected-value tombstones for the active tenant
+    --json                 Output as JSON
+    --global               Operate on the global store`],
+    }),
+    unreject: verb(() => import('../curate.js'), 'handleUnreject', {
+        flags: { switches: ['global'] },
+        usage: [`
+  unreject <digest-prefix> Delete a tombstone (the only escape hatch)
+    --global               Operate on the global store`],
+    }),
+    dormant: verb(() => import('../curate.js'), 'handleDormant', {
+        scoped: true,
+        flags: { switches: ['global', 'json'], numbers: ['limit'] },
+        usage: [`
+  dormant [<query>]        List faded memories sleep kept instead of deleting
+                           (on by default; "dormant": {"enabled": false} deletes instead)
+    --limit <n>            Max rows, newest first (default: 20)
+    --json                 Output as JSON
+    --global               Operate on the global store
+    dormant restore <id>   Bring a dormant memory back to active memory
+    dormant forget <id>    Delete a dormant memory permanently`],
+    }),
+    projects: verb(() => import('../projects.js'), 'handleProjects', {
+        destructive: true,
+        flags: { switches: ['apply', 'global', 'json'] },
+        usage: [`
+  projects [list]          List the project names in a store, with a hint for old worktree names
+    --json                 Output as JSON
+    --global               Operate on the global store
+    projects merge <from> <into> [--apply]
+                           Fold one project name into another (dry run unless --apply;
+                           writes a backup and one audit event first)
+    projects repair [--apply]
+                           Set aside misfiled note imports, fold old project names into
+                           their ids, re-tag merged rows (dry run unless --apply;
+                           writes a backup and one audit event first)`],
+    }),
+    quarantine: verb(() => import('../curate.js'), 'handleQuarantine', {
+        scoped: true,
+        flags: { switches: ['all', 'global', 'json'] },
+        usage: [`
+  quarantine [list]       List memories a connector flagged as an instruction attempt, pending review
+    --all                  Include approved and rejected rows too (default: pending only)
+    --json                 Output as JSON
+    --global               Operate on the global store
+    quarantine approve <id> Restore a quarantined memory to its original scope
+    quarantine reject <id>  Keep a quarantined memory hidden for good`],
+    }),
+    'capture-error': verb(() => import('../session-hooks.js'), 'handleCaptureError', {
+        flags: { values: ['format', 'runtime'] },
+        usage: [`
+  capture-error            Store a failed tool call as an error memory (reads the Claude Code
+                           PostToolUseFailure hook payload on stdin; skips routine failures)
+    --runtime copilot      The payload came from a Copilot hook: use the store of its cwd`],
+    }),
+    doctor: verb(() => import('../status.js'), 'handleDoctor', {
+        flags: { switches: ['json'] },
+        usage: [`
+  doctor                   Check the install: Node, store, schema, sleep, agent hooks
+    --json                 Machine-readable report (exit code 1 on any failure)`],
+    }),
+    'support-bundle': verb(() => import('../status.js'), 'handleSupportBundle', {
+        flags: { switches: ['include-logs'], values: ['out'] },
+        usage: [`
+  support-bundle           Write a redacted JSON file for a support ticket: versions, doctor,
+                           config without secrets, store counts, log names; never memory text
+    --out <file>           Where to write it (default: hippo-support-<time>.json here)
+    --include-logs         Add the last ${TAIL_MAX_LINES} lines of each hippo log, known secret shapes removed`],
+    }),
+    tokens: verb(() => import('../status.js'), 'handleTokens', {
+        scoped: true,
+        flags: { switches: ['global', 'json'], numbers: ['days'] },
+        usage: [`
+  tokens                   Tokens of memory text hippo handed agents, per surface
+                           (hook, compact-resume, context, recall, MCP, HTTP), what
+                           skipping unchanged hook blocks saved, and how much of the
+                           hook and compact-resume blocks later model calls re-read,
+                           counted when a session ends. Estimates (characters / 4)
+    --days <n>             Window in days (default: 30)
+    --json                 Output as JSON
+    --global               Operate on the global store`],
+    }),
+    failures: verb(() => import('../status.js'), 'handleFailures', {
+        scoped: true,
+        flags: { switches: ['global', 'json'], numbers: ['days'] },
+        usage: [`
+  failures                 Failed tool calls capture-error saw, by outcome, and how
+                           many errors first happened in another session
+    --days <n>             Window in days (default: 30)
+    --json                 Output as JSON
+    --global               Operate on the global store`],
+    }),
+};
+//# sourceMappingURL=health.js.map

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

@@ -0,0 +1,16 @@
+import { type VerbSpec } from '../verb-row.js';
+export declare const MEMORY_VERBS: {
+    init: VerbSpec;
+    remember: VerbSpec;
+    supersede: VerbSpec;
+    recall: VerbSpec;
+    explain: VerbSpec;
+    trace: VerbSpec;
+    refine: VerbSpec;
+    eval: VerbSpec;
+    context: VerbSpec;
+    sleep: VerbSpec;
+    'daily-runner': VerbSpec;
+    dedup: VerbSpec;
+};
+//# sourceMappingURL=memory.d.ts.map

package/dist/cli/verbs/memory.js

@@ -0,0 +1,236 @@
+// Store, recall and maintenance verbs; every verbs/ file keeps its rows in the order `hippo help` lists them.
+import { DEFAULT_LOCAL_BUMP, DEFAULT_RECALL_BUDGET } from '../../core/search-types.js';
+import { DEFAULT_EMBEDDING_WEIGHT, DEFAULT_MMR_LAMBDA } from '../../search/hybrid.js';
+import { DEFAULT_GRAPH_HOPS, DEFAULT_GRAPH_SEED_COUNT } from '../../graph/stream.js';
+import { verb } from '../verb-row.js';
+export const MEMORY_VERBS = {
+    init: verb(() => import('../init.js'), 'handleInit', {
+        repairsCodexWrapper: true,
+        flags: { switches: ['global', 'no-hooks', 'no-learn', 'no-schedule'], values: ['scan'], numbers: ['days'] },
+        usage: [`
+  init                     Create .hippo/ structure in current directory
+    --scan [dir]           Find all git repos under dir (default: ~) and init each
+    --days <n>             Days of git history to seed (default: 365 for --scan, 30 for single)
+    --global               Init the global store ($HIPPO_HOME or ~/.hippo/)
+    --no-hooks             Skip auto-detecting and installing agent hooks
+                           (HIPPO_SKIP_AUTO_INTEGRATIONS=1 does the same)
+    --no-schedule          Skip auto-creating the machine-level daily runner
+    --no-learn             Skip seeding memories from git history and importing
+                           coding agents' own memories (every init imports those)`],
+    }),
+    remember: verb(() => import('../remember.js'), 'handleRemember', {
+        repairsCodexWrapper: true,
+        flags: {
+            switches: ['error', 'extract', 'force', 'global', 'inferred', 'observed', 'pin', 'verified'],
+            values: ['artifact-ref', 'kind', 'layer', 'owner', 'scope'],
+            lists: ['tag'],
+        },
+        usage: [`
+  remember <text>          Store a memory
+    --tag <tag>            Add a tag (repeatable)
+    --error                Tag as error (boosts retention)
+    --pin                  Pin memory (never decays)
+    --verified             Set confidence: verified (default)
+    --observed             Set confidence: observed
+    --inferred             Set confidence: inferred
+    --global               Store in global store ($HIPPO_HOME or ~/.hippo/)`],
+    }),
+    supersede: verb(() => import('../remember.js'), 'handleSupersede', {
+        destructive: true,
+        flags: { switches: ['pin'], values: ['layer'], lists: ['tag'] },
+        usage: [`
+  supersede <id> "<text>"  Replace a memory with a new version; the old one points at it
+    --layer <layer>        Layer for the new memory (default: the old memory's layer)
+    --tag <tag>            Tag for the new memory (repeatable; default: the old memory's tags)
+    --pin                  Pin the new memory (default: pinned if the old one was)`],
+    }),
+    recall: verb(() => import('../recall.js'), 'handleRecall', {
+        repairsCodexWrapper: true,
+        scoped: true,
+        flags: {
+            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'],
+        },
+        usage: [`
+  recall <query>           Search and retrieve memories (local + global)
+    --budget <n>           Token budget for the whole printed block (default: ${DEFAULT_RECALL_BUDGET})
+    --min-results <n>      Minimum results regardless of budget (default: 1)
+    --json                 Output as JSON
+    --why                  Show match reasons and source annotations
+    --include-superseded   Also return memories a newer version replaced
+    --as-of <iso-date>     Return the memories that were current on that date
+    --multihop             Search a second time with the speaker: and topic: tags the
+                           first pass found (also on when config multihop.enabled is true)
+    --hops <n>             Also surface memories reached by walking the entity and
+                           relation graph <n> hops (0..3, default off) out from the
+                           lexical matches. Graph hits are tagged [graph: Nhop <rel>].
+                           Today the graph holds supersedes edges; cross-object
+                           edges light up the same walk once extracted.
+    --max-neighbors <n>    Per-hop fanout cap for --hops (1..200, default 25).
+    --graph-stream         Fuse a graph-proximity ranking into the result list,
+                           re-ranking in-pool results by closeness to the strong
+                           lexical matches. Implies rrf scoring (default is blend).
+                           Local store only. Unlike --hops, it adds no memories
+                           from outside the candidate pool.
+    --graph-hops <n>       Hops for --graph-stream (1..3, default ${DEFAULT_GRAPH_HOPS}).
+    --graph-seeds <n>      Lexical anchors for --graph-stream (default ${DEFAULT_GRAPH_SEED_COUNT}). The stream
+                           re-ranks the results below the anchors; on a pool with <= n
+                           candidates every candidate is an anchor and the stream is inert.
+    --no-mmr               Disable MMR diversity re-ranking
+    --mmr-lambda <f>       MMR balance 0..1 (default: ${DEFAULT_MMR_LAMBDA}, 1.0 = pure relevance)
+    --evc-adaptive         When the top results overlap heavily (a conflict
+                           cluster), widen the pool and re-rank by recency.
+                           Default off.
+    --filter-conflicts     Drop superseded entries and down-weight by 0.3x any
+                           entry in an open conflict with another result.
+                           Uses recorded supersession and conflicts only, never
+                           lexical inference. Default off.
+    --value-aware          Boost memories with positive cumulative outcomes and
+                           demote those with negative ones during ranking:
+                           multiplier clip(1 + 0.3*tanh(pos - neg), 0.7, 1.3).
+                           Reads outcome_positive and outcome_negative. Default off.
+    --rerank-utility       Re-sort results by utility = score * (0.5 + 0.5 * strength)
+                           * (1 - cost_factor), where cost_factor =
+                           min(0.3, tokens / 10000). Default off.
+    --reranker <name>      Apply a reranker pass after retrieval
+                           (cross-encoder|jev|clef-flash|clef|llm) to re-order the
+                           top-K candidates. Default unset (no reranker).
+                           jev calls the hosted TypeSafe Jev API: it needs
+                           TYPESAFE_API_KEY, sends the query and candidate
+                           text to that API, costs about 0.0004 USD a recall,
+                           and falls back to cross-encoder on any failure.
+                           clef-flash and clef send the same request to
+                           Cloudflare Workers AI (CLOUDFLARE_ACCOUNT_ID and
+                           CLOUDFLARE_API_TOKEN) or to HIPPO_CLEF_ENDPOINT, and
+                           keep the native order on any failure.
+    --reranker-top-k <n>   Cap candidates passed to the reranker (default 50;
+                           40 for jev, clef-flash and clef).
+    --goal <tag>           Goal-conditioned recall: memories tagged with the
+                           goal tag get a 1.5x score boost and results are
+                           re-sorted. Default off.
+    --session-id <id>      Session identifier for the goal-stack boost.
+                           Defaults to $HIPPO_SESSION_ID. When set and the
+                           (tenant, session) has active goals (see
+                           'hippo goal push'), recall auto-boosts memories
+                           whose tags match an active goal name. Boost stacks
+                           on top of base BM25 score, capped at 3.0x.
+    --salience-threshold <n>
+                           Down-weight memories retrieved fewer than n times:
+                           score *= max(0.5, retrieval_count / n) for entries
+                           with count < n; entries at or above n are unchanged.
+                           Salience comes from use, not from lexical overlap.
+                           Default off.
+    --continuity           Include a continuity block (active task snapshot,
+                           latest matching session handoff, last 5 session
+                           events) above the memory list. Useful at agent
+                           boot when you want both relevant memories AND
+                           where you left off in one call. Anchored on the
+                           active snapshot's session_id; no anchor = no
+                           handoff/events (use 'hippo session resume' for
+                           the explicit handoff-without-snapshot path).`],
+    }),
+    explain: verb(() => import('../explain.js'), 'handleExplain', {
+        scoped: true,
+        flags: {
+            switches: ['classic', 'equal-sources', 'include-superseded', 'json', 'no-mmr', 'physics'],
+            values: ['as-of', 'budget', 'scope'],
+            numbers: ['limit', 'local-bump', 'mmr-lambda'],
+        },
+        usage: [`
+  explain <query>          Show full score breakdown for each retrieved memory
+    --budget <n>           Token budget, counted as recall prints (default: ${DEFAULT_RECALL_BUDGET})
+    --limit <n>            Cap the number of results displayed
+    --json                 Output as JSON
+    --physics | --classic  Force search mode (default: from config)
+    --no-mmr               Disable MMR diversity re-ranking
+    --mmr-lambda <f>       MMR balance 0..1 (default: ${DEFAULT_MMR_LAMBDA}, 1.0 = pure relevance)`],
+    }),
+    trace: verb(() => import('../remember.js'), 'handleTrace', {
+        flags: { switches: ['json'], values: ['outcome', 'session', 'source', 'steps', 'task'], lists: ['tag'] },
+        usage: [`
+  trace <id>               Memory dossier: content, decay trajectory, retrievals,
+                           outcomes, consolidation parents, open conflicts
+    --json                 Output as JSON`],
+    }),
+    refine: verb(() => import('../maintenance.js'), 'handleRefine', {
+        flags: { switches: ['all', 'dry-run', 'json'], values: ['model'], numbers: ['limit'] },
+        usage: [`
+  refine                   Rewrite consolidated semantic memories with Claude
+    --limit <n>            Cap the number of memories processed this run
+    --all                  Ignore \`llm-refined\` tag and re-refine everything
+    --dry-run              Call the API but don't write results back
+    --model <id>           Override the default model (claude-sonnet-4-6)
+    --json                 Output summary as JSON
+    (requires ANTHROPIC_API_KEY in env)`],
+    }),
+    eval: verb(() => import('../eval.js'), 'handleEval', {
+        flags: {
+            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'],
+        },
+        usage: [`
+  eval [<corpus.json>]     Measure recall quality against a test corpus
+    --bootstrap            Generate a synthetic corpus from current memories
+    --out <path>           With --bootstrap, write to file instead of stdout
+    --max-cases <n>        With --bootstrap, cap case count (default: 50)
+    --show-cases           Print per-case details (query, R@10, missed, top 3)
+    --compare <path>       JSON from a prior \`eval --json\` run; print deltas
+    --no-mmr               Disable MMR for this eval run
+    --mmr-lambda <f>       Override MMR lambda for this run
+    --embedding-weight <f> Override cosine weight (default: ${DEFAULT_EMBEDDING_WEIGHT})
+    --local-bump <f>       Local-over-global priority multiplier (default: ${DEFAULT_LOCAL_BUMP})
+    --equal-sources        Shortcut for --local-bump 1.0
+    --min-mrr <f>          Exit non-zero if mean MRR falls below this
+    --json                 Output full summary as JSON`],
+    }),
+    context: verb(() => import('../context.js'), 'handleContext', {
+        repairsCodexWrapper: true,
+        flags: {
+            switches: ['auto', 'cross-project', 'pinned-only'],
+            values: ['budget', 'format', 'framing', 'include-recent', 'runtime', 'scope'],
+            numbers: ['limit'],
+        },
+        usage: [`
+  context                  Smart context injection for AI agents
+    --auto                 Auto-detect task from git state
+    --budget <n>           Token budget for the whole printed block (default: 1500)
+    --pinned-only          Only inject pinned memories (used by UserPromptSubmit hook)
+    --include-recent <n>   With --pinned-only, also inject the last N writes regardless of pinning
+    (the hook payload's "prompt" drives prompt recall instead of --include-recent when pinnedInject.promptRecall is on, the default)
+    --format <fmt>         Output format: markdown (default), json, additional-context (Claude Code hook JSON),
+                           or copilot (Copilot sessionStart hook JSON, from the store of the payload's cwd)
+    --framing <mode>       Framing: observe (default), suggest, assert`],
+    }),
+    sleep: verb(() => import('../sleep.js'), 'handleSleep', {
+        repairsCodexWrapper: true,
+        destructive: true,
+        scoped: true,
+        flags: { switches: ['dry-run', 'no-learn', 'no-share'], values: ['log-file'] },
+        usage: [`
+  sleep                    Run consolidation pass (auto-learns + dedup + auto-shares)
+                           Runs at Claude Code and OpenCode session end and in the daily job.
+                           With ANTHROPIC_API_KEY set it sends memory text to Anthropic for
+                           fact extraction; {"extraction":{"enabled":false}} turns that off
+    --dry-run              Preview without writing
+    --no-learn             Skip auto git-learn and the agent memory import before consolidation
+    --no-share             Skip auto-sharing to global store`],
+    }),
+    'daily-runner': verb(() => import('../setup.js'), 'handleDailyRunner', {
+        flags: {},
+        usage: [`
+  daily-runner             Sweep registered workspaces and run daily learn+sleep`],
+    }),
+    dedup: verb(() => import('../maintenance.js'), 'handleDedup', {
+        destructive: true,
+        flags: { switches: ['dry-run'], numbers: ['threshold'] },
+        usage: [`
+  dedup                    Remove duplicate memories (keeps stronger copy)
+    --dry-run              Preview without removing
+    --threshold <n>        Ignored, kept for old scripts: a duplicate is the same text apart from spacing`],
+    }),
+};
+//# sourceMappingURL=memory.js.map

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

@@ -0,0 +1,20 @@
+import { type VerbSpec } from '../verb-row.js';
+export declare const OBJECT_VERBS: {
+    predict: VerbSpec;
+    decide: VerbSpec;
+    incident: VerbSpec;
+    process: VerbSpec;
+    policy: VerbSpec;
+    skill: VerbSpec;
+    brief: VerbSpec;
+    note: VerbSpec;
+    graph: VerbSpec;
+    invalidate: VerbSpec;
+    wm: VerbSpec;
+    dashboard: VerbSpec;
+    mcp: VerbSpec;
+    serve: VerbSpec;
+    goal: VerbSpec;
+    auth: VerbSpec;
+};
+//# sourceMappingURL=objects.d.ts.map