diff --git a/adolf/HINDSIGHT-MIGRATION.md b/adolf/HINDSIGHT-MIGRATION.md
new file mode 100644
index 0000000..fe702de
--- /dev/null
+++ b/adolf/HINDSIGHT-MIGRATION.md
@@ -0,0 +1,219 @@
+# Adolf memory migration — Cognee → Hindsight
+
+**Status:** Planned · **Date:** 2026-07-13 · **Owner:** alvis
+
+This is the authoritative design + plan for replacing Adolf's long-term memory
+subsystem (**Cognee**) with **Hindsight** (Vectorize, MIT, self-hosted). It
+supersedes the Cognee-specific parts of `docs/ARCHITECTURE.md` and gates 4–5 of
+`docs/SPIKE-FINDINGS.md` in the OpenClaw fork (`/home/alvis/adolf`).
+
+Memory stays integrated into Adolf **exactly the two ways Cognee was** — as a
+**tool** (MCP) and as **forced hooks** (an OpenClaw memory plugin) — so no
+behaviour the user sees is lost; only the backend changes.
+
+> Scope note: this document + the kanboard **Ready** tasks (H1–H5) are the
+> migration. No live service, compose file, `openclaw.json`, or plugin code has
+> been changed yet — those edits are the H-tasks.
+
+---
+
+## 1. Why migrate
+
+Cognee works, but its Agap deployment carries three structural costs, all
+documented in the (now-retired) kanboard cognee tasks:
+
+- **Three bespoke services** to keep the memory stack alive: `cognee` (FastAPI +
+  embedded Kuzu graph + Qdrant vectors), `cognee-mcp` (a patched MCP→HTTP proxy,
+  local build overlay from kb#70), and `cognee-llm` (a stateless Kimi-CLI wrapper
+  that exists *only* to give Cognee an LLM on the flat subscription).
+- **The cognify pipeline is fragile and expensive.** "Cognify" (turning raw
+  turns into a graph) is an LLM step. On the Kimi CLI it runs ~5–24 s per call
+  and drains the single-seat subscription quota (SPIKE gate 5 recommended
+  LiteLLM instead). The plugin's async "cognify sweep" also silently stalled
+  twice (kb#69) because of OpenClaw plugin-lifecycle edge cases, so freshly told
+  facts weren't retrievable cross-session until the sweep was re-armed.
+- **Scoping is best-effort.** Under `ENABLE_BACKEND_ACCESS_CONTROL=False` all
+  datasets share one graph/vector backend, so per-chat isolation leaks (kb#59).
+
+## 2. What Hindsight gives us
+
+- **One container.** `ghcr.io/vectorize-io/hindsight:latest` — REST API on
+  **:8888**, web UI on **:9999**, built-in PostgreSQL (`pg0`, persisted under
+  `/home/hindsight/.pg0`). It owns its own vector + graph + temporal
+  representation internally (the "four-network" model), so **no external Qdrant
+  or Kuzu** is needed for memory.
+- **Built-in MCP server** mounted at `/mcp` on the same port — ~30 tools
+  including `retain` / `recall` / `reflect`. This **removes the need for a
+  separate `cognee-mcp` proxy container entirely**.
+- **Retain learns on its own.** `retain` runs Hindsight's extraction/reflection
+  pipeline internally (optionally `async`), so there is **no separate "cognify
+  sweep" to arm, throttle, or watch** — the whole class of kb#69 bugs disappears.
+- **Memory banks** are first-class isolation units, scoped by URL path
+  (`/v1/{tenant}/banks/{bank_id}/…`), so per-chat / per-user scoping is real, not
+  best-effort.
+- **Bring-your-own LLM/embeddings** — OpenAI-compatible, Anthropic, Ollama,
+  LMStudio, etc. We point it at the infra we already run (LiteLLM `:4000` and/or
+  Ollama), so we can **delete `cognee-llm`** rather than port it.
+
+Net: **3 services → 1**, plus we drop the cognify-sweep machinery.
+
+## 3. Target architecture
+
+```
+Matrix ⇄ OpenClaw ("Adolf" gateway)
+             │  provider adolf-llm (Kimi wrapper, :8010)  — unchanged
+             ▼
+        adolf-llm ── kimi CLI (agent)
+             │
+   ┌─────────┴───────────────── memory is a boundary concern ─────────────┐
+   │                                                                       │
+   │  (a) FORCED HOOKS — hindsight-memory OpenClaw plugin                  │
+   │      before_prompt_build → recall  → inject as prependContext        │
+   │      agent_end            → retain (async:true) the turn             │
+   │                                                                       │
+   │  (b) TOOL — Hindsight built-in MCP in openclaw.json mcp.servers       │
+   │      http://hindsight:8888/mcp/adolf/  → retain/recall/reflect/…      │
+   └───────────────────────────────┬───────────────────────────────────────┘
+                                    ▼
+                        hindsight  (ONE container)
+                          :8888 REST + /mcp   ·   :9999 UI
+                          built-in Postgres (pg0)
+                          LLM  → LiteLLM :4000 (or Ollama)   [decision, §6]
+                          embeddings → Ollama / built-in     [decision, §6]
+```
+
+Reused infra: **LiteLLM `:4000`** and/or **Ollama** for Hindsight's model calls.
+**Retired:** `cognee`, `cognee-mcp`, `cognee-llm`, Qdrant-for-cognee, Kuzu, the
+`cognee-openclaw-plugin`, and all `openclaw.json` cognee references.
+
+### 3.1 Surface (a) — forced hooks (the `hindsight-memory` plugin)
+
+A new OpenClaw memory plugin replacing `cognee-openclaw-plugin`, modelled on the
+same Honcho touchpoints Cognee used, so the plugin shape is familiar:
+
+| Cognee plugin (`cognee-memory`)                     | Hindsight plugin (`hindsight-memory`)                         |
+|-----------------------------------------------------|---------------------------------------------------------------|
+| `before_prompt_build` → LLM-free graph recall inject | `before_prompt_build` → `recall` → inject `prependContext`    |
+| `agent_end` → raw `/add` (no inline cognify)         | `agent_end` → `retain` (`async:true`) the user+assistant turn |
+| throttled **cognify sweep** (dirty-tracker, timers)  | **removed** — retain does extraction/learning internally      |
+| `cognee_recall` registered tool                      | `hindsight_recall` (+ optional `hindsight_reflect`) tool      |
+
+- Activated via `plugins.entries.hindsight-memory` in `openclaw.json` with the
+  same hook grants Cognee needed: `hooks.allowConversationAccess: true` and
+  `allowPromptInjection: true` (external plugins must opt in).
+- **Recall stays off the hot LLM path.** Hindsight `recall` is retrieval
+  (semantic + BM25 + graph + temporal) with evidence scoring — no generative
+  synthesis — so it's the direct analogue of Cognee's LLM-free `onlyContext`
+  recall. The LLM-backed synthesis path is `reflect`, exposed as a deliberate
+  tool, not run per-turn.
+- **No freshness dial / sweep.** Retain with `async:true` returns fast and lets
+  Hindsight extract/consolidate in the background; there is no plugin-owned timer
+  to stall.
+- Same "untrusted metadata" framing on the injected block; same cleaning of
+  OpenClaw's `Conversation info (untrusted metadata):` and the memory block out
+  of stored/queried text.
+
+### 3.2 Surface (b) — tool (built-in MCP)
+
+Replace the `cognee` entry in `openclaw.json` `mcp.servers` with:
+
+```jsonc
+mcp: {
+  servers: {
+    hindsight: {
+      type: "http",
+      url: "http://hindsight:8888/mcp/adolf/",   // bank-scoped by URL path
+    },
+    // openclaw-tools, kanboard, marketplace — unchanged
+  },
+}
+```
+
+The single bank in the path (`adolf`, or a per-chat bank) selects isolation; the
+built-in MCP then exposes `retain`, `recall`, `reflect`, plus mental-model /
+directive / memory-browse tools. This replaces cognee-mcp's `remember` / `recall`
+/ `forget` — and gives deliberate delete via the memory-management tools instead
+of the hand-patched `forget(data_id)` from kb#70.
+
+## 4. REST / MCP API mapping
+
+Base path: `http://hindsight:8888/v1/default` (tenant `default`). Bank id is a
+**path** parameter.
+
+| Operation        | Cognee (old)                                   | Hindsight (new)                                                        |
+|------------------|------------------------------------------------|-----------------------------------------------------------------------|
+| store a turn     | `POST /api/v1/add` (+ later `/cognify`)        | `POST /banks/{bank}/memories`  body `{items:[{content,context,tags,timestamp}], async:true}` |
+| recall (no LLM)  | `POST /api/v1/search` `GRAPH_COMPLETION` `onlyContext:true` | `POST /banks/{bank}/memories/recall`  body `{query, budget, max_tokens, tags}` |
+| deep answer (LLM)| cognee-mcp `recall` (GRAPH_COMPLETION)         | `POST /banks/{bank}/reflect`  body `{query, budget, max_tokens, response_schema?}` |
+| delete an entry  | patched `forget(dataset, data_id)` (kb#70)     | memory-management endpoints / MCP (`delete`, `clear_memories`)        |
+| list / inspect   | dataset status polling                         | `GET /banks/{bank}/memories/list`, `GET /banks`                       |
+| create bank      | dataset created implicitly on add              | `PUT /banks/{bank}`                                                    |
+
+Built-in MCP tools live at `http://hindsight:8888/mcp/{bank}/` (HTTP transport;
+bank via URL path, `X-Bank-Id` header, or `HINDSIGHT_MCP_BANK_ID` default).
+
+> Exact request-body field names and any auth headers must be confirmed against
+> the running instance's OpenAPI (`http://localhost:8888/docs`) and the Hindsight
+> configuration docs during H1 — treat the bodies above as the shape, not gospel.
+
+## 5. Bank scoping
+
+Mirror Cognee's per-conversation `chat_<chatId>` dataset with a per-conversation
+**bank**: derive `bank_id` from OpenClaw's `chat_id` (the
+`Conversation info (untrusted metadata):` block; see SPIKE gate 2), sanitized to
+`chat_<slug>`. A single shared `adolf` bank is the simpler alternative if
+cross-chat recall is actually wanted — decide in H3. Banks are hard isolation in
+Hindsight, so per-chat is now safe (unlike Cognee's leaky datasets).
+
+## 6. Open decisions (resolve in H1)
+
+1. **LLM backend for retain/reflect.** SPIKE gate 5 already concluded the
+   extraction workload should *not* sit on the Kimi CLI (latency + single-seat
+   quota). Recommendation: point Hindsight's LLM at **LiteLLM `:4000`** (or a
+   local **Ollama** model for zero marginal cost). This is why `cognee-llm` is
+   deleted, not ported. Confirm Hindsight's provider env-var names on the image.
+2. **Embeddings.** Prefer the local **Ollama** embedder already available
+   (`nomic-embed` / `bge-m3` at `host.docker.internal:11436`) or Hindsight's
+   built-in, to keep embeddings off any paid path.
+3. **Storage path.** Persist `pg0` under `/mnt/ssd/dbs/hindsight/` to match the
+   Agap storage layout (replaces `/mnt/ssd/dbs/cognee/`).
+4. **UI exposure.** Whether to reverse-proxy the `:9999` UI (Caddy) or keep it
+   internal-only.
+5. **Auth.** Open by default; enable the tenant API-key extension
+   (`HINDSIGHT_API_TENANT_API_KEY`, `Authorization: Bearer`) if the service is
+   reachable beyond the compose network.
+
+## 7. Data migration
+
+Cognee's Kuzu graph is **not** portable into Hindsight's store. The memory corpus
+is low-value conversational history, so **start Hindsight empty** rather than
+building an exporter. Optionally replay a handful of durable facts by calling
+`retain` once at cutover. The two throwaway datasets left in Cognee
+(`chat_verify`, `chat_webchat`) are discarded with the stack.
+
+## 8. Migration phases (kanboard **Ready**, project *Adolf*)
+
+- **H1 · Deploy Hindsight service** — add the `hindsight` container to
+  `openai/docker-compose.yml` (image, ports 8888/9999, `pg0` volume, LLM +
+  embedding provider env → LiteLLM/Ollama), bring it up, confirm `/docs` + a
+  round-trip `retain`→`recall`. Resolves §6 decisions.
+- **H2 · Wire built-in MCP as an Adolf tool** — swap `mcp.servers.cognee` →
+  `mcp.servers.hindsight` (`/mcp/{bank}/`) in `openclaw.json`; verify Adolf can
+  call `retain`/`recall`/`reflect` as tools.
+- **H3 · `hindsight-memory` OpenClaw plugin (forced hooks)** — build the plugin
+  replacing `cognee-openclaw-plugin`: `before_prompt_build`→recall inject,
+  `agent_end`→`retain(async)`, `hindsight_recall`/`hindsight_reflect` tools, bank
+  scoping; activate in `openclaw.json`. Delete the cognify-sweep machinery.
+- **H4 · Decommission Cognee** — remove `cognee`, `cognee-mcp`, `cognee-llm`
+  services + volumes, the `cognee-openclaw-plugin`, and all `openclaw.json`/
+  `shared-mcp.json` cognee references. Free `/mnt/ssd/dbs/cognee`.
+- **H5 · End-to-end verification** — state a fact → fresh session → recalled via
+  injected memory (no LLM on the recall path); measure recall latency; confirm
+  per-bank isolation; confirm no sweep/timer exists to stall.
+
+## 9. What is unchanged
+
+The Kimi/OpenClaw/Matrix substrate is untouched: `adolf` gateway, `adolf-llm`
+(:8010) provider, the SSE-heartbeat/idle-watchdog fix (kb#71), the
+`openclaw-tools` bridge, `kanboard`/`marketplace` MCP servers, Matrix allow-list
+and E2EE. Only the memory backend and its two integration surfaces change.
diff --git a/adolf/openclaw.json b/adolf/openclaw.json
index 7723154..777ed29 100644
--- a/adolf/openclaw.json
+++ b/adolf/openclaw.json
@@ -43,8 +43,12 @@
         // Margin above the server.js SSE heartbeat cadence (empty-content
         // keepalive delta every ~25s once idle) so the idle watchdog never
         // fires on long thinking/tool/MCP phases even if a heartbeat tick
-        // is delayed (kb #71).
-        timeoutSeconds: 300,
+        // is delayed (kb #71). Raised to 10min: long agentic turns (Cognee
+        // tool-loops / recalls up to 150s each) were producing no *content*
+        // progress for >300s, tripping "no response from model" and surfacing
+        // an error before the agent finished. The wrapper now also kills the
+        // kimi child on disconnect, so an over-timeout turn no longer orphans.
+        timeoutSeconds: 600,
         models: [
           { id: "adolf", name: "Adolf", input: ["text", "image"] },
         ],
@@ -93,9 +97,9 @@
   // OpenClaw's documented CLI-native alias for transport: "streamable-http".
   mcp: {
     servers: {
-      cognee: {
+      hindsight: {
         type: "http",
-        url: "http://cognee-mcp:8000/mcp",
+        url: "http://hindsight:8888/mcp/adolf/",
       },
       "openclaw-tools": {
         type: "http",
@@ -130,18 +134,56 @@
     },
   },
 
-  // Cognee memory plugin (P8) — installed external plugin under
-  // .openclaw/extensions/cognee-memory. Activation entry is required for the
-  // gateway to load it at startup (discovery alone is not enough).
+  // Memory plugins (P8). Activation entry is required for the gateway to
+  // load a plugin at startup (discovery alone is not enough).
   plugins: {
     entries: {
+      // Cognee memory plugin — DISABLED as of kb #75 (H3): superseded by
+      // hindsight-memory below. Left `enabled: false` rather than removed —
+      // full teardown (plugin dir, cognee/cognee-mcp/cognee-llm containers)
+      // is kb #75's H4, a separate step so the Hindsight path can be proven
+      // out first. Kept disabled (not both active) to avoid double
+      // prependContext injection and double persisted turns while both
+      // backends exist side by side.
       "cognee-memory": {
-        enabled: true,
+        enabled: false,
         // External (non-bundled) plugins must opt in to conversation + prompt-injection
         // hook access explicitly. before_prompt_build => allowPromptInjection;
         // agent_end => allowConversationAccess.
         hooks: { allowConversationAccess: true, allowPromptInjection: true },
-        config: {},
+        // Throttle background cognify hard to stop it draining the Kimi quota:
+        // one cognify per dataset per hour (was 5 min default), and a longer
+        // persist timeout so /add doesn't fail-and-retry when cognee is busy.
+        config: {
+          sweepIntervalMs: 3600000, // 1h (default 300000 = 5min)
+          persistTimeoutMs: 20000,  // 20s (default 8000)
+        },
+      },
+      // Hindsight memory plugin (kb #75, H3) — installed external plugin
+      // under .openclaw/extensions/hindsight-memory, bind-mounted read-only
+      // from openai/hindsight-openclaw-plugin (see that project's
+      // docker-compose.yml adolf.volumes). Structural successor to
+      // cognee-memory above: LLM-free recall inject (before_prompt_build) +
+      // async retain (agent_end) against the hindsight service, bank
+      // "adolf" (same bank the mcp.servers.hindsight tool surface above
+      // uses, so hook-based and tool-based memory stay one consistent
+      // store). No cognify/sweep config here — Hindsight's retain does
+      // extraction/consolidation server-side, so that whole class of
+      // config (sweepIntervalMs etc. above) doesn't apply.
+      "hindsight-memory": {
+        enabled: true,
+        // Same opt-in requirement as cognee-memory above: before_prompt_build
+        // => allowPromptInjection; agent_end => allowConversationAccess.
+        hooks: { allowConversationAccess: true, allowPromptInjection: true },
+      },
+      // Kimi quota readout (kb #62) — installed external plugin, bind-mounted
+      // read-only from openai/quota-command-openclaw-plugin (see that
+      // project's docker-compose.yml adolf.volumes) onto
+      // .openclaw/extensions/quota-command. Registers a `/quota` native
+      // command; no hooks, so no allowConversationAccess/allowPromptInjection
+      // opt-in needed.
+      "quota-command": {
+        enabled: true,
       },
     },
   },
diff --git a/openai/adolf-llm/server.js b/openai/adolf-llm/server.js
index 742018b..5693182 100644
--- a/openai/adolf-llm/server.js
+++ b/openai/adolf-llm/server.js
@@ -65,23 +65,16 @@ function writeMcpConfig(dir) {
 }
 
 // ---------------------------------------------------------------------------
-// Cognee auto-memory hooks (§3.2). Both are STUBS today — the cognee service is
-// P4 and does not exist yet. They are deliberately non-blocking: a turn must
-// never wait on (or fail because of) memory. Wire the real cognee-mcp calls in
-// P4 and the rest of the turn pipeline stays unchanged.
-
-// Pre-turn auto-retrieve: returns a string of relevant memories to inject ahead
-// of the user prompt, or null for "nothing to inject".
-// TODO(P4): call cognee memory_search / cognee.search() scoped by chatId.
-async function cogneeSearch(_query, _chatId) {
-  return null;
-}
-
-// Post-turn auto-ingest: fire-and-forget; never awaited by the turn path.
-// TODO(P4): async cognee.add(user + assistant) via cognee-mcp, scoped by chatId.
-async function cogneeAdd(_userText, _assistantText, _chatId) {
-  return;
-}
+// Memory lives at the OpenClaw layer, not here (P8). The Adolf gateway loads
+// the `cognee-memory` OpenClaw plugin, which owns all memory touchpoints:
+//   - before_prompt_build => LLM-free cognee graph recall, injected into the
+//     prompt this wrapper then receives from OpenClaw.
+//   - agent_end           => raw `add` of the turn to cognee.
+//   - background sweep     => async `cognify` on cognee-llm (Kimi).
+//   - cognee_recall tool + cognee-mcp `recall` for on-demand deep queries.
+// This wrapper is therefore a dumb model endpoint again: it must never call
+// cognee itself. The former cogneeSearch/cogneeAdd stubs (and their call sites)
+// were deleted when the plugin took over (P8).
 
 // ---------------------------------------------------------------------------
 // Persistent conversation -> Kimi session map.
@@ -242,9 +235,8 @@ async function persistImage(url, dir, n) {
 }
 
 // Build the prompt for the current user turn: join text parts, persist any
-// image parts, append path references. `injectedMemory` (from cogneeSearch) is
-// prepended when present.
-async function buildPrompt(userMsg, dir, injectedMemory) {
+// image parts, append path references.
+async function buildPrompt(userMsg, dir) {
   const content = userMsg.content;
   const textParts = [];
   const imageRefs = [];
@@ -275,9 +267,6 @@ async function buildPrompt(userMsg, dir, injectedMemory) {
   if (imageRefs.length) {
     prompt += '\n\n' + imageRefs.map(r => `See attached image: ${r}`).join('\n');
   }
-  if (injectedMemory) {
-    prompt = `Relevant memories (retrieved automatically):\n${injectedMemory}\n\n---\n\n${prompt}`;
-  }
   return prompt;
 }
 
@@ -288,8 +277,9 @@ async function buildPrompt(userMsg, dir, injectedMemory) {
 //   {"type":"session.resume_hint","session_id":"..."}    -> capture session id
 // onDelta(chunk) is called per assistant content fragment as it arrives.
 // Resolves { text, sessionId } once the process closes.
-function runKimi({ prompt, cwd, resumeId, onDelta }) {
+function runKimi({ prompt, cwd, resumeId, onDelta, signal }) {
   return new Promise((resolve, reject) => {
+    if (signal?.aborted) { reject(new Error('aborted before start')); return; }
     const args = [];
     if (resumeId) args.push('-r', resumeId);
     args.push('-p', prompt, '--output-format', 'stream-json');
@@ -300,6 +290,19 @@ function runKimi({ prompt, cwd, resumeId, onDelta }) {
     let stderr = '';
     const parts = [];
     let sessionId = null;
+    let settled = false;
+    let aborted = false;
+
+    // If the caller aborts (the gateway/client disconnected — e.g. its idle
+    // watchdog gave up), kill the child so it doesn't keep grinding an
+    // orphaned agent turn to completion, wasting Kimi quota and streaming into
+    // a dead socket. SIGTERM first, hard SIGKILL if it lingers.
+    const onAbort = () => {
+      aborted = true;
+      try { child.kill('SIGTERM'); } catch {}
+      setTimeout(() => { try { child.kill('SIGKILL'); } catch {} }, 3000).unref();
+    };
+    if (signal) signal.addEventListener('abort', onAbort, { once: true });
 
     function handleLine(line) {
       const t = line.trim();
@@ -324,11 +327,21 @@ function runKimi({ prompt, cwd, resumeId, onDelta }) {
     });
     child.stderr.on('data', d => { stderr += d; });
 
-    child.on('error', reject);
+    child.on('error', err => {
+      if (settled) return;
+      settled = true;
+      if (signal) signal.removeEventListener('abort', onAbort);
+      reject(err);
+    });
     child.on('close', code => {
+      if (settled) return;
+      settled = true;
+      if (signal) signal.removeEventListener('abort', onAbort);
       if (buf) handleLine(buf); // flush any trailing partial line
       const text = parts.join('').trim();
-      if (!text && code !== 0) {
+      if (aborted) {
+        reject(new Error('aborted: client disconnected'));
+      } else if (!text && code !== 0) {
         reject(new Error(`kimi exited ${code}: ${stderr.slice(0, 2000)}`));
       } else {
         resolve({ text, sessionId });
@@ -341,7 +354,7 @@ function runKimi({ prompt, cwd, resumeId, onDelta }) {
 // One turn: resolve session (chat_id primary, history-hash fallback), persist
 // media + .mcp.json, run kimi (streaming through onDelta), record the mapping,
 // and fire the async cognee ingest. Returns { text }.
-async function handleTurn(messages, onDelta) {
+async function handleTurn(messages, onDelta, signal) {
   const turns = convTurns(messages);
   let lastUserIdx = -1;
   for (let i = turns.length - 1; i >= 0; i--) {
@@ -396,24 +409,21 @@ async function handleTurn(messages, onDelta) {
   fs.mkdirSync(dir, { recursive: true });
   writeMcpConfig(dir); // Gate 1: shared MCP via project-root .mcp.json
 
-  // Pre-turn auto-retrieve (STUB no-op today; never blocks meaningfully).
-  const injectedMemory = await cogneeSearch(textOf(userMsg), chatId);
-
   let prompt;
   if (reseed) {
-    // Rebuild the whole conversation for a fresh session, plus current media/memory.
+    // Rebuild the whole conversation for a fresh session, plus current media.
     const base = renderTranscript(turns.slice(0, lastUserIdx + 1));
-    const media = await buildPrompt(userMsg, dir, injectedMemory);
+    const media = await buildPrompt(userMsg, dir);
     // buildPrompt already includes the current user text; for reseed we want the
-    // transcript to carry it, so only append image refs / injected memory extras.
+    // transcript to carry it, so only append image refs.
     prompt = base;
     const extra = media.replace(textOf(userMsg), '').trim();
     if (extra) prompt += `\n\n${extra}`;
   } else {
-    prompt = await buildPrompt(userMsg, dir, injectedMemory);
+    prompt = await buildPrompt(userMsg, dir);
   }
 
-  const { text, sessionId } = await runKimi({ prompt, cwd: dir, resumeId, onDelta });
+  const { text, sessionId } = await runKimi({ prompt, cwd: dir, resumeId, onDelta, signal });
 
   // Record the forward mapping.
   const entry = { convId, sessionId: sessionId || resumeId, dir, ts: Date.now() };
@@ -425,12 +435,187 @@ async function handleTurn(messages, onDelta) {
   }
   persistMap();
 
-  // Post-turn auto-ingest (STUB no-op today; fire-and-forget, never awaited).
-  cogneeAdd(textOf(userMsg), text, chatId).catch(() => {});
-
   return { text };
 }
 
+// ---------------------------------------------------------------------------
+// Kimi quota readout (kb #62). GET /usage — the claude-usage analog for
+// Adolf. LLM-free: hits Kimi's own managed-usage endpoint directly, never
+// spawns `kimi`. Mirrors the parsing logic of the installed
+// @moonshot-ai/kimi-code CLI itself (decompiled from dist/main.mjs's
+// parseManagedUsagePayload/toUsageRow/limitLabel/resetHintFrom — same
+// endpoint, same response shape) so bucket labels/derivations stay in sync
+// with what `kimi` would show via its own /usage-equivalent.
+//
+// Token source: the CLI's own OAuth creds file, kept fresh by the running
+// `kimi` process (adolf-llm-home volume). We only ever READ that file. If
+// its access_token is stale/expired we refresh in memory (POST
+// https://auth.kimi.com/api/oauth/token, form-encoded, grant_type=
+// refresh_token — endpoint + client_id taken from the same decompiled
+// KIMI_CODE_FLOW_CONFIG/refreshAccessToken) and cache the result in a
+// module-level variable ONLY — we deliberately never write the refreshed
+// token back to the creds file, since the live CLI owns that file and a
+// racing write from here could corrupt/rotate state it depends on.
+const KIMI_CREDS_PATH = '/root/.kimi-code/credentials/kimi-code.json';
+const KIMI_OAUTH_HOST = 'https://auth.kimi.com';
+const KIMI_CLIENT_ID = '17e5f671-d194-4dfb-9706-5516cb48c098';
+const KIMI_USAGES_URL = 'https://api.kimi.com/coding/v1/usages';
+
+let kimiMemToken = null; // { access_token, expires_at } — in-memory only, never persisted
+
+async function loadKimiCreds() {
+  const raw = await fs.promises.readFile(KIMI_CREDS_PATH, 'utf8');
+  return JSON.parse(raw);
+}
+
+async function refreshKimiToken(refreshToken) {
+  const body = new URLSearchParams({
+    client_id: KIMI_CLIENT_ID,
+    grant_type: 'refresh_token',
+    refresh_token: refreshToken,
+  }).toString();
+  const res = await fetch(`${KIMI_OAUTH_HOST}/api/oauth/token`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded', Accept: 'application/json' },
+    body,
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok || typeof data.access_token !== 'string') {
+    throw new Error(`kimi oauth refresh failed (HTTP ${res.status}): ${data.error || data.error_description || 'unknown error'}`);
+  }
+  return {
+    access_token: data.access_token,
+    expires_at: Math.floor(Date.now() / 1000) + Number(data.expires_in || 900),
+  };
+}
+
+// Resolve a usable access token, preferring the creds-file token (kept fresh
+// by the live CLI) and falling back to an in-memory refresh only when that
+// one is stale/expired.
+async function getKimiAccessToken(forceRefresh) {
+  const creds = await loadKimiCreds();
+  const now = Math.floor(Date.now() / 1000);
+  if (!forceRefresh && creds.access_token && creds.expires_at && now < creds.expires_at - 30) {
+    return creds.access_token;
+  }
+  if (!forceRefresh && kimiMemToken && now < kimiMemToken.expires_at - 30) {
+    return kimiMemToken.access_token;
+  }
+  if (!creds.refresh_token) throw new Error('no refresh_token in kimi credentials file');
+  kimiMemToken = await refreshKimiToken(creds.refresh_token);
+  return kimiMemToken.access_token;
+}
+
+async function fetchKimiUsagesRaw() {
+  let token = await getKimiAccessToken(false);
+  let res = await fetch(KIMI_USAGES_URL, { headers: { Authorization: `Bearer ${token}`, Accept: 'application/json' } });
+  if (res.status === 401) {
+    token = await getKimiAccessToken(true); // force one in-memory refresh + retry
+    res = await fetch(KIMI_USAGES_URL, { headers: { Authorization: `Bearer ${token}`, Accept: 'application/json' } });
+  }
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`kimi /usages HTTP ${res.status}: ${text.slice(0, 500)}`);
+  }
+  return res.json();
+}
+
+function isRecord(v) { return v !== null && typeof v === 'object' && !Array.isArray(v); }
+
+function toInt(v) {
+  if (typeof v === 'number') return Number.isFinite(v) ? Math.trunc(v) : null;
+  if (typeof v === 'string') { const n = Number(v); return Number.isFinite(n) ? Math.trunc(n) : null; }
+  return null;
+}
+
+// Port of the CLI's limitLabel(): prefer an explicit name/title/scope field,
+// else derive "<N>h limit" / "<N>m limit" / "<N>d limit" from the window's
+// duration+timeUnit.
+function kimiLimitLabel(item, detail, window, idx) {
+  for (const key of ['name', 'title', 'scope']) {
+    const v = item[key] ?? detail[key];
+    if (typeof v === 'string' && v) return v;
+  }
+  const duration = toInt(window.duration ?? item.duration ?? detail.duration);
+  const rawUnit = window.timeUnit ?? item.timeUnit ?? detail.timeUnit;
+  const timeUnit = typeof rawUnit === 'string' ? rawUnit : '';
+  if (duration !== null) {
+    if (timeUnit.includes('MINUTE')) {
+      if (duration >= 60 && duration % 60 === 0) return `${duration / 60}h limit`;
+      return `${duration}m limit`;
+    }
+    if (timeUnit.includes('HOUR')) return `${duration}h limit`;
+    if (timeUnit.includes('DAY')) return `${duration}d limit`;
+    return `${duration}s limit`;
+  }
+  return `Limit #${idx + 1}`;
+}
+
+function kimiResetIso(raw) {
+  for (const key of ['reset_at', 'resetAt', 'reset_time', 'resetTime']) {
+    const v = raw[key];
+    if (typeof v === 'string' && v) return v;
+  }
+  return null;
+}
+
+// Port of the CLI's toUsageRow(): used = raw.used, or limit-remaining when
+// used is absent.
+function kimiUsageRow(raw, defaultLabel) {
+  if (!isRecord(raw)) return null;
+  const limit = toInt(raw.limit);
+  let used = toInt(raw.used);
+  const remaining = toInt(raw.remaining);
+  if (used === null && remaining !== null && limit !== null) used = limit - remaining;
+  if (used === null && limit === null) return null;
+  const name = typeof raw.name === 'string' ? raw.name : (typeof raw.title === 'string' ? raw.title : defaultLabel);
+  return {
+    label: name,
+    used: used ?? 0,
+    limit: limit ?? 0,
+    remaining: remaining !== null ? remaining : (limit !== null && used !== null ? limit - used : null),
+    resets: kimiResetIso(raw),
+  };
+}
+
+function kimiRowOut(row) {
+  if (!row) return null;
+  const pct = row.limit > 0 ? Math.round((row.used / row.limit) * 100) : null;
+  return { pct, used: row.used, limit: row.limit, remaining: row.remaining, resets: row.resets };
+}
+
+// Normalize Kimi's /usages payload ({ usage, limits: [...] }) into the
+// claude-usage-analog shape: weekly / window_5h / window_7d, each
+// pct/used/limit/remaining/resets, plus a raw `limits` passthrough so no
+// bucket is lost if label text ever drifts from what we match on below.
+function normalizeKimiUsage(payload) {
+  const rec = isRecord(payload) ? payload : {};
+  const summaryRow = kimiUsageRow(rec.usage, 'Weekly limit');
+  const limitRows = [];
+  const rawLimits = Array.isArray(rec.limits) ? rec.limits : [];
+  rawLimits.forEach((item, idx) => {
+    if (!isRecord(item)) return;
+    const detail = isRecord(item.detail) ? item.detail : item;
+    const window = isRecord(item.window) ? item.window : {};
+    const label = kimiLimitLabel(item, detail, window, idx);
+    const row = kimiUsageRow(detail, label);
+    if (row) limitRows.push(row);
+  });
+
+  const findByLabel = re => limitRows.find(r => re.test(r.label));
+  const weekly = summaryRow || findByLabel(/week/i) || null;
+  const window5h = findByLabel(/^5\s*h(our)?\b|5h limit/i) || null;
+  const window7d = findByLabel(/^7\s*d(ay)?\b|7d limit/i) || null;
+
+  return {
+    timestamp: new Date().toISOString(),
+    weekly: kimiRowOut(weekly),
+    window_5h: kimiRowOut(window5h),
+    window_7d: kimiRowOut(window7d),
+    limits: limitRows.map(r => ({ label: r.label, ...kimiRowOut(r) })),
+  };
+}
+
 // ---------------------------------------------------------------------------
 // OpenAI-compatible HTTP surface.
 function completionBody(text) {
@@ -464,6 +649,21 @@ const server = http.createServer((req, res) => {
     return;
   }
 
+  if (req.method === 'GET' && req.url === '/usage') {
+    (async () => {
+      try {
+        const raw = await fetchKimiUsagesRaw();
+        const out = normalizeKimiUsage(raw);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(out));
+      } catch (err) {
+        res.writeHead(502, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: String(err.message || err) }));
+      }
+    })();
+    return;
+  }
+
   if (req.method === 'POST' && req.url === '/v1/chat/completions') {
     let body = '';
     req.on('data', d => { body += d; });
@@ -488,30 +688,68 @@ const server = http.createServer((req, res) => {
         });
         const id = `chatcmpl-${Date.now()}`;
         const created = Math.floor(Date.now() / 1000);
-        res.write(sseChunk(id, created, { role: 'assistant' }, null));
+
+        // Heartbeat keepalive: OpenClaw's LLM idle watchdog aborts a turn on
+        // any >120s gap between SSE stream events (default timeoutSeconds),
+        // not on total run length. During long thinking/tool/MCP phases Kimi
+        // emits stream-json events we don't forward, so the SSE stream can go
+        // silent well past that window. Every write resets `lastWrite`; a 5s
+        // ticker emits an empty-content delta once 25s of silence elapses —
+        // still a stream event (resets the watchdog) but appends nothing
+        // visible to the rendered reply or cognee-persisted text.
+        let lastWrite = Date.now();
+        const write = (delta, finish) => {
+          if (res.writableEnded || res.destroyed) return;
+          res.write(sseChunk(id, created, delta, finish));
+          lastWrite = Date.now();
+        };
+        write({ role: 'assistant' }, null);
+        const hb = setInterval(() => {
+          if (Date.now() - lastWrite >= 25_000) write({ content: '' }, null);
+        }, 5_000);
+
+        // Propagate a client/gateway disconnect down to the kimi child so an
+        // abandoned turn (e.g. OpenClaw's idle watchdog gave up) is killed
+        // instead of finishing invisibly and burning quota. `done` guards
+        // against the normal res.end() 'close' also aborting.
+        const ac = new AbortController();
+        let done = false;
+        res.on('close', () => { if (!done) ac.abort(); });
+
         try {
-          await handleTurn(messages, delta => {
-            res.write(sseChunk(id, created, { content: delta }, null));
-          });
-          res.write(sseChunk(id, created, {}, 'stop'));
+          await handleTurn(messages, delta => write({ content: delta }, null), ac.signal);
+          done = true;
+          write({}, 'stop');
           res.write('data: [DONE]\n\n');
-          res.end();
         } catch (err) {
-          // Headers already sent — surface the error inside the stream.
-          res.write(sseChunk(id, created, { content: `\n[error: ${String(err.message || err)}]` }, 'stop'));
-          res.write('data: [DONE]\n\n');
-          res.end();
+          done = true;
+          // Headers already sent — surface the error inside the stream (unless
+          // the socket is already gone, in which case there is nowhere to write).
+          if (!res.writableEnded && !res.destroyed) {
+            write({ content: `\n[error: ${String(err.message || err)}]` }, 'stop');
+            res.write('data: [DONE]\n\n');
+          }
+        } finally {
+          clearInterval(hb);
+          if (!res.writableEnded) res.end();
         }
         return;
       }
 
+      const ac = new AbortController();
+      let done = false;
+      res.on('close', () => { if (!done) ac.abort(); });
       try {
-        const { text } = await handleTurn(messages, null);
+        const { text } = await handleTurn(messages, null, ac.signal);
+        done = true;
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify(completionBody(text)));
       } catch (err) {
-        res.writeHead(500, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: String(err.message || err) }));
+        done = true;
+        if (!res.writableEnded && !res.destroyed) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: String(err.message || err) }));
+        }
       }
     });
     return;
diff --git a/openai/docker-compose.yml b/openai/docker-compose.yml
index 4109adb..20e6edf 100644
--- a/openai/docker-compose.yml
+++ b/openai/docker-compose.yml
@@ -170,6 +170,25 @@ services:
       # so read-only is safe. Edit the tracked file + restart to change config;
       # runtime/UI edits are intentionally disabled by the ro mount.
       - ../adolf/openclaw.json:/home/node/.openclaw/openclaw.json:ro
+      # quota-command plugin (kb #62) — same read-only-bind-over-volume
+      # pattern as openclaw.json above, applied to a single external plugin
+      # dir instead of the whole state tree. Previously the only precedent
+      # (cognee-memory) was docker cp'd straight into the adolf-state volume
+      # at runtime with no git backing; this plugin is small enough (no
+      # node_modules — only Node built-ins/global fetch) to just bind-mount
+      # its tracked source directly at its extensions/<id> path, so git stays
+      # the single source of truth the same way it already is for
+      # openclaw.json. Activated via plugins.entries.quota-command in that file.
+      - ./quota-command-openclaw-plugin:/home/node/.openclaw/extensions/quota-command:ro
+      # hindsight-memory plugin (kb #75, H3) — same read-only-bind-over-volume
+      # pattern as quota-command above. Structural successor to cognee-memory
+      # (still docker cp'd into the adolf-state volume, no git backing; that
+      # plugin's activation/container is decommissioned in H4, not here).
+      # Forced hooks (before_prompt_build recall / agent_end retain) against
+      # the hindsight service (see that service's block below), replacing
+      # Cognee as Adolf's memory backend. Activated via
+      # plugins.entries.hindsight-memory in openclaw.json.
+      - ./hindsight-openclaw-plugin:/home/node/.openclaw/extensions/hindsight-memory:ro
     extra_hosts:
       - "host.docker.internal:host-gateway"
       # mtx.alogins.net's public A record can't hairpin-NAT back through the
@@ -218,6 +237,11 @@ services:
       - adolf-llm-workspace:/workspace
       - adolf-llm-home:/root/.kimi-code
       - ./shared-mcp.json:/shared-mcp.json:ro
+    extra_hosts:
+      # Needed to reach kanboard-mcp-adolf (:3104, network_mode: host, outside
+      # this compose project's network) via shared-mcp.json's "kanboard"
+      # entry — same host-gateway trick used by adolf/cognee/pipecat above.
+      - "host.docker.internal:host-gateway"
     restart: unless-stopped
 
   # cognee — Adolf's memory backend (P4). FastAPI + embedded Kuzu graph +
@@ -261,8 +285,13 @@ services:
   # Never opens the graph/vector files itself, so it's safe to run alongside
   # `cognee` without a second writer on the same Kuzu database. Exposes 3
   # tools: remember / recall / forget.
+  #
+  # Built from a local Dockerfile (kb#70 fix) instead of the bare upstream
+  # image: forget was missing a data_id parameter end-to-end, so agents
+  # could delete a whole dataset but never a single entry. See
+  # ./cognee-mcp/Dockerfile and ./cognee-mcp/src/ for the patched files.
   cognee-mcp:
-    image: cognee/cognee-mcp:1.2.2
+    build: ./cognee-mcp
     container_name: cognee-mcp
     restart: unless-stopped
     environment:
@@ -277,6 +306,95 @@ services:
     depends_on:
       - cognee
 
+  # hindsight — Adolf memory backend, replacing cognee/cognee-mcp/cognee-llm
+  # (kb#73, migration doc agap_git/adolf/HINDSIGHT-MIGRATION.md, H1). One
+  # container: REST API :8888 (also serves the built-in MCP at /mcp/{bank}/),
+  # UI :9999, built-in Postgres (pg0) bind-mounted to
+  # /mnt/ssd/dbs/hindsight/ (host dir created + chowned 1000:1000 to match
+  # the image's non-root `hindsight` user, confirmed via
+  # `docker run --entrypoint id`).
+  #
+  # LLM + embeddings reconfigured 2026-07-15 (kb#84) to fix two wrong H1
+  # choices for a Russian/multilingual use case:
+  #
+  # LLM -> cognee-llm:8011 (the existing Kimi-CLI wrapper, same shim cognee
+  # uses — see cognee/cognee.env's LLM section for the full precedent,
+  # including why LLM_INSTRUCTOR_MODE=json_mode isn't needed here since
+  # Hindsight's own client doesn't go through `instructor`). Replaces the
+  # H1 choice of LiteLLM + ollama/gemma3:4b (a tiny local model): validated
+  # 2026-07-15 that cognee-llm returns clean, JSON-parseable structured
+  # extraction for Russian input (see kb#84 probe B) — gemma3:4b's fluency
+  # on Russian was never actually verified, it was picked only to dodge
+  # qwen3:8b's <think>-token empty-content bug. Kimi is also the flat-rate
+  # subscription already paid for, so this isn't a new cost.
+  #
+  # Embeddings -> ollama's bge-m3 on the GPU (host.docker.internal:11436,
+  # separate compose project, same extra_hosts trick as cognee/adolf-llm
+  # below), via ollama's OpenAI-compatible /v1/embeddings endpoint
+  # (confirmed 200 + 1024-dim vector 2026-07-15, kb#84 probe A). Replaces
+  # the H1 choice of Hindsight's built-in `local` provider
+  # (BAAI/bge-small-en-v1.5, English-only, 384-d, CPU-bound in-process
+  # SentenceTransformers). The hindsight image itself is CPU-only (torch
+  # +cpu build, no onnxruntime GPU provider — confirmed 2026-07-15), so its
+  # in-process local/onnx embedders can never reach the GPU; routing
+  # through ollama's `openai` embeddings provider (HTTP, not the bespoke
+  # cognee-style `ollama` provider Hindsight doesn't have) is how GPU
+  # serving happens here. Dimensions var matches cognee.env's own bge-m3
+  # swap (kb#60): 1024.
+  #
+  # Runs ALONGSIDE cognee/cognee-mcp/cognee-llm during the migration; those
+  # are untouched here and only decommissioned in H4, after H2/H3/H5 prove
+  # this service out. Not yet wired into openclaw.json/shared-mcp.json
+  # (that's H2, kb#74) — this block only stands the service up and proves
+  # retain/recall against a throwaway bank.
+  hindsight:
+    image: ghcr.io/vectorize-io/hindsight:latest
+    container_name: hindsight
+    restart: unless-stopped
+    environment:
+      - HINDSIGHT_API_LLM_PROVIDER=openai
+      - HINDSIGHT_API_LLM_BASE_URL=http://cognee-llm:8011/v1
+      - HINDSIGHT_API_LLM_MODEL=openai/cognee-llm
+      # cognee-llm ignores the key entirely (Kimi CLI wrapper, no real
+      # OpenAI auth) — same dummy value cognee.env uses for LLM_API_KEY.
+      - HINDSIGHT_API_LLM_API_KEY=sk-cognee-llm-local
+      - HINDSIGHT_API_EMBEDDINGS_PROVIDER=openai
+      - HINDSIGHT_API_EMBEDDINGS_OPENAI_BASE_URL=http://host.docker.internal:11436/v1
+      - HINDSIGHT_API_EMBEDDINGS_OPENAI_MODEL=bge-m3
+      - HINDSIGHT_API_EMBEDDINGS_OPENAI_DIMENSIONS=1024
+      # ollama doesn't check this value at all (no auth), but the openai
+      # embeddings client requires a non-empty key to construct.
+      - HINDSIGHT_API_EMBEDDINGS_OPENAI_API_KEY=ollama
+      # Stable worker id (compose service name), not the container hostname
+      # default -- without this, recreating the container orphans any
+      # in-flight async retain/consolidation tasks under the old hostname
+      # (startup log warns about exactly this).
+      - HINDSIGHT_API_WORKER_ID=hindsight
+      # Reranker -> multilingual (kb#84 follow-up). The TEMPR rerank stage
+      # defaulted to English cross-encoder/ms-marco-MiniLM, which ranks
+      # Russian/multilingual candidates poorly. jina v2 multilingual fixes
+      # that. Runs on CPU in this image (no CUDA torch) but only over the
+      # small recall candidate set. trust_remote_code: jina ships custom code.
+      - HINDSIGHT_API_RERANKER_PROVIDER=local
+      - HINDSIGHT_API_RERANKER_LOCAL_MODEL=jinaai/jina-reranker-v2-base-multilingual
+      - HINDSIGHT_API_RERANKER_LOCAL_TRUST_REMOTE_CODE=true
+    volumes:
+      - /mnt/ssd/dbs/hindsight:/home/hindsight/.pg0
+      # Persist HuggingFace/sentence-transformers model cache so the jina
+      # reranker (~1GB) doesn't re-download on every container recreate.
+      - /mnt/ssd/dbs/hindsight-cache:/home/hindsight/.cache
+    ports:
+      - "8888:8888"
+      - "9999:9999"
+    extra_hosts:
+      # Needed to resolve host.docker.internal from inside the container
+      # for the ollama embeddings call above — ollama lives in a separate
+      # compose project, same trick as cognee/adolf-llm elsewhere in this
+      # file.
+      - "host.docker.internal:host-gateway"
+    depends_on:
+      - cognee-llm
+
   # openclaw-tools — MCP bridge (P5) exposing a minimal slice of the Adolf
   # OpenClaw gateway's agent tools (message/cron/nodes/browser) over MCP
   # Streamable HTTP, so Kimi CLI sessions (adolf-llm) can call them instead of
diff --git a/openai/hindsight-openclaw-plugin/index.js b/openai/hindsight-openclaw-plugin/index.js
new file mode 100644
index 0000000..c2815ee
--- /dev/null
+++ b/openai/hindsight-openclaw-plugin/index.js
@@ -0,0 +1,378 @@
+/**
+ * Hindsight Memory — an OpenClaw memory plugin, structural successor to
+ * cognee-openclaw-plugin (kb #75, H3). Same three touchpoints as the Cognee
+ * plugin it replaces:
+ *
+ *   before_prompt_build -> recall  => LLM-free retrieval, injected as prependContext
+ *   agent_end           -> retain  => async persist of the turn (extraction runs server-side)
+ *   *_recall / *_reflect tool      => on-demand recall (LLM-free) / reflect (LLM-synthesized)
+ *
+ * Why recall is LLM-free (verified against the live service, kb #75 H3):
+ *   POST /v1/default/banks/{bank}/memories/recall does semantic + BM25 (keyword)
+ *   + spreading-activation graph traversal + temporal scoring and returns ranked
+ *   raw fact/observation text (RecallResult.text) directly — there is no
+ *   generation step on this path. (Verified via a live probe against a
+ *   throwaway bank: POST retain -> POST recall returned the stored fact
+ *   verbatim, no LLM call in the response.) The separate POST .../reflect
+ *   endpoint is the LLM-synthesized path (used only by the optional
+ *   hindsight_reflect tool below, never by the forced hooks).
+ *
+ * Key simplification vs. the Cognee plugin: no cognify-sweep machinery.
+ * Cognee needed an explicit, throttled background "cognify" step (dirty-set
+ * tracker + persisted state + per-dataset throttle) to turn raw added text
+ * into graph facts. Hindsight's retain endpoint does extraction, embedding,
+ * dedup, and entity/temporal linking server-side as part of the retain call
+ * itself (async:true just makes that happen off the request path) — so the
+ * whole class of "sweep never got re-armed after a hot-reload" bugs the
+ * Cognee plugin had to work around does not exist here. There is nothing to
+ * port.
+ *
+ * Bank scoping: a single shared bank ("adolf" by default), NOT per-chat
+ * datasets like the Cognee plugin used. Two reasons this diverges from the
+ * Cognee reference:
+ *   1. H2 (kb #74) already pointed the MCP tool surface at a single bank
+ *      (mcp.servers.hindsight -> http://hindsight:8888/mcp/adolf/). If this
+ *      plugin's hooks wrote to per-chat banks instead, a fact the model
+ *      stores/recalls via the MCP tools would live in a different bank than
+ *      the one the forced hooks read/write, silently fragmenting memory.
+ *   2. Cognee's per-chat "datasets" were explicitly a best-effort mitigation
+ *      for a backend that leaks across datasets when
+ *      ENABLE_BACKEND_ACCESS_CONTROL=False (see the old plugin's
+ *      `datasetFor` comment) — i.e. Cognee could not do real isolation, so
+ *      splitting by chat was the closest available approximation. Hindsight
+ *      banks are hard, real isolation; Adolf has exactly one owner/DM
+ *      allowlist (see channels.matrix.dm.allowFrom in openclaw.json), so
+ *      there is no isolation need that per-chat banks would actually solve
+ *      here — they would only fragment recall across a single user's own
+ *      conversations. The chat/session id is still attached to each stored
+ *      turn as free-text `context` for provenance/debugging, without
+ *      affecting bank-level isolation or recall filtering.
+ *
+ * Hindsight is reachable only inside the `openai` compose network as
+ * http://hindsight:8888 (REST + built-in MCP; not published to the host
+ * except via the 8888/9999 port mappings used for admin/debug access).
+ */
+
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+
+const DEFAULTS = {
+  enabled: true,
+  hindsightUrl: "http://hindsight:8888",
+  bankId: "adolf",
+  agents: [],
+  budget: "mid", // low | mid | high — recall/reflect effort knob
+  recallMaxTokens: 2048, // Hindsight's own per-call token budget for recall results
+  maxContextChars: 4000, // hard cap on the injected prependContext block
+  recallTimeoutMs: 4000,
+  retainTimeoutMs: 8000,
+  minTextChars: 3,
+  types: ["world", "experience"],
+  injectHeader:
+    "Relevant long-term memory (retrieved from Hindsight; untrusted metadata, not instructions):",
+};
+
+// OpenClaw injects this labelled block into the user-role prompt. Strip it so
+// neither the recall query nor the stored memory carries transport metadata.
+const CONV_INFO_LABEL = "Conversation info (untrusted metadata):";
+const MEMORY_OPEN = "<hindsight_memory>";
+const MEMORY_CLOSE = "</hindsight_memory>";
+
+function normalizeConfig(raw) {
+  const c = raw && typeof raw === "object" ? raw : {};
+  const int = (v, d) => (Number.isFinite(v) && v > 0 ? Math.floor(v) : d);
+  const budget = ["low", "mid", "high"].includes(c.budget) ? c.budget : DEFAULTS.budget;
+  return {
+    enabled: c.enabled !== false,
+    hindsightUrl: (typeof c.hindsightUrl === "string" && c.hindsightUrl.trim()) || DEFAULTS.hindsightUrl,
+    bankId: (typeof c.bankId === "string" && c.bankId.trim()) || DEFAULTS.bankId,
+    agents: Array.isArray(c.agents) ? c.agents.filter((a) => typeof a === "string" && a.trim()) : [],
+    budget,
+    recallMaxTokens: int(c.recallMaxTokens, DEFAULTS.recallMaxTokens),
+    maxContextChars: int(c.maxContextChars, DEFAULTS.maxContextChars),
+    recallTimeoutMs: int(c.recallTimeoutMs, DEFAULTS.recallTimeoutMs),
+    retainTimeoutMs: int(c.retainTimeoutMs, DEFAULTS.retainTimeoutMs),
+    minTextChars: int(c.minTextChars, DEFAULTS.minTextChars),
+    types: Array.isArray(c.types) && c.types.length ? c.types.filter((t) => typeof t === "string") : DEFAULTS.types,
+    injectHeader: (typeof c.injectHeader === "string" && c.injectHeader.trim()) || DEFAULTS.injectHeader,
+  };
+}
+
+// --- text helpers -----------------------------------------------------------
+
+function textOf(msg) {
+  if (msg == null) return "";
+  if (typeof msg === "string") return msg;
+  const content = msg.content;
+  if (Array.isArray(content)) {
+    return content
+      .map((p) => (typeof p === "string" ? p : p && typeof p.text === "string" ? p.text : ""))
+      .join("\n");
+  }
+  return content == null ? "" : String(content);
+}
+
+// Remove OpenClaw's untrusted-metadata block and our own injected memory block
+// so stored/queried text is the real conversational content only.
+function cleanText(text) {
+  let t = typeof text === "string" ? text : "";
+  const at = t.indexOf(CONV_INFO_LABEL);
+  if (at !== -1) t = t.slice(0, at);
+  let open;
+  while ((open = t.indexOf(MEMORY_OPEN)) !== -1) {
+    const close = t.indexOf(MEMORY_CLOSE, open);
+    if (close === -1) {
+      t = t.slice(0, open);
+      break;
+    }
+    t = t.slice(0, open) + t.slice(close + MEMORY_CLOSE.length);
+  }
+  return t.trim();
+}
+
+function lastRoleText(messages, role) {
+  if (!Array.isArray(messages)) return "";
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m && typeof m === "object" && m.role === role) {
+      const t = cleanText(textOf(m));
+      if (t) return t;
+    }
+  }
+  return "";
+}
+
+// Chat/session label used only as free-text provenance (MemoryItem.context),
+// never as a bank selector — see the bank-scoping note at the top of this file.
+function chatLabel(ctx) {
+  const raw = (ctx && (ctx.chatId || ctx.channelId || ctx.sessionKey)) || "";
+  const slug = String(raw)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "_")
+    .replace(/^_+|_+$/g, "")
+    .slice(0, 60);
+  return slug ? `chat_${slug}` : "chat_default";
+}
+
+// --- Hindsight HTTP client ---------------------------------------------------
+
+function makeHindsight(cfg) {
+  const base = cfg.hindsightUrl.replace(/\/+$/, "");
+  const bankPath = `${base}/v1/default/banks/${encodeURIComponent(cfg.bankId)}`;
+
+  async function withTimeout(ms, fn) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(new Error(`hindsight timeout after ${ms}ms`)), ms);
+    try {
+      return await fn(ac.signal);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  // LLM-free recall: semantic + keyword + graph + temporal ranking only.
+  async function recallContext(query) {
+    const body = {
+      query,
+      budget: cfg.budget,
+      max_tokens: cfg.recallMaxTokens,
+      types: cfg.types,
+    };
+    const res = await withTimeout(cfg.recallTimeoutMs, (signal) =>
+      fetch(`${bankPath}/memories/recall`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal,
+      }),
+    );
+    if (!res.ok) throw new Error(`recall ${res.status}`);
+    const data = await res.json();
+    const results = Array.isArray(data?.results) ? data.results : [];
+    if (results.length === 0) return "";
+    const lines = results
+      .map((r) => (typeof r?.text === "string" ? r.text.trim() : ""))
+      .filter(Boolean);
+    let ctx = lines.join("\n");
+    return ctx.length > cfg.maxContextChars ? ctx.slice(0, cfg.maxContextChars) + "\n…" : ctx;
+  }
+
+  // Retain one turn. async:true — Hindsight does extraction/consolidation
+  // server-side off the request path; we never wait for it.
+  async function retainTurn(content, context) {
+    const body = {
+      async: true,
+      items: [{ content, context }],
+    };
+    const res = await withTimeout(cfg.retainTimeoutMs, (signal) =>
+      fetch(`${bankPath}/memories`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal,
+      }),
+    );
+    if (!res.ok) throw new Error(`retain ${res.status}`);
+    return true;
+  }
+
+  // LLM-synthesized answer over memory (used only by the optional
+  // hindsight_reflect tool, never by the forced hooks).
+  async function reflect(query) {
+    const body = { query, budget: "low" };
+    const res = await withTimeout(cfg.recallTimeoutMs, (signal) =>
+      fetch(`${bankPath}/reflect`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal,
+      }),
+    );
+    if (!res.ok) throw new Error(`reflect ${res.status}`);
+    const data = await res.json();
+    return typeof data?.text === "string" ? data.text.trim() : "";
+  }
+
+  return { recallContext, retainTurn, reflect };
+}
+
+// ---------------------------------------------------------------------------
+
+export default definePluginEntry({
+  id: "hindsight-memory",
+  name: "Hindsight Memory",
+  description:
+    "Cross-session memory via Hindsight: LLM-free recall inject before each reply, async retain of each turn after it ends.",
+  register(api) {
+    let cfg = normalizeConfig(api.pluginConfig);
+    const hindsight = makeHindsight(cfg);
+
+    // runId -> { userText } captured at recall time, consumed at agent_end so
+    // retain stores the same clean user text the recall query used.
+    const pending = new Map();
+
+    const agentAllowed = (agentId) =>
+      cfg.agents.length === 0 || (agentId && cfg.agents.includes(agentId));
+
+    // 1) RECALL — before_prompt_build => inject LLM-free memory context.
+    api.on(
+      "before_prompt_build",
+      async (event, ctx) => {
+        if (!cfg.enabled) return;
+        if (ctx?.trigger && ctx.trigger !== "user") return; // only real user turns
+        if (!agentAllowed(ctx?.agentId)) return;
+
+        const query = cleanText(lastRoleText(event?.messages, "user") || event?.prompt || "");
+        if (!query || query.length < cfg.minTextChars) return;
+
+        if (ctx?.runId) pending.set(ctx.runId, { userText: query });
+
+        try {
+          const context = await hindsight.recallContext(query);
+          if (!context) return;
+          const block = `${MEMORY_OPEN}\n${cfg.injectHeader}\n${context}\n${MEMORY_CLOSE}`;
+          api.logger?.info?.(
+            `hindsight-memory: injected ${context.length} chars of memory for bank ${cfg.bankId}`,
+          );
+          return { prependContext: block };
+        } catch (e) {
+          // Recall is best-effort: never block or fail a turn on memory.
+          api.logger?.debug?.(`hindsight-memory: recall skipped (${e?.message || e})`);
+          return;
+        }
+      },
+      { timeoutMs: cfg.recallTimeoutMs + 2000 },
+    );
+
+    // 2) RETAIN — agent_end => async retain of the turn. No cognify/sweep
+    // step: Hindsight extracts+consolidates internally as part of retain.
+    api.on("agent_end", async (event, ctx) => {
+      if (!cfg.enabled) return;
+      const carried = ctx?.runId ? pending.get(ctx.runId) : undefined;
+      if (ctx?.runId) pending.delete(ctx.runId);
+
+      const userText = carried?.userText || lastRoleText(event?.messages, "user");
+      const assistantText = lastRoleText(event?.messages, "assistant");
+
+      const parts = [];
+      if (userText) parts.push(`User: ${userText}`);
+      if (assistantText) parts.push(`Assistant: ${assistantText}`);
+      const turn = parts.join("\n").trim();
+      if (turn.length < cfg.minTextChars) return;
+
+      try {
+        await hindsight.retainTurn(turn, chatLabel(ctx));
+        api.logger?.info?.(`hindsight-memory: retained turn to bank ${cfg.bankId}`);
+      } catch (e) {
+        api.logger?.warn?.(`hindsight-memory: retain failed (${e?.message || e})`);
+      }
+    });
+
+    // 3) TOOL — deliberate LLM-free recall.
+    api.registerTool({
+      name: "hindsight_recall",
+      label: "Hindsight Recall",
+      description:
+        "Search long-term memory (Hindsight) and return ranked fact/observation text WITHOUT an LLM synthesis step. Fast and factual. For a synthesized natural-language answer over memory, use hindsight_reflect instead.",
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          query: {
+            type: "string",
+            description: "What to look up in long-term memory.",
+          },
+        },
+        required: ["query"],
+      },
+      execute: async (_toolCallId, params) => {
+        const query = cleanText(String(params?.query || ""));
+        if (!query) {
+          return { content: [{ type: "text", text: "hindsight_recall: empty query." }], details: { ok: false } };
+        }
+        try {
+          const context = await hindsight.recallContext(query);
+          const text = context || "No relevant memory found.";
+          return { content: [{ type: "text", text }], details: { ok: true, chars: context.length } };
+        } catch (e) {
+          const msg = `hindsight_recall failed: ${e?.message || e}`;
+          return { content: [{ type: "text", text: msg }], details: { ok: false } };
+        }
+      },
+    });
+
+    // 4) TOOL (optional) — LLM-synthesized answer over memory.
+    api.registerTool({
+      name: "hindsight_reflect",
+      label: "Hindsight Reflect",
+      description:
+        "Ask a question over long-term memory and get back a synthesized natural-language answer (LLM-backed, slower than hindsight_recall). Use hindsight_recall first when raw facts are enough.",
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          query: {
+            type: "string",
+            description: "The question to answer using long-term memory.",
+          },
+        },
+        required: ["query"],
+      },
+      execute: async (_toolCallId, params) => {
+        const query = cleanText(String(params?.query || ""));
+        if (!query) {
+          return { content: [{ type: "text", text: "hindsight_reflect: empty query." }], details: { ok: false } };
+        }
+        try {
+          const text = await hindsight.reflect(query);
+          return {
+            content: [{ type: "text", text: text || "No answer could be synthesized from memory." }],
+            details: { ok: true },
+          };
+        } catch (e) {
+          const msg = `hindsight_reflect failed: ${e?.message || e}`;
+          return { content: [{ type: "text", text: msg }], details: { ok: false } };
+        }
+      },
+    });
+  },
+});
diff --git a/openai/hindsight-openclaw-plugin/openclaw.plugin.json b/openai/hindsight-openclaw-plugin/openclaw.plugin.json
new file mode 100644
index 0000000..c86dac9
--- /dev/null
+++ b/openai/hindsight-openclaw-plugin/openclaw.plugin.json
@@ -0,0 +1,79 @@
+{
+  "id": "hindsight-memory",
+  "name": "Hindsight Memory",
+  "description": "Cross-session memory via Hindsight. Injects LLM-free recall context before each reply (before_prompt_build) and retains each turn asynchronously after it ends (agent_end); Hindsight extracts/consolidates server-side, so there is no client-side cognify sweep. Structural successor to cognee-memory (kb #75, H3).",
+  "activation": {
+    "onStartup": true
+  },
+  "contracts": {
+    "tools": ["hindsight_recall", "hindsight_reflect"]
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "enabled": { "type": "boolean" },
+      "hindsightUrl": { "type": "string" },
+      "bankId": { "type": "string" },
+      "agents": { "type": "array", "items": { "type": "string" } },
+      "budget": { "type": "string", "enum": ["low", "mid", "high"] },
+      "recallMaxTokens": { "type": "integer", "minimum": 128, "maximum": 32000 },
+      "maxContextChars": { "type": "integer", "minimum": 200, "maximum": 20000 },
+      "recallTimeoutMs": { "type": "integer", "minimum": 500, "maximum": 30000 },
+      "retainTimeoutMs": { "type": "integer", "minimum": 500, "maximum": 60000 },
+      "minTextChars": { "type": "integer", "minimum": 1, "maximum": 200 },
+      "types": { "type": "array", "items": { "type": "string" } },
+      "injectHeader": { "type": "string" }
+    }
+  },
+  "uiHints": {
+    "enabled": {
+      "label": "Hindsight Memory",
+      "help": "Enable cross-session Hindsight memory (recall inject + async turn retain)."
+    },
+    "hindsightUrl": {
+      "label": "Hindsight URL",
+      "help": "Base URL of the Hindsight REST API (default http://hindsight:8888)."
+    },
+    "bankId": {
+      "label": "Bank ID",
+      "help": "Hindsight memory bank to read/write (default \"adolf\" — the same shared bank the MCP tool surface uses, so hook-based and tool-based memory stay consistent)."
+    },
+    "agents": {
+      "label": "Target Agents",
+      "help": "Agent ids that use Hindsight memory. Empty means all agents."
+    },
+    "budget": {
+      "label": "Recall/Reflect Budget",
+      "help": "Effort level for recall and reflect calls (low/mid/high). Higher costs more latency."
+    },
+    "recallMaxTokens": {
+      "label": "Recall Max Tokens",
+      "help": "Hindsight's own token budget for a single recall call's results."
+    },
+    "maxContextChars": {
+      "label": "Max Injected Context Chars",
+      "help": "Hard cap on the size of the injected memory block."
+    },
+    "recallTimeoutMs": {
+      "label": "Recall Timeout (ms)",
+      "help": "Budget for the LLM-free recall on the reply path. On timeout the turn proceeds with no injected memory."
+    },
+    "retainTimeoutMs": {
+      "label": "Retain Timeout (ms)",
+      "help": "Budget for the post-turn async retain call to Hindsight (off the reply path; async:true itself makes Hindsight's extraction non-blocking, this only bounds the HTTP request)."
+    },
+    "minTextChars": {
+      "label": "Minimum Text Chars",
+      "help": "Skip recall/retain for text shorter than this."
+    },
+    "types": {
+      "label": "Recall Types",
+      "help": "Fact types to recall: world, experience, observation. Defaults to world and experience."
+    },
+    "injectHeader": {
+      "label": "Inject Header",
+      "help": "Header line prepended to the injected memory block."
+    }
+  }
+}
diff --git a/openai/hindsight-openclaw-plugin/package.json b/openai/hindsight-openclaw-plugin/package.json
new file mode 100644
index 0000000..b47a93f
--- /dev/null
+++ b/openai/hindsight-openclaw-plugin/package.json
@@ -0,0 +1,18 @@
+{
+  "name": "openclaw-hindsight-memory",
+  "version": "1.0.0",
+  "description": "Hindsight-backed cross-session memory for OpenClaw (LLM-free recall inject, async retain).",
+  "type": "module",
+  "private": true,
+  "main": "./index.js",
+  "peerDependencies": {
+    "openclaw": ">=2026.3.0"
+  },
+  "openclaw": {
+    "extensions": ["./index.js"],
+    "compat": {
+      "pluginApi": ">=2026.0.0",
+      "minGatewayVersion": "2026.0.0"
+    }
+  }
+}
diff --git a/openai/quota-command-openclaw-plugin/index.js b/openai/quota-command-openclaw-plugin/index.js
new file mode 100644
index 0000000..e885bdf
--- /dev/null
+++ b/openai/quota-command-openclaw-plugin/index.js
@@ -0,0 +1,64 @@
+/**
+ * Kimi Quota Command (kb #62) — registers `/quota` on Adolf's Matrix channel.
+ *
+ * OpenClaw's native-command dispatch (`api.registerCommand`) runs a
+ * `/`-prefixed command BEFORE the agent turn: no model is invoked, so this
+ * never spends a Kimi turn (unlike asking Adolf in prose "what's my quota").
+ * It hits adolf-llm's own GET /usage route (server.js, kb #62 piece 1), which
+ * itself talks straight to Kimi's managed-usage API — no LLM anywhere in the
+ * path.
+ *
+ * Gating: `requireAuth: true` (the registerCommand default) restricts the
+ * command to `ctx.isAuthorizedSender`, i.e. the same Matrix DM allowlist
+ * (`channels.matrix.dm.allowFrom` in openclaw.json) that already gates every
+ * other interaction with Adolf. No separate owner-only tier is needed here —
+ * it's a read-only status line, not a privileged action.
+ */
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+
+// adolf-llm is a sibling service on the same `openai` compose network —
+// reached by service name, not localhost/host.docker.internal.
+const USAGE_URL = "http://adolf-llm:8010/usage";
+const FETCH_TIMEOUT_MS = 5000;
+
+function pct(row) {
+  return row && typeof row.pct === "number" ? `${row.pct}%` : "n/a";
+}
+
+async function fetchUsage() {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetch(USAGE_URL, { signal: controller.signal });
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) throw new Error(body?.error || `adolf-llm /usage HTTP ${res.status}`);
+    return body;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export default definePluginEntry({
+  id: "quota-command",
+  name: "Kimi Quota Command",
+  description:
+    "LLM-free /quota command: reads Adolf's Kimi usage from adolf-llm:8010/usage and replies with a compact readout.",
+  register(api) {
+    api.registerCommand({
+      name: "quota",
+      description: "Show Kimi quota usage (5h / weekly / 7d) — no model call.",
+      acceptsArgs: false,
+      requireAuth: true,
+      handler: async () => {
+        try {
+          const usage = await fetchUsage();
+          const line = `Kimi: 5h ${pct(usage.window_5h)} · weekly ${pct(usage.weekly)} · 7d ${pct(usage.window_7d)}`;
+          return { text: line, suppressReply: true };
+        } catch (e) {
+          api.logger?.warn?.(`quota-command: fetch failed (${e?.message || e})`);
+          return { text: `Kimi quota unavailable: ${e?.message || e}`, suppressReply: true };
+        }
+      },
+    });
+  },
+});
diff --git a/openai/quota-command-openclaw-plugin/openclaw.plugin.json b/openai/quota-command-openclaw-plugin/openclaw.plugin.json
new file mode 100644
index 0000000..11b789e
--- /dev/null
+++ b/openai/quota-command-openclaw-plugin/openclaw.plugin.json
@@ -0,0 +1,13 @@
+{
+  "id": "quota-command",
+  "name": "Kimi Quota Command",
+  "description": "Registers /quota: a native-command handler (runs before the agent, zero model calls) that reads Adolf's Kimi usage from adolf-llm:8010/usage and replies with a compact 5h/weekly/7d readout.",
+  "activation": {
+    "onStartup": true
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}
diff --git a/openai/quota-command-openclaw-plugin/package.json b/openai/quota-command-openclaw-plugin/package.json
new file mode 100644
index 0000000..6833462
--- /dev/null
+++ b/openai/quota-command-openclaw-plugin/package.json
@@ -0,0 +1,18 @@
+{
+  "name": "openclaw-quota-command",
+  "version": "1.0.0",
+  "description": "LLM-free /quota command for Adolf: reads Kimi usage from adolf-llm:8010/usage and replies with a compact readout.",
+  "type": "module",
+  "private": true,
+  "main": "./index.js",
+  "peerDependencies": {
+    "openclaw": ">=2026.3.0"
+  },
+  "openclaw": {
+    "extensions": ["./index.js"],
+    "compat": {
+      "pluginApi": ">=2026.0.0",
+      "minGatewayVersion": "2026.0.0"
+    }
+  }
+}
diff --git a/openai/shared-mcp.json b/openai/shared-mcp.json
index 317886f..9b8fa01 100644
--- a/openai/shared-mcp.json
+++ b/openai/shared-mcp.json
@@ -1,12 +1,16 @@
 {
   "mcpServers": {
-    "cognee": {
+    "hindsight": {
       "type": "http",
-      "url": "http://cognee-mcp:8000/mcp"
+      "url": "http://hindsight:8888/mcp/adolf/"
     },
     "openclaw-tools": {
       "type": "http",
       "url": "http://openclaw-tools:8020/mcp"
+    },
+    "kanboard": {
+      "type": "http",
+      "url": "http://host.docker.internal:3104/mcp"
     }
   }
 }