### Setup and Run LongMemEval Benchmark (Python)

Source: https://github.com/kitfunso/hippo-memory/blob/master/benchmarks/README.md

Install dependencies and run the LongMemEval benchmark using Python. This command assumes data has been downloaded from HuggingFace.

```bash
cd longmemeval
pip install -r requirements.txt

# Download data from HuggingFace (see README)
# Then run:
python run.py --data data/longmemeval_oracle.json
```

--------------------------------

### Install and Initialize Hippo CLI

Source: https://github.com/kitfunso/hippo-memory/blob/master/extensions/claude-code-plugin/README.md

Install the hippo CLI globally and then initialize it within your project directory.

```bash
npm install -g hippo-memory
```

```bash
cd your-project
hippo init
```

--------------------------------

### Install Hippo CLI and Initialize

Source: https://github.com/kitfunso/hippo-memory/blob/master/extensions/pi-extension/README.md

Install the hippo CLI globally and initialize hippo in your project. You can also scan all repositories for initialization.

```bash
# Install hippo CLI
npm install -g hippo-memory

# Init hippo in your project (or scan all repos)
hippo init
# or: hippo init --scan ~
```

--------------------------------

### Install Dependencies

Source: https://github.com/kitfunso/hippo-memory/blob/master/benchmarks/longmemeval/README.md

Install the required Python packages for the benchmark.

```bash
pip install -r requirements.txt
```

--------------------------------

### Install Dependencies and Build UI

Source: https://github.com/kitfunso/hippo-memory/blob/master/docs/plans/2026-04-16-brain-observatory-v025.md

Commands to install npm dependencies and build the UI project. Assumes you are in the 'ui' directory.

```bash
cd C:/Users/skf_s/hippo/ui && npm install
```

```bash
cd C:/Users/skf_s/hippo/ui && npm run build
```

--------------------------------

### Server Bearer Lockdown Test Setup

Source: https://github.com/kitfunso/hippo-memory/blob/master/docs/plans/2026-04-29-e1.3-slack-ingestion.md

Sets up the test environment by initializing the store, starting the server with authentication enabled, and defining routes to test.

```typescript
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { mkdtempSync, rmSync } from 'fs';
import { tmpdir } from 'os';
import { join } from 'path';
import { initStore } from '../src/store.js';
import { serve } from '../src/server.js';

describe('server Bearer lockdown', () => {
  let root: string;
  let handle: { stop: () => Promise<void>; port: number };

  beforeEach(async () => {
    root = mkdtempSync(join(tmpdir(), 'hippo-lockdown-'));
    initStore(root);
    process.env.HIPPO_REQUIRE_AUTH = '1';
    handle = await serve({ hippoRoot: root, host: '127.0.0.1', port: 0 });
  });
  afterEach(async () => { delete process.env.HIPPO_REQUIRE_AUTH; await handle.stop(); rmSync(root, { recursive: true, force: true }); });

  const v1Routes: Array<{ method: string; path: string; body?: string }> = [
    { method: 'POST', path: '/v1/memories', body: '{"content":"x"}' },
    { method: 'GET', path: '/v1/memories?q=x' },
    { method: 'POST', path: '/v1/auth/keys', body: '{}' },
    { method: 'GET', path: '/v1/auth/keys' },
    { method: 'GET', path: '/v1/audit' },
  ];

  it('all /v1/* routes except slack require Bearer', async () => {
    for (const r of v1Routes) {
      const res = await fetch(`http://127.0.0.1:${handle.port}${r.path}`, {
        method: r.method,
        headers: { 'content-type': 'application/json' },
        body: r.body,
      });
      expect(res.status, `${r.method} ${r.path}`).toBe(401);
    }
  });
});

```

--------------------------------

### Hippo Memory Installation and Initialization

Source: https://github.com/kitfunso/hippo-memory/blob/master/extensions/mcp/README.md

Install the hippo-memory package globally using npm and then initialize it in your project directory.

```bash
npm install -g hippo-memory
cd your-project && hippo init
```

--------------------------------

### Copy Pi Extension for Project-Level Installation

Source: https://github.com/kitfunso/hippo-memory/blob/master/extensions/pi-extension/README.md

Copy the pi-extension directory to the project's .pi/extensions directory for project-level installation.

```bash
cp -r extensions/pi-extension .pi/extensions/hippo-memory
```

--------------------------------

### Install Dependencies

Source: https://github.com/kitfunso/hippo-memory/blob/master/docs/plans/2026-04-29-b3-dlpfc-depth.md

Install project dependencies using npm.

```bash
npm install
```

--------------------------------

### Install and Initialize Hippo Memory CLI

Source: https://context7.com/kitfunso/hippo-memory/llms.txt

Install the hippo-memory package globally and initialize a project store. The `--scan` option can discover all git repositories under a given path. Use `--no-hooks` and `--no-schedule` to initialize without modifying agent configuration files.

```bash
# Install
npm install -g hippo-memory

# Initialize a single project (auto-installs agent hooks into CLAUDE.md / AGENTS.md / .cursorrules)
cd my-project && hippo init

# Initialize all projects under home directory at once
hippo init --scan ~

# Initialize without touching agent config files
hippo init --no-hooks --no-schedule

# Check what was created
hippo status
# Memories: 0 (0 pinned, 0 errors)
# Avg strength: 0
# At risk (<0.1): 0
# Open conflicts: 0
# Half-life default: 7d
```

--------------------------------

### Install Hippo Memory Plugin

Source: https://github.com/kitfunso/hippo-memory/blob/master/extensions/claude-code-plugin/README.md

Use these commands to install the Hippo Memory plugin from the marketplace or locally for development.

```bash
/plugin marketplace add kitfunso/hippo-memory
/plugin install hippo-memory
```

```bash
claude --plugin-dir ./extensions/claude-code-plugin
```

```bash
cp -r extensions/claude-code-plugin ~/.claude/plugins/hippo-memory
```

--------------------------------

### Initialize and Start Rendering (JavaScript)

Source: https://github.com/kitfunso/hippo-memory/blob/master/mockups/medical-imaging.html

Initializes the visualization by setting up event listeners for window resize and starting the animation loop. Ensures the canvas is responsive to display size changes.

```javascript
window.addEventListener('resize', resize);
resize();
requestAnimationFrame(render);
})();
```

--------------------------------

### Manual Installation of Hippo Memory Plugin

Source: https://github.com/kitfunso/hippo-memory/blob/master/extensions/openclaw-plugin/README.md

Manually copy the plugin files to the OpenClaw extensions directory if not using the plugin installer.

```bash
cp -r extensions/openclaw-plugin ~/.openclaw/extensions/hippo-memory
```

--------------------------------

### Install Hippo Memory Plugin

Source: https://github.com/kitfunso/hippo-memory/blob/master/extensions/openclaw-plugin/README.md

Install and enable the Hippo Memory plugin directly from npm or link a local folder for development.

```bash
openclaw plugins install hippo-memory
openclaw plugins enable hippo-memory
```

```bash
openclaw plugins install -l ./extensions/openclaw-plugin
```

--------------------------------

### JavaScript for Celestial Scene Setup

Source: https://github.com/kitfunso/hippo-memory/blob/master/mockups/bg-celestial-star.html

Initializes Three.js, scene, camera, renderer, and OrbitControls. Sets up the background color and fog.

```javascript
{ "imports": {
    "three": "https://unpkg.com/three@0.170.0/build/three.module.js",
    "three/addons/": "https://unpkg.com/three@0.170.0/examples/jsm/"
  }}
import * as THREE from "three";
import { OrbitControls } from "three/addons/controls/OrbitControls.js";

const PAL = {
  teal: new THREE.Color("#4a8ca3"),
  sage: new THREE.Color("#5a8f6b"),
  violet: new THREE.Color("#7c6caf"),
};

const LAYER_Y = {
  buffer: 14,
  episodic: 7,
  semantic: 0
};

function mulberry(a) {
  return function() {
    a |= 0;
    a = a + 0x6D2B79F5 | 0;
    let t = Math.imul(a ^ a >>> 15, 1 | a);
    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
    return ((t ^ t >>> 14) >>> 0) / 4294967296;
  };
}

const rand = mulberry(314);
const MEMORIES = [];
const layers = ["buffer","episodic","semantic"];

for (let i = 0; i < 28; i++) {
  MEMORIES.push({
    id: `m${i}`,
    layer: layers[i % 3],
    strength: 0.3 + rand() * 0.7,
    text: `word${i} phrase${i%5}`
  });
}

const positions = MEMORIES.map((m, i) => {
  const angle = i * 2.3998;
  const r = 6 + Math.sqrt(i) * 3.4;
  return new THREE.Vector3(Math.cos(angle) * r, LAYER_Y[m.layer], Math.sin(angle) * r);
});

const mount = document.getElementById("scene");
const scene = new THREE.Scene();
scene.background = new THREE.Color("#f0e7d2");
scene.fog = new THREE.Fog(0xf0e7d2, 55, 130);

const camera = new THREE.PerspectiveCamera(42, window.innerWidth / window.innerHeight, 0.1, 400);
camera.position.set(26, 22, 38);

const renderer = new THREE.WebGLRenderer({ antialias: true });
renderer.setPixelRatio(Math.min(2, window.devicePixelRatio));
renderer.setSize(window.innerWidth, window.innerHeight);
mount.appendChild(renderer.domElement);

const controls = new OrbitControls(camera, renderer.domElement);
controls.enableDamping = true;
controls.target.set(0, 6, 0);

// ------- Celestial chart floor: concentric rings + radial lines + zodiac ticks
function makeCelestialTexture() {
  const size = 1024;
  const c = document.createElement("canvas");
  c.width = c.height = size;
  const ctx = c.getContext("2d");
  ctx.fillStyle = "#f0e7d2";
  ctx.fillRect(0,0,size,size);

  // grain
  const img = ctx.getImageData(0,0,size,size);
  for (let i = 0; i < img.data.length; i += 4) {
    const n = (Math.random() - 0.5) * 20;
    img.data[i] = Math.max(0, Math.min(255, img.data[i] + n));
    img.data[i+1] = Math.max(0, Math.min(255, img.data[i+1] + n - 2));
    img.data[i+2] = Math.max(0, Math.min(255, img.data[i+2] + n - 10));
  }
  ctx.putImageData(img, 0, 0);

  const cx = size/2, cy = size/2;

  // concentric circles
  ctx.strokeStyle = "rgba(31,25,18,0.35)";
  ctx.lineWidth = 1.4;
  for (let r = 60; r < size/2; r += 70) {
    ctx.beginPath();
    ctx.arc(cx, cy, r, 0, Math.PI*2);
    ctx.stroke();
  }
  // faint in-between
  ctx.strokeStyle = "rgba(31,25,18,0.14)";
  ctx.lineWidth = 1;
  for (let r = 95; r < size/2; r += 70) {
    ctx.beginPath();
    ctx.arc(cx, cy, r, 0, Math.PI*2);
    ctx.stroke();
  }

  // radial lines (spokes) — 16 major
  ctx.strokeStyle = "rgba(31,25,18,0.28)";
  ctx.lineWidth = 1.1;
  for (let i = 0; i < 16; i++) {
    const a = (i / 16) * Math.PI * 2;
    ctx.beginPath();
    ctx.moveTo(cx + Math.cos(a) * 40, cy + Math.sin(a) * 40);
    ctx.lineTo(cx + Math.cos(a) * (size/2 - 30), cy + Math.sin(a) * (size/2 - 30));
    ctx.stroke();
  }
  // minor ticks — 64
  ctx.strokeStyle = "rgba(31,25,18,0.22)";
  ctx.lineWidth = 1;
  for (let i = 0; i < 64; i++) {
    const a = (i / 64) * Math.PI * 2;
    ctx.beginPath();
    ctx.moveTo(cx + Math.cos(a) * (size/2 - 50), cy + Math.sin(a) * (size/2 - 50));
    ctx.lineTo(cx + Math.cos(a) * (size/2 - 32), cy + Math.sin(a) * (size/2 - 32));
    ctx.stroke();
  }

  // compass rose at center
  ctx.save();
  ctx.translate(cx, cy);
  ctx.fillStyle = "rgba(31,25,18,0.55)";
  ctx.strokeStyle = "rgba(31,25,18,0.75)";
  ctx.lineWidth = 1.4;
  for (let i = 0; i < 4; i++) {
    ctx.rotate(Math.PI/2);
    ctx.beginPath();
    ctx.moveTo(0, 0);
    ctx.lineTo(12, -34);
    ctx.lineTo(0, -54);
    ctx.lineTo(-12, -34);
    ctx.closePath();
    ctx.fill();
    ctx.stroke();
  }
  ctx.restore();

  // cardinal letters
  ctx.fillStyle = "rgba(31,25,18,0.7)";
  ctx.font = "bold 22px Georgia";
  ctx.textAlign = "center";
  ctx.textBaseline = "middle";
  ctx.fillText("N", cx, cy - size/2 + 40);
  ctx.fillText("S", cx, cy + size/2 - 40);
  ctx.fillText("E", cx + size/2 - 40, cy);
  ctx.fillText("W", cx - size/2 + 40, cy);

  return c;
}
```

--------------------------------

### MCP Server Configuration

Source: https://context7.com/kitfunso/hippo-memory/llms.txt

Example configuration file (`mcp.json`) for setting up the Hippo MCP server to run as a command.

```json
// .cursor/mcp.json or claude_desktop_config.json
{
  "mcpServers": {
    "hippo-memory": {
      "command": "hippo",
      "args": ["mcp"]
    }
  }
}
```

--------------------------------

### Start Hippo Memory API Server

Source: https://context7.com/kitfunso/hippo-memory/llms.txt

Starts an HTTP daemon that exposes the full memory API. It supports bearer-token authentication and audit logging. By default, it serves on loopback only.

```bash
hippo serve --port 6789
```

--------------------------------

### MCP Server Configuration Example

Source: https://github.com/kitfunso/hippo-memory/blob/master/README.md

Example JSON configuration for an MCP client to connect to the Hippo Memory MCP server. This should be added to your MCP client's configuration file.

```json
{
  "mcpServers": {
    "hippo-memory": {
      "command": "hippo",
      "args": ["mcp"]
    }
  }
}
```

--------------------------------

### Initialization and Game Start

Source: https://github.com/kitfunso/hippo-memory/blob/master/mockups/art-hippocampus-anime.html

Initializes the canvas, sets up event listeners, pushes an initial log message, renders the timeline, and starts the main game loop using requestAnimationFrame.

```javascript
resize(); pushLog("monitor online <span class="em">hippo-chan greets you</span>"); renderTL(); requestAnimationFrame(tick); })();
```

--------------------------------

### Start MCP Server

Source: https://github.com/kitfunso/hippo-memory/blob/master/README.md

Starts the Hippo Memory MCP server over stdio. This command is used for integrating with MCP-compatible clients like Cursor, Windsurf, Cline, and Claude Desktop.

```bash
hippo mcp   # starts MCP server over stdio
```

--------------------------------

### Install and Initialize Hippo Memory

Source: https://github.com/kitfunso/hippo-memory/blob/master/README.md

Installs the hippo-memory package globally and initializes memory for all git repositories on the machine. This command scans the home directory for git repositories and sets up a .hippo/ store in each, seeding it with recent commit history.

```bash
npm install -g hippo-memory && hippo init --scan ~
```

--------------------------------

### Example Hook Block in CLAUDE.md

Source: https://context7.com/kitfunso/hippo-memory/llms.txt

This is an example of the hook block that is added to the `CLAUDE.md` file when the `claude-code` hook is installed.

```markdown
<!-- hippo:start -->
```

--------------------------------

### Initialize UI Directory Structure

Source: https://github.com/kitfunso/hippo-memory/blob/master/docs/plans/2026-04-16-brain-observatory-v025.md

Creates the necessary directories for the UI application. Ensure you are in the project's root directory before running.

```bash
cd C:/Users/skf_s/hippo
mkdir -p ui/src/api ui/src/views ui/src/components
```

--------------------------------

### GitHub Actions Workflow Configuration

Source: https://github.com/kitfunso/hippo-memory/blob/master/docs/plans/2026-05-05-provenance-ci-gate.md

Defines the CI workflow including checkout, Node.js setup, dependency installation, build, testing, and the provenance gate step. Sets a timeout for the job.

```yaml
permissions:
  contents: read

jobs:
  test:
    runs-on: ubuntu-latest
    # codex P1: 15min was tight on first-run npm ci with @xenova/transformers
    # optionalDependency (large native install). 25 gives headroom on a cold cache.
    timeout-minutes: 25
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '22.5.0'
          cache: npm
      - run: npm ci
      - run: npm run build
      - name: Vitest
        run: npx vitest run
      - name: Provenance gate
        run: node scripts/ci-seed-provenance.mjs
      - name: Upload provenance JSON
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: provenance-coverage
          path: provenance-coverage.json
          if-no-files-found: warn
          retention-days: 14
```

--------------------------------

### Hippo Recall Command with Explanation

Source: https://github.com/kitfunso/hippo-memory/blob/master/docs/working-memory-roadmap.md

Example of using the `hippo recall` command with the `--why` flag to get explanations for returned items, including match reasons and source buckets. This was part of PR4.

```bash
hippo recall <query> --why --limit 5
```

--------------------------------

### Build and Deploy Frontend

Source: https://github.com/kitfunso/hippo-memory/blob/master/tests/traps/trap-repo/README.md

Use the PowerShell script to build the frontend and deploy it.

```powershell
.\src\build.ps1
```

--------------------------------

### Manual OpenClaw Hook Configuration

Source: https://github.com/kitfunso/hippo-memory/blob/master/integrations/openclaw.md

Configuration for manual OpenClaw hook installation in AGENTS.md. Includes commands for session start context retrieval, error reporting, outcome logging, and learning from coding sessions.

```markdown
## Project Memory (Hippo)

At the start of every session, run:
hippo context --auto --budget 1500

On errors or unexpected behaviour:
hippo remember "<description of what went wrong>" --error

On task completion:
hippo outcome --good

After significant coding sessions:
hippo learn --git
```

--------------------------------

### Install Dependencies

Source: https://github.com/kitfunso/hippo-memory/blob/master/benchmarks/locomo/README.md

Installs necessary Python packages. Requires the hippo CLI to be installed globally.

```bash
pip install -r requirements.txt
# Requires: hippo CLI installed globally (hippo --version => 0.31.0)
# Judge: uses `claude -p` CLI (no ANTHROPIC_API_KEY required)
```

--------------------------------

### Initialize and Handle Window Resize

Source: https://github.com/kitfunso/hippo-memory/blob/master/mockups/hybrid-v4.html

Sets up the renderer and camera aspect ratio, and adds an event listener to update them on window resize.

```javascript
function resize() {
  const r = container.getBoundingClientRect();
  renderer.setSize(r.width, r.height);
  camera.aspect = r.width / Math.max(r.height, 1);
  camera.updateProjectionMatrix();
}
resize();
window.addEventListener('resize', resize);
```

--------------------------------

### Install Codex Integration

Source: https://github.com/kitfunso/hippo-memory/blob/master/integrations/codex.md

Run this command to manually install or repair the Codex integration if Hippo was installed before Codex.

```bash
hippo hook install codex
```

--------------------------------

### Verify Full Build

Source: https://github.com/kitfunso/hippo-memory/blob/master/docs/plans/2026-04-16-brain-observatory-v025.md

Command to build the UI project. This command should be run from the 'ui' directory and is expected to create a 'dist-ui/' folder at the project root.

```bash
cd C:/Users/skf_s/hippo/ui && npm run build
```

--------------------------------

### Manually Install OpenClaw Hook

Source: https://github.com/kitfunso/hippo-memory/blob/master/integrations/openclaw.md

Install the OpenClaw hook manually for lightweight prompt injection without installing the native plugin. This appends a hippo block to AGENTS.md.

```bash
hippo hook install openclaw
```

--------------------------------

### Initialize Hippo Memory Project

Source: https://github.com/kitfunso/hippo-memory/blob/master/PLAN.md

Use this command to set up the necessary configuration and directory structure for a new Hippo Memory project.

```bash
hippo init
```

--------------------------------

### Initialize Project Context with Hippo

Source: https://github.com/kitfunso/hippo-memory/blob/master/AGENTS.md

Use this command at the start of each task to set the project context and budget. Read the output before writing any code.

```bash
hippo context --auto --budget 1500
```

--------------------------------

### Run the RSI Demo

Source: https://github.com/kitfunso/hippo-memory/blob/master/examples/rsi-demo/README.md

Execute the main agent script to start the demonstration. The output shows the first-attempt success rate over different task windows and the calculated learning gap.

```bash
node agent.mjs
```

--------------------------------

### Outcomes Action Example

Source: https://github.com/kitfunso/hippo-memory/blob/master/benchmarks/micro/README.md

Example of an 'outcomes' action, applying positive or negative outcomes to a remembered item.

```json
{"type": "outcomes", "remember_index": 0, "good": 3, "bad": 0}
```

--------------------------------

### Run Build and Test Suite

Source: https://github.com/kitfunso/hippo-memory/blob/master/docs/plans/2026-04-22-bi-temporal.md

Execute the build process and run the full test suite to verify the migration and implementation. This command should be run after implementing the migration steps.

```bash
npm run build && npx vitest run
```

--------------------------------

### Commit UserPromptSubmit Hook Installation

Source: https://github.com/kitfunso/hippo-memory/blob/master/docs/plans/2026-04-21-pinned-reinject.md

Stages and commits the changes related to installing the UserPromptSubmit hook for pinned-rule re-injection.

```bash
git add src/hooks.ts tests/pinned-hook-install.test.ts
git commit -m "feat(hooks): install UserPromptSubmit entry for pinned-rule re-inject"
```

--------------------------------

### 3D Scene Setup and Animation Loop

Source: https://github.com/kitfunso/hippo-memory/blob/master/mockups/bg-nebula-bio.html

Sets up a 3D scene with animated orbs and pollen particles. Includes a main animation loop that updates object scales, materials, and positions, then re-renders the scene. Handles window resizing to maintain aspect ratio.

```javascript
const edges = new THREE.LineSegments( new THREE.BufferGeometry().setFromPoints(ep), new THREE.LineBasicMaterial({ color: "#2a241e", transparent: true, opacity: 0.25 }) );
scene.add(edges);
const clock = new THREE.Clock();
function frame() {
  const t = clock.getElapsedTime();
  for (const { inner, outer } of orbs) {
    const p1 = 0.10 * Math.sin(t * 0.9 + inner.userData.phase);
    const p2 = 0.16 * Math.sin(t * 0.9 + outer.userData.phase);
    inner.scale.setScalar(inner.userData.base * (1 + p1));
    outer.scale.setScalar(outer.userData.base * (1 + p2));
    outer.material.opacity = 0.18 + 0.12 * Math.sin(t * 0.9 + outer.userData.phase);
  }
  // pollen drift + gentle sway, wrap when out of bounds
  const pArr = pollenGeom.attributes.position.array;
  for (let i = 0; i < POLLEN_COUNT; i++) {
    const k = i * 3;
    const sway = 0.03 * Math.sin(t * 0.7 + pollenPhase[i]);
    pArr[k] += pollenVel[k] + sway * 0.02;
    pArr[k+1] += pollenVel[k+1];
    pArr[k+2] += pollenVel[k+2] + sway * 0.01;
    if (pArr[k+1] > 32) {
      pArr[k] = (rand() - 0.5) * pollenSpread * 2;
      pArr[k+1] = -3;
      pArr[k+2] = (rand() - 0.5) * pollenSpread * 2;
    }
  }
  pollenGeom.attributes.position.needsUpdate = true;
  controls.update();
  renderer.render(scene, camera);
  requestAnimationFrame(frame);
}
frame();
window.addEventListener("resize", () => {
  camera.aspect = window.innerWidth / window.innerHeight;
  camera.updateProjectionMatrix();
  renderer.setSize(window.innerWidth, window.innerHeight);
});
```

--------------------------------

### Run Sequential Learning Benchmark

Source: https://github.com/kitfunso/hippo-memory/blob/master/README.md

Command to execute the sequential learning benchmark using all available adapters. Navigate to the benchmarks/sequential-learning directory first.

```bash
cd benchmarks/sequential-learning
node run.mjs --adapter all
```

--------------------------------

### Recall Pre-Action Example

Source: https://github.com/kitfunso/hippo-memory/blob/master/benchmarks/micro/README.md

Example of a 'recall' pre-action for a query, used to bump the retrieval count of a specific memory.

```json
{"type": "recall", "query": "marker-pineal-1", "remember_index": 0, "times": 3}
```

--------------------------------

### Supersede Action Example

Source: https://github.com/kitfunso/hippo-memory/blob/master/benchmarks/micro/README.md

Example of a 'supersede' action within a fixture, updating the content of a specific remembered item.

```json
{"type": "supersede", "remember_index": 0,
     "new_content": "Bob switched to oat milk flat white"}
```

--------------------------------

### Build and Test Commands

Source: https://github.com/kitfunso/hippo-memory/blob/master/docs/plans/2026-04-16-brain-observatory-v025.md

Commands to build the project, run tests, and start the dashboard locally. Ensure you are in the project root directory.

```bash
cd C:/Users/skf_s/hippo
npm run build:all
npm run test
node bin/hippo.js dashboard
# Open http://localhost:3333
# Verify: particles render, hover tooltips work, search filters, detail panel opens, conflicts show
```

--------------------------------

### Initialize Benchmark Runner Script

Source: https://github.com/kitfunso/hippo-memory/blob/master/docs/plans/2026-04-21-model-aware-hippo.md

Sets up the main script for running model profile benchmarks. Imports necessary modules and parses command-line flags for models, profiles, and output destinations. It reads the benchmark corpus from a JSON file.

```javascript
#!/usr/bin/env node
import * as fs from 'node:fs';
import { execFileSync } from 'node:child_process';
import { judge } from './model-profile-judge.mjs';

const corpus = JSON.parse(fs.readFileSync('evals/model-profile-bench.json', 'utf8'));

const TARGET_MODELS = flag('--models', 'claude-opus-4-6,claude-opus-4-7').split(',');
const PROFILES = flag('--profiles', 'default').split(',');
const OUT = flag('--out', 'evals/baseline-profile-bench.json');
// No API key check — uses claude CLI subscription
```

--------------------------------

### Install Hippo Memory

Source: https://github.com/kitfunso/hippo-memory/blob/master/README.md

Installs the hippo-memory package globally using npm. This is the first step before initializing memory for projects.

```bash
npm install -g hippo-memory
```

--------------------------------

### Run Sequential Learning Benchmark

Source: https://github.com/kitfunso/hippo-memory/blob/master/benchmarks/sequential-learning/README.md

Execute the benchmark script. Options include running all conditions, a specific adapter, or customizing the output directory.

```bash
# Run all conditions
node benchmarks/sequential-learning/run.mjs

# Run a specific adapter
node benchmarks/sequential-learning/run.mjs --adapter hippo
node benchmarks/sequential-learning/run.mjs --adapter static
node benchmarks/sequential-learning/run.mjs --adapter none

# Custom output directory
node benchmarks/sequential-learning/run.mjs --output my-results/
```

--------------------------------

### Start stdio MCP Server

Source: https://context7.com/kitfunso/hippo-memory/llms.txt

Launches the Hippo MCP server to expose tools over stdio, allowing integration with compatible agents.

```bash
hippo mcp
```

--------------------------------

### Slack Webhook POST Request Example

Source: https://github.com/kitfunso/hippo-memory/blob/master/docs/plans/2026-04-29-e1.3-slack-ingestion.md

Example of a POST request to the Slack events endpoint with necessary headers for signature verification.

```typescript
method: 'POST',
      headers: { 'content-type': 'application/json', 'x-slack-request-timestamp': ts, 'x-slack-signature': sign(ts, body) },
      body,
    });
    expect(res.status).toBe(200);
    // DLQ row exists.
    const { openHippoDb, closeHippoDb } = await import('../src/db.js');
    const db = openHippoDb(root);
    try {
      const row = db.prepare(`SELECT COUNT(*) as c FROM slack_dlq`).get() as { c: number };
      expect(Number(row.c)).toBe(1);
    } finally { closeHippoDb(db); }
```

--------------------------------

### Run Sequential Learning Benchmark (Node.js)

Source: https://github.com/kitfunso/hippo-memory/blob/master/benchmarks/README.md

Execute the sequential learning benchmark using Node.js. Ensure you have Node.js 22.5+ installed. This command runs all available adapters.

```bash
cd sequential-learning
node run.mjs --adapter all
```

--------------------------------

### Goal Push Pre-Action Example

Source: https://github.com/kitfunso/hippo-memory/blob/master/benchmarks/micro/README.md

Example of a 'goal_push' pre-action for a query, used to set a named goal for the 'hippo recall' command.

```json
{"op": "goal_push", "name": "db-rewrite", "session_id": "s-db"}
```

--------------------------------

### Initialization and Resize Handling (JavaScript)

Source: https://github.com/kitfunso/hippo-memory/blob/master/mockups/art-hippocampus-breathing.html

Sets up the initial state of the animation, including resizing the canvas and starting the animation loop. It also seeds the log with initial status messages.

```javascript
// ---------- init ----------
resize();
// seed a couple of log lines so it's not empty on load
pushLog(`monitor online :: <span class="em">12.0 bpm baseline</span>`);
renderTL();
rafId = requestAnimationFrame(tick);
})();
```