@nowledge/openclaw-nowledge-mem 0.2.7 → 0.6.2

package/CHANGELOG.md

@@ -2,6 +2,50 @@
 
 All notable changes to the Nowledge Mem OpenClaw plugin will be documented in this file.
 
+## [0.3.0] - 2026-02-23
+
+### Changed — Architecture overhaul: tool-first, LLM-based capture
+
+**Breaking: `autoRecall` now defaults to `false`**
+
+The agent has full access to all 7 tools regardless of this setting. Tool-only mode (both `autoRecall` and `autoCapture` off) is now the recommended default. The agent calls `memory_search`, `nowledge_mem_save`, etc. on demand — no tokens wasted on irrelevant context injection.
+
+Users who explicitly set `autoRecall: true` are unaffected.
+
+**Removed: English-only heuristic capture**
+
+The entire rule-based capture pipeline has been removed:
+- `shouldCaptureAsMemory()` — English-only regex patterns (`/\bi (like|prefer|hate)\b/i`)
+- `MEMORY_TRIGGER_PATTERNS`, `PROMPT_INJECTION_PATTERNS`
+- `looksLikeQuestion()`, `hasMemoryTrigger()`, `looksLikePromptInjection()`
+- `fingerprint()`, per-session dedup map
+
+These were fundamentally broken for non-English users (~95% of the world) and violated the "never settle for heuristic shortcuts" principle.
+
+**Added: Two-step LLM capture pipeline**
+
+Replaced heuristics with a proper LLM-based pipeline:
+
+1. **Thread capture** (unconditional, unchanged) — full conversation appended to persistent thread
+2. **Triage** (cheap, fast) — lightweight LLM call (~50 output tokens) determines if conversation contains save-worthy content. Language-agnostic. New backend endpoint: `POST /memories/distill/triage`
+3. **Distillation** (only when worthwhile) — full LLM extraction via existing `POST /memories/distill`, creating structured memories with proper unit_type, labels, and temporal data
+
+Cost: negligible for conversations without save-worthy content (triage only). Moderate for rich conversations (triage + distill). Works in any language.
+
+**Enhanced: `memory_search` tool description**
+
+More directive description for tool-only mode: tells the agent when to proactively search (past work references, previous decisions, prior context that would help).
+
+**Migrated: `before_prompt_build` hook**
+
+Auto-recall hook migrated from legacy `before_agent_start` to modern `before_prompt_build` API. Trimmed verbose tool guidance — the agent already sees tool descriptions in its tool list.
+
+### Added
+
+- `client.triageConversation(content)` — calls `POST /memories/distill/triage`
+- `client.distillThread({ threadId, title, content })` — calls `POST /memories/distill`
+- Backend `POST /memories/distill/triage` endpoint with lightweight LLM triage prompt
+
 ## [0.2.7] - 2026-02-18
 
 ### Added — Gap closures: date range, EVOLVES CLI, WM section edit

package/CLAUDE.md

@@ -0,0 +1,138 @@
+# CLAUDE.md — Nowledge Mem OpenClaw Plugin
+
+Continuation guide for `community/nowledge-mem-openclaw-plugin`.
+
+## Scope
+
+- Plugin target: OpenClaw plugin runtime (memory slot provider)
+- Runtime: JS ESM modules under `src/`, no TS build pipeline
+- Memory backend: `nmem` CLI (fallback: `uvx --from nmem-cli nmem`)
+- Architecture: **CLI-first** — all operations go through the nmem CLI, not direct API calls
+- Remote mode: set `NMEM_API_URL` + `NMEM_API_KEY` env vars or plugin config `apiUrl` + `apiKey`
+
+## Design Philosophy
+
+Reflects Nowledge Mem's genuine v0.6 strengths:
+
+1. **Knowledge graph** — EVOLVES chains, entity relationships, typed memory connections
+2. **Source provenance** — Library ingests docs/URLs; `SOURCED_FROM` edges trace knowledge origin
+3. **Structured types** — 8 unit types: `fact | preference | decision | plan | procedure | learning | context | event`
+4. **Working Memory** — daily evolving briefing; agents can patch sections without overwriting the whole document
+5. **Cross-AI continuity** — "Your AI tools forget. We remember. Everywhere."
+6. **Hybrid search** — BM25 + semantic + graph + decay, not vector-only
+7. **Transparent scoring** — `relevance_reason` in every search result
+
+## Files That Matter
+
+```
+src/
+  index.js          — plugin registration (tools, hooks, commands, CLI)
+  client.js         — CLI wrapper with API fallback; credential handling
+  config.js         — strict config parsing (apiUrl, apiKey, autoRecall, etc.)
+  hooks/
+    recall.js       — before_agent_start: inject Working Memory + recalled memories
+    capture.js      — quality-gated memory note + thread append
+  tools/
+    memory-search.js    — OpenClaw compat; multi-signal; bi-temporal; relevance_reason
+    memory-get.js       — OpenClaw compat; supports MEMORY.md alias
+    save.js             — structured capture: unit_type, labels, temporal, importance
+    context.js          — Working Memory daily briefing (read-only)
+    connections.js      — graph exploration: edge types, relationship strength, provenance
+    timeline.js         — activity feed: daily grouping, event_type filter, memoryId hints
+    forget.js           — memory deletion by ID or search
+openclaw.plugin.json — manifest + config schema (version, uiHints, configSchema)
+```
+
+## Tool Surface (7 tools)
+
+### OpenClaw Memory Slot (required for system prompt activation)
+- `memory_search` — multi-signal: BM25 + embedding + label + graph + decay. Returns `matchedVia` ("Text Match 100% + Semantic 69%"), `importance`, bi-temporal filters (`event_date_from/to`, `recorded_date_from/to`). Mode: `"multi-signal"`.
+- `memory_get` — retrieve by `nowledgemem://memory/<id>` path or bare ID. `MEMORY.md` → Working Memory.
+
+### Nowledge Mem Native (differentiators)
+- `nowledge_mem_save` — structured capture: `unit_type`, `labels[]`, `event_start`, `event_end`, `temporal_context`, `importance`. All fields wired to CLI and API.
+- `nowledge_mem_context` — Working Memory daily briefing. Read-only by default; supports section-level patch via `patch_section` + `patch_content`/`patch_append` params (uses `nmem wm patch` client-side read-modify-write).
+- `nowledge_mem_connections` — graph exploration. Edges JOIN-ed to nodes by type: CRYSTALLIZED_FROM (crystal → source memories), EVOLVES (with sub-relations: supersedes/enriches/confirms/challenges), SOURCED_FROM (document provenance), MENTIONS (entities). Each connection shows strength % and memoryId.
+- `nowledge_mem_timeline` — activity feed via `nmem f`. Groups by day. `event_type` filter. Exact date range via `date_from`/`date_to` (YYYY-MM-DD). Entries include `(id: <memoryId>)` for chaining to connections.
+- `nowledge_mem_forget` — delete by ID or fuzzy query.
+
+## Hook Surface
+
+- `before_agent_start` — auto-recall: Working Memory + `searchRich()` with `relevanceReason` in context
+- `agent_end` — quality-gated memory note + thread append (requires `autoCapture: true`)
+- `after_compaction` — thread append
+- `before_reset` — thread append
+
+## Slash Commands
+
+- `/remember` — quick save
+- `/recall` — quick search
+- `/forget` — quick delete
+
+## Config Keys
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `autoRecall` | boolean | `false` | Inject context at session start |
+| `autoCapture` | boolean | `false` | Capture notes/threads at session end |
+| `maxRecallResults` | integer 1–20 | `5` | How many memories to recall |
+| `apiUrl` | string | `""` | Remote server URL. Empty = local (127.0.0.1:14242) |
+| `apiKey` | string | `""` | API key. Injected as `NMEM_API_KEY` env var only. Never logged. |
+
+### Credential Handling Rules
+- `apiKey` → ONLY via child process env (`NMEM_API_KEY`). Never CLI arg, never logged.
+- `apiUrl` → passed as `--api-url` flag to CLI (not a secret).
+- Config values win over environment variables.
+- `_spawnEnv()` builds per-spawn env; `_apiUrlArgs()` adds `--api-url` when non-default.
+
+## CLI Surface (nmem commands used by plugin)
+
+| Command | Plugin method | Notes |
+|---------|--------------|-------|
+| `nmem --json m search <q>` | `client.search()` | Rich: relevance_reason, importance, labels, temporal |
+| `nmem --json m search <q> --event-from/--event-to/--recorded-from/--recorded-to` | `client.searchTemporal()` | Bi-temporal |
+| `nmem --json m add <content> [--unit-type] [-l] [--event-start] [--when]` | `client.execJson()` in save.js | Full rich save |
+| `nmem --json g expand <id>` | `client.graphExpand()` | Graph neighbors + edges |
+| `nmem --json g evolves <id>` | `client.graphEvolves()` | EVOLVES version chain |
+| `nmem --json f [--days] [--type] [--all] [--from DATE] [--to DATE]` | `client.feedEvents()` | Activity feed + date range |
+| `nmem --json wm read` | `client.readWorkingMemory()` | Working Memory read |
+| `nmem --json wm patch --heading "## S" --content/--append` | `client.patchWorkingMemory()` | Section-level WM update |
+| `nmem --json m delete <id>` | `client.execJson()` in forget.js | Delete |
+
+All commands have API fallback for older CLI versions.
+
+## Smoke Test
+
+```bash
+# Lint
+npx biome check src/
+
+# CLI
+nmem --version
+nmem --json m search "test" -n 3
+nmem --json m add "test memory" --unit-type learning -l test
+nmem g expand <id-from-above>
+nmem g evolves <id-from-above>
+nmem f --days 1
+nmem f --type crystal_created
+nmem f --from 2026-02-17 --to 2026-02-17
+nmem wm patch --heading "## Notes" --append "New note from agent"
+
+# Remote mode
+NMEM_API_URL=https://your-server NMEM_API_KEY=key nmem status
+```
+
+## Known Gaps / Accepted Limitations
+
+1. **Feed API `date_from`/`date_to`** — supported. Backend filters events by YYYY-MM-DD range. CLI: `nmem f --from/--to`. Plugin: `nowledge_mem_timeline` accepts `date_from`/`date_to`.
+2. **Working Memory section edit** — supported. `nmem wm patch --heading "## X" --content/--append` does client-side read-modify-write. Plugin: `nowledge_mem_context` accepts `patch_section` + `patch_content`/`patch_append`.
+3. **EVOLVES chain CLI** — supported. `nmem g evolves <id>` calls `/agent/evolves?memory_id=<id>`. Plugin: `nowledge_mem_connections` uses `client.graphEvolves()`.
+4. **`unit_type` requires rebuilt backend** — `MemoryCreateRequest` includes `unit_type` (fixed). Restart backend after rebuild.
+5. **Working Memory full-overwrite only via API** — the API (`PUT /agent/working-memory`) still takes full content. The section-level patch is implemented purely client-side. This is acceptable; the Knowledge Agent regenerates WM each morning anyway.
+
+## Non-Goals
+
+- Do NOT add `nowledge_mem_search` — `memory_search` covers it.
+- Do NOT expose full WM overwrite from agents — section-level patch is the right granularity.
+- Do NOT add cloud dependencies to the core path.
+- Do NOT accept unknown config keys (strict parser in `config.js`).

package/README.md

@@ -25,21 +25,18 @@ Start Nowledge Mem desktop app or run `nmem serve`, then configure:
     "slots": { "memory": "openclaw-nowledge-mem" },
     "entries": {
       "openclaw-nowledge-mem": {
-        "enabled": true,
-        "config": {
-          "autoRecall": true,
-          "autoCapture": false,
-          "maxRecallResults": 5
-        }
+        "enabled": true
       }
     }
   }
 }
 ```
 
+That's it. The agent gets 7 tools and calls them on demand. No extra tokens wasted.
+
 ### Remote mode
 
-Connect to a Nowledge Mem server running elsewhere — on a VPS, a home server, or shared team instance. See [remote access guide](https://docs.nowledge.co/docs/remote-access) for server setup.
+Connect to a Nowledge Mem server running elsewhere — on a VPS, a home server, or shared team instance. See [remote access guide](https://mem.nowledge.co/docs/remote-access) for server setup.
 
 ```json
 {
@@ -49,8 +46,6 @@ Connect to a Nowledge Mem server running elsewhere — on a VPS, a home server,
       "openclaw-nowledge-mem": {
         "enabled": true,
         "config": {
-          "autoRecall": true,
-          "autoCapture": false,
           "apiUrl": "https://nowledge.example.com",
           "apiKey": "your-api-key-here"
         }
@@ -123,35 +118,27 @@ last_n_days: 7
 
 **nowledge_mem_forget** — Delete a memory by ID or search query. Supports user confirmation when multiple matches are found.
 
-## Hooks
+## Operating Modes
 
-These run automatically at OpenClaw lifecycle events — no agent decision-making involved. The LLM never calls a hidden "save" tool; the plugin's code fires at the right moments.
+The plugin supports three modes. The default (tool-only) gives the agent full access to all tools with zero token overhead.
 
-### Auto-Recall (`autoRecall`, default: true)
+| Mode | Config | Behavior |
+|------|--------|----------|
+| **Tool-only** (default) | `autoRecall: false, autoCapture: false` | Agent calls tools on demand. Zero overhead. |
+| **Auto-recall** | `autoRecall: true` | Working Memory + relevant memories injected at session start. |
+| **Auto-capture** | `autoCapture: true` | Thread capture + LLM distillation at session end. |
 
-Before each agent turn, the plugin:
+### Auto-Recall (`autoRecall`, default: false)
 
-1. Reads **Working Memory** (today's AI-generated briefing — focus areas, flags, recent activity)
-2. Searches your knowledge graph for **relevant memories** matching the current prompt
-3. Prepends both as context to the system prompt, along with **tool guidance** for Nowledge Mem tools
-
-The agent receives richer context automatically. No tool call is made; no agent action is required.
+When enabled, the plugin injects Working Memory and relevant search results at session start. Useful for giving the agent immediate context without waiting for it to search proactively.
 
 ### Auto-Capture (`autoCapture`, default: false)
 
-At three lifecycle points — `agent_end`, `after_compaction`, `before_reset` — the plugin does two independent things:
-
-**1. Thread transcript (always)**
-The full conversation is appended to a persistent thread in Nowledge Mem, keyed by a stable session ID. This happens unconditionally on every successful session end, regardless of what was said. The thread is searchable via `nowledge_mem_timeline` and `nmem t` commands.
-
-**2. Memory note (conditional)**
-If the last user message matches a memory-trigger pattern (decision, preference, fact, entity — e.g. "I prefer TypeScript", "we chose Postgres"), a separate structured memory is also created. Questions, slash commands, and injected-context blocks are skipped. The memory note is independent of the thread — both can happen, either, or neither.
-
-**Compaction captures**: when OpenClaw compresses a long conversation to fit the model's context window, the plugin fires `after_compaction` and appends the pre-compaction transcript to the thread. Messages that get compressed away are not lost.
+When enabled, two things happen at `agent_end`, `after_compaction`, and `before_reset`:
 
-**Deduplication**: thread appends are idempotent by `external_id`. If the same hook fires twice (e.g. both `agent_end` and `before_reset`), messages are deduplicated — no duplicates in Nowledge Mem.
+**1. Thread capture (always).** The full conversation is appended to a persistent thread. Unconditional, idempotent by message ID.
 
-**Quality gates** (memory note only): skips messages shorter than 24 characters, fewer than 5 words, questions, slash commands, prompt-injection patterns, and LLM-generated context blocks.
+**2. LLM distillation (when worthwhile).** A lightweight LLM triage determines if the conversation has save-worthy content. If yes, a full distillation pass creates structured memories with types, labels, and temporal data. Language-agnostic — works in any language.
 
 ## Slash Commands
 
@@ -172,9 +159,9 @@ openclaw nowledge-mem status
 
 | Key | Type | Default | Description |
 |-----|------|---------|-------------|
-| `autoRecall` | boolean | `true` | Inject Working Memory + relevant memories at session start |
-| `autoCapture` | boolean | `false` | Capture knowledge notes and thread transcripts across lifecycle hooks |
-| `maxRecallResults` | integer | `5` | Max memories to recall (1-20) |
+| `autoRecall` | boolean | `false` | Inject Working Memory + relevant memories at session start |
+| `autoCapture` | boolean | `false` | Thread capture + LLM distillation at session end |
+| `maxRecallResults` | integer | `5` | Max memories to recall at session start (only used when autoRecall is enabled) |
 
 ## What Makes This Different
 

package/openclaw.plugin.json

@@ -1,19 +1,23 @@
 {
 	"id": "openclaw-nowledge-mem",
-	"version": "0.2.7",
+	"version": "0.6.2",
 	"kind": "memory",
 	"uiHints": {
 		"autoRecall": {
 			"label": "Auto-recall at session start",
-			"help": "Inject Working Memory briefing and relevant memories when a new session begins"
+			"help": "Inject Working Memory and relevant memories at session start. Off by default \u2014 the agent can call memory_search on demand instead."
 		},
 		"autoCapture": {
 			"label": "Auto-capture at session end",
-			"help": "Store high-value notes on agent_end / after_compaction / before_reset"
+			"help": "Capture conversation threads and distill key memories via LLM at session end"
+		},
+		"captureMinInterval": {
+			"label": "Minimum capture interval (seconds)",
+			"help": "Minimum seconds between auto-captures for the same thread. Prevents heartbeat-driven burst captures. Set to 0 for no limit."
 		},
 		"maxRecallResults": {
 			"label": "Max recall results",
-			"help": "How many memories to inject for each recall cycle (1–20)"
+			"help": "How many memories to inject for each recall cycle (1\u201320)"
 		},
 		"apiUrl": {
 			"label": "Server URL (remote mode)",
@@ -21,7 +25,7 @@
 		},
 		"apiKey": {
 			"label": "API key (remote mode)",
-			"help": "Required when connecting to a remote server. Never logged or passed as a CLI argument — injected as NMEM_API_KEY env var only.",
+			"help": "Required when connecting to a remote server. Never logged or passed as a CLI argument \u2014 injected as NMEM_API_KEY env var only.",
 			"secret": true
 		}
 	},
@@ -30,20 +34,27 @@
 		"properties": {
 			"autoRecall": {
 				"type": "boolean",
-				"default": true,
-				"description": "Inject Working Memory and recalled memories at session start"
+				"default": false,
+				"description": "Inject Working Memory and recalled memories at session start. Off by default \u2014 the agent queries memory on demand via tools."
 			},
 			"autoCapture": {
 				"type": "boolean",
 				"default": false,
-				"description": "Enable memory note capture across session lifecycle hooks"
+				"description": "Capture conversation threads and distill key memories via LLM at session end"
+			},
+			"captureMinInterval": {
+				"type": "integer",
+				"default": 300,
+				"minimum": 0,
+				"maximum": 86400,
+				"description": "Minimum seconds between auto-captures for the same thread (0 = no limit). Prevents heartbeat-driven burst captures."
 			},
 			"maxRecallResults": {
 				"type": "integer",
 				"default": 5,
 				"minimum": 1,
 				"maximum": 20,
-				"description": "Maximum memories to recall at session start"
+				"description": "Maximum memories to recall at session start (only used when autoRecall is enabled)"
 			},
 			"apiUrl": {
 				"type": "string",
@@ -53,7 +64,7 @@
 			"apiKey": {
 				"type": "string",
 				"default": "",
-				"description": "API key for remote access. Stored in plugin config, injected as NMEM_API_KEY env var — never logged."
+				"description": "API key for remote access. Stored in plugin config, injected as NMEM_API_KEY env var \u2014 never logged."
 			}
 		},
 		"additionalProperties": false

package/package.json

@@ -1,42 +1,19 @@
 {
 	"name": "@nowledge/openclaw-nowledge-mem",
-	"version": "0.2.7",
+	"version": "0.6.2",
 	"type": "module",
-	"description": "Nowledge Mem memory plugin for OpenClaw — local-first knowledge graph memory across all your AI tools",
-	"keywords": [
-		"openclaw",
-		"openclaw-plugin",
-		"memory",
-		"knowledge-graph",
-		"nowledge",
-		"nowledge-mem",
-		"ai-memory",
-		"local-first"
-	],
+	"description": "Nowledge Mem memory plugin for OpenClaw, local-first personal knowledge base",
 	"author": {
 		"name": "Nowledge Labs",
 		"email": "hello@nowledge-labs.ai",
 		"url": "https://nowledge-labs.ai"
 	},
 	"license": "MIT",
-	"homepage": "https://mem.nowledge.co/docs/integrations/openclaw",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/nowledge-co/community.git",
 		"directory": "nowledge-mem-openclaw-plugin"
 	},
-	"bugs": {
-		"url": "https://github.com/nowledge-co/community/issues"
-	},
-	"engines": {
-		"node": ">=18.0.0"
-	},
-	"files": [
-		"src/",
-		"openclaw.plugin.json",
-		"README.md",
-		"CHANGELOG.md"
-	],
 	"openclaw": {
 		"extensions": ["./src/index.js"]
 	},

package/src/client.js

@@ -16,10 +16,10 @@ function patchWmSection(currentContent, heading, { content, append } = {}) {
 	const levelMatch = headingLc.match(/^(#{1,6})\s/);
 	const targetLevel = levelMatch ? levelMatch[1].length : 2;
 
-	// Find the start of the section
+	// Find the start of the section (exact heading match, not substring)
 	let startIdx = -1;
 	for (let i = 0; i < lines.length; i++) {
-		if (lines[i].trim().toLowerCase().includes(headingLc)) {
+		if (lines[i].trim().toLowerCase() === headingLc) {
 			startIdx = i;
 			break;
 		}
@@ -48,11 +48,9 @@ function patchWmSection(currentContent, heading, { content, append } = {}) {
 	}
 
 	const newSection = [headingLine, newBody].filter(Boolean).join("\n");
-	return [
-		...lines.slice(0, startIdx),
-		newSection,
-		...lines.slice(endIdx),
-	].join("\n");
+	return [...lines.slice(0, startIdx), newSection, ...lines.slice(endIdx)].join(
+		"\n",
+	);
 }
 
 /**
@@ -81,7 +79,8 @@ export class NowledgeMemClient {
 		this.logger = logger;
 		this.nmemCmd = null;
 		// Resolved once from config + env (config wins over env, both win over default)
-		this._apiUrl = (credentials.apiUrl || "").trim() || "http://127.0.0.1:14242";
+		this._apiUrl =
+			(credentials.apiUrl || "").trim() || "http://127.0.0.1:14242";
 		this._apiKey = (credentials.apiKey || "").trim();
 	}
 
@@ -193,12 +192,16 @@ export class NowledgeMemClient {
 		const cmd = this.resolveCommand();
 		const [bin, ...baseArgs] = cmd;
 		try {
-			const result = spawnSync(bin, [...baseArgs, ...this._apiUrlArgs(), ...args], {
-				stdio: ["ignore", "pipe", "pipe"],
-				timeout,
-				encoding: "utf-8",
-				env: this._spawnEnv(),
-			});
+			const result = spawnSync(
+				bin,
+				[...baseArgs, ...this._apiUrlArgs(), ...args],
+				{
+					stdio: ["ignore", "pipe", "pipe"],
+					timeout,
+					encoding: "utf-8",
+					env: this._spawnEnv(),
+				},
+			);
 			if (result.error) {
 				throw result.error;
 			}
@@ -287,7 +290,8 @@ export class NowledgeMemClient {
 		];
 		if (eventDateFrom) args.push("--event-from", String(eventDateFrom));
 		if (eventDateTo) args.push("--event-to", String(eventDateTo));
-		if (recordedDateFrom) args.push("--recorded-from", String(recordedDateFrom));
+		if (recordedDateFrom)
+			args.push("--recorded-from", String(recordedDateFrom));
 		if (recordedDateTo) args.push("--recorded-to", String(recordedDateTo));
 
 		let data;
@@ -306,9 +310,13 @@ export class NowledgeMemClient {
 			if (query) qs.set("q", String(query));
 			if (eventDateFrom) qs.set("event_date_from", String(eventDateFrom));
 			if (eventDateTo) qs.set("event_date_to", String(eventDateTo));
-			if (recordedDateFrom) qs.set("recorded_date_from", String(recordedDateFrom));
+			if (recordedDateFrom)
+				qs.set("recorded_date_from", String(recordedDateFrom));
 			if (recordedDateTo) qs.set("recorded_date_to", String(recordedDateTo));
-			const apiData = await this.apiJson("GET", `/memories/search?${qs.toString()}`);
+			const apiData = await this.apiJson(
+				"GET",
+				`/memories/search?${qs.toString()}`,
+			);
 			// Normalize from API response format
 			const apiMems = (apiData.memories ?? []).map((m) => ({
 				id: String(m.id ?? ""),
@@ -322,7 +330,10 @@ export class NowledgeMemClient {
 				event_end: m.metadata?.event_end ?? null,
 				temporal_context: m.metadata?.temporal_context ?? null,
 			}));
-			return { memories: apiMems.map((m) => this._normalizeMemory(m)), searchMetadata: apiData.search_metadata ?? {} };
+			return {
+				memories: apiMems.map((m) => this._normalizeMemory(m)),
+				searchMetadata: apiData.search_metadata ?? {},
+			};
 		}
 
 		const memories = data.memories ?? data.results ?? [];
@@ -395,7 +406,14 @@ export class NowledgeMemClient {
 	 * with relation type: replaces | enriches | confirms | challenges.
 	 */
 	async graphEvolves(memoryId, { limit = 20 } = {}) {
-		const args = ["--json", "g", "evolves", String(memoryId), "-n", String(limit)];
+		const args = [
+			"--json",
+			"g",
+			"evolves",
+			String(memoryId),
+			"-n",
+			String(limit),
+		];
 		try {
 			return this.execJson(args);
 		} catch (err) {
@@ -465,7 +483,10 @@ export class NowledgeMemClient {
 			if (eventType) qs.set("event_type", eventType);
 			if (dateFrom) qs.set("date_from", String(dateFrom));
 			if (dateTo) qs.set("date_to", String(dateTo));
-			const data = await this.apiJson("GET", `/agent/feed/events?${qs.toString()}`);
+			const data = await this.apiJson(
+				"GET",
+				`/agent/feed/events?${qs.toString()}`,
+			);
 			return Array.isArray(data) ? data : (data.events ?? []);
 		}
 	}
@@ -648,7 +669,9 @@ export class NowledgeMemClient {
 			if (!notSupported) throw err;
 
 			// Fallback: full-document write (read → patch inline → write)
-			this.logger.warn("patchWorkingMemory: CLI too old, falling back to full replace");
+			this.logger.warn(
+				"patchWorkingMemory: CLI too old, falling back to full replace",
+			);
 			const current = await this.readWorkingMemory();
 			if (!current.available) throw new Error("Working Memory not available");
 
@@ -662,6 +685,43 @@ export class NowledgeMemClient {
 		}
 	}
 
+	// ── Distillation ─────────────────────────────────────────────────────────
+
+	/**
+	 * Lightweight triage: determine if a conversation has save-worthy content.
+	 * Uses a cheap LLM call (~50 output tokens) on the backend.
+	 *
+	 * @param {string} content  Conversation text to triage
+	 * @returns {{ should_distill: boolean, reason: string }}
+	 */
+	async triageConversation(content) {
+		return this.apiJson("POST", "/memories/distill/triage", {
+			thread_content: String(content || ""),
+		});
+	}
+
+	/**
+	 * Distill memories from a conversation thread.
+	 * Calls the full distillation endpoint which uses LLM to extract
+	 * structured memories (with unit_type, temporal data, labels).
+	 *
+	 * @param {{ threadId: string, title?: string, content: string }} params
+	 */
+	async distillThread({ threadId, title, content }) {
+		return this.apiJson(
+			"POST",
+			"/memories/distill",
+			{
+				thread_id: String(threadId || ""),
+				thread_title: title || "",
+				thread_content: String(content || ""),
+				distillation_type: "simple_llm",
+				extraction_level: "swift",
+			},
+			60_000, // 60s timeout for LLM distillation
+		);
+	}
+
 	async checkHealth() {
 		try {
 			this.exec(["status"]);

package/src/config.js

@@ -1,6 +1,18 @@
+export const API_DEFAULT_URL = "http://127.0.0.1:14242";
+
+/**
+ * Check whether an API URL points to the local default server.
+ * Useful for mode detection (local vs remote) in UI, CORS, diagnostics.
+ */
+export function isDefaultApiUrl(url) {
+	const trimmed = (url || "").trim().replace(/\/+$/, "");
+	return !trimmed || trimmed === API_DEFAULT_URL;
+}
+
 const ALLOWED_KEYS = new Set([
 	"autoRecall",
 	"autoCapture",
+	"captureMinInterval",
 	"maxRecallResults",
 	"apiUrl",
 	"apiKey",
@@ -9,10 +21,15 @@ const ALLOWED_KEYS = new Set([
 export function parseConfig(raw) {
 	const obj = raw && typeof raw === "object" ? raw : {};
 
-	for (const key of Object.keys(obj)) {
-		if (!ALLOWED_KEYS.has(key)) {
-			throw new Error(`Unknown config key: "${key}"`);
-		}
+	// Strict: reject unknown keys so users catch typos immediately.
+	// If OpenClaw adds new platform-level keys that should pass through,
+	// add them to ALLOWED_KEYS rather than silently accepting anything.
+	const unknownKeys = Object.keys(obj).filter((k) => !ALLOWED_KEYS.has(k));
+	if (unknownKeys.length > 0) {
+		throw new Error(
+			`nowledge-mem: unknown config key${unknownKeys.length > 1 ? "s" : ""}: ${unknownKeys.join(", ")}. ` +
+				`Allowed keys: ${[...ALLOWED_KEYS].join(", ")}`,
+		);
 	}
 
 	// apiUrl: config wins, then env var, then local default
@@ -30,8 +47,13 @@ export function parseConfig(raw) {
 		"";
 
 	return {
-		autoRecall: typeof obj.autoRecall === "boolean" ? obj.autoRecall : true,
+		autoRecall: typeof obj.autoRecall === "boolean" ? obj.autoRecall : false,
 		autoCapture: typeof obj.autoCapture === "boolean" ? obj.autoCapture : false,
+		captureMinInterval:
+			typeof obj.captureMinInterval === "number" &&
+			Number.isFinite(obj.captureMinInterval)
+				? Math.min(86400, Math.max(0, Math.trunc(obj.captureMinInterval)))
+				: 300,
 		maxRecallResults:
 			typeof obj.maxRecallResults === "number" &&
 			Number.isFinite(obj.maxRecallResults)

package/src/hooks/capture.js

@@ -2,6 +2,26 @@ import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 
 const MAX_MESSAGE_CHARS = 800;
+const MAX_DISTILL_MESSAGE_CHARS = 2000;
+const MAX_CONVERSATION_CHARS = 30_000;
+const MIN_MESSAGES_FOR_DISTILL = 4;
+
+// Per-thread triage cooldown: prevents burst triage/distillation from heartbeat.
+// Maps threadId -> timestamp (ms) of last successful triage.
+// Evicted opportunistically when new entries are set (see _setLastCapture).
+const _lastCaptureAt = new Map();
+const _MAX_COOLDOWN_ENTRIES = 200;
+
+function _setLastCapture(threadId, now) {
+	_lastCaptureAt.set(threadId, now);
+	// Opportunistic eviction: sweep stale entries when map grows large
+	if (_lastCaptureAt.size > _MAX_COOLDOWN_ENTRIES) {
+		const cutoff = now - 86_400_000; // 24h — generous TTL
+		for (const [key, ts] of _lastCaptureAt) {
+			if (ts < cutoff) _lastCaptureAt.delete(key);
+		}
+	}
+}
 
 function truncate(text, max = MAX_MESSAGE_CHARS) {
 	const str = String(text || "").trim();
@@ -61,73 +81,12 @@ function normalizeRoleMessage(raw) {
 	return {
 		role,
 		content: truncate(text),
+		fullContent: text,
 		timestamp,
 		externalHint,
 	};
 }
 
-function fingerprint(text) {
-	return String(text || "")
-		.toLowerCase()
-		.replace(/\s+/g, " ")
-		.replace(/[^\w\s]/g, "")
-		.slice(0, 180);
-}
-
-const PROMPT_INJECTION_PATTERNS = [
-	/ignore (all|any|previous|above|prior) instructions/i,
-	/do not follow (the )?(system|developer)/i,
-	/system prompt/i,
-	/developer message/i,
-	/<\s*(system|assistant|developer|tool|function)\b/i,
-	/\b(run|execute|call|invoke)\b.{0,40}\b(tool|command)\b/i,
-];
-
-const MEMORY_TRIGGER_PATTERNS = [
-	/\bi (like|prefer|hate|love|want|need|use|chose|decided)\b/i,
-	/\bwe (decided|agreed|chose|will use|are using|should)\b/i,
-	/\b(always|never|important|remember)\b/i,
-	/\b(my|our) (\w+ )?is\b/i,
-	/[\w.-]+@[\w.-]+\.\w+/,
-	/\+\d{10,}/,
-];
-
-function looksLikeQuestion(text) {
-	const trimmed = text.trim();
-	if (trimmed.endsWith("?")) return true;
-	if (
-		/^(what|how|why|when|where|which|who|can|could|would|should|do|does|did|is|are|was|were)\b/i.test(
-			trimmed,
-		)
-	) {
-		return true;
-	}
-	return false;
-}
-
-function looksLikePromptInjection(text) {
-	const normalized = text.replace(/\s+/g, " ").trim();
-	if (!normalized) return false;
-	return PROMPT_INJECTION_PATTERNS.some((p) => p.test(normalized));
-}
-
-function hasMemoryTrigger(text) {
-	return MEMORY_TRIGGER_PATTERNS.some((p) => p.test(text));
-}
-
-function shouldCaptureAsMemory(text) {
-	const normalized = String(text || "").trim();
-	if (!normalized) return false;
-	if (normalized.startsWith("/")) return false;
-	if (normalized.length < 24) return false;
-	if (normalized.split(/\s+/).length < 5) return false;
-	if (looksLikeQuestion(normalized)) return false;
-	if (looksLikePromptInjection(normalized)) return false;
-	if (normalized.includes("<relevant-memories>")) return false;
-	if (normalized.startsWith("<") && normalized.includes("</")) return false;
-	return hasMemoryTrigger(normalized);
-}
-
 function buildThreadTitle(ctx, reason) {
 	const session = ctx?.sessionKey || ctx?.sessionId || "session";
 	const reasonSuffix = reason ? ` (${reason})` : "";
@@ -247,15 +206,16 @@ async function appendOrCreateThread({ client, logger, event, ctx, reason }) {
 			deduplicate: true,
 			idempotencyKey,
 		});
+		const added = appended.messagesAdded ?? 0;
 		logger.info(
-			`capture: appended ${appended.messagesAdded} messages to ${threadId} (${reason || "event"})`,
+			`capture: appended ${added} messages to ${threadId} (${reason || "event"})`,
 		);
-		return;
+		return { threadId, normalized, messagesAdded: added };
 	} catch (err) {
 		if (!client.isThreadNotFoundError(err)) {
 			const message = err instanceof Error ? err.message : String(err);
 			logger.warn(`capture: thread append failed for ${threadId}: ${message}`);
-			return;
+			return null;
 		}
 	}
 
@@ -269,32 +229,60 @@ async function appendOrCreateThread({ client, logger, event, ctx, reason }) {
 		logger.info(
 			`capture: created thread ${createdId} with ${messages.length} messages (${reason || "event"})`,
 		);
+		return { threadId, normalized, messagesAdded: messages.length };
 	} catch (err) {
 		const message = err instanceof Error ? err.message : String(err);
 		logger.warn(`capture: thread create failed for ${threadId}: ${message}`);
+		return null;
+	}
+}
+
+/**
+ * Build a plain-text conversation string from normalized messages.
+ * Used as input for triage and distillation.
+ *
+ * Per-message content is capped at MAX_DISTILL_MESSAGE_CHARS and the
+ * total output at MAX_CONVERSATION_CHARS to keep LLM API payloads
+ * bounded — long coding sessions with large code blocks can produce
+ * arbitrarily large fullContent.
+ */
+function buildConversationText(normalized) {
+	const parts = [];
+	let total = 0;
+	for (const m of normalized) {
+		const text = truncate(m.fullContent || m.content, MAX_DISTILL_MESSAGE_CHARS);
+		const line = `${m.role}: ${text}`;
+		if (total + line.length > MAX_CONVERSATION_CHARS) break;
+		parts.push(line);
+		total += line.length + 2; // account for "\n\n" separator
 	}
+	return parts.join("\n\n");
 }
 
 /**
- * Capture thread + optional memory note after a successful agent run.
+ * Capture thread + LLM-based distillation after a successful agent run.
  *
- * Thread capture and memory note capture are intentionally independent:
- * - Thread append: always attempted when event.success is true and messages exist.
- *   appendOrCreateThread self-guards on empty messages.
- * - Memory note: only when the last user message matches a trigger pattern.
- *   This is an additional signal, not the gating condition for thread capture.
+ * Two independent operations (agent_end only):
+ * 1. Thread append: always attempted (unconditional, idempotent).
+ * 2. Triage + distill: only if enough messages AND cheap LLM triage
+ *    determines the conversation has save-worthy content. This replaces
+ *    the old English-only regex heuristic with language-agnostic LLM
+ *    classification.
  *
- * Previous bug: both were gated behind shouldCaptureAsMemory, so sessions
- * ending with a question or a command were silently dropped from threads.
+ * Note: LLM distillation (step 2) runs exclusively in this agent_end handler.
+ * The before_reset / after_compaction handlers only capture threads — no
+ * triage or distillation, since those are mid-session checkpoints.
  */
-export function buildAgentEndCaptureHandler(client, _cfg, logger) {
-	const seenBySession = new Map();
+export function buildAgentEndCaptureHandler(client, cfg, logger) {
+	const cooldownMs = (cfg.captureMinInterval ?? 300) * 1000;
 
 	return async (event, ctx) => {
 		if (!event?.success) return;
 
-		// 1. Always thread-append this session (idempotent, self-guards on empty messages).
-		await appendOrCreateThread({
+		// 1. Always thread-append (idempotent, self-guards on empty messages).
+		//    Never skip this — messages must always be persisted regardless of
+		//    cooldown state, since appendOrCreateThread is deduped and cheap.
+		const result = await appendOrCreateThread({
 			client,
 			logger,
 			event,
@@ -302,32 +290,83 @@ export function buildAgentEndCaptureHandler(client, _cfg, logger) {
 			reason: "agent_end",
 		});
 
-		// 2. Optionally save a memory note if the last user message is worth capturing.
-		//    This is a separate, weaker signal — do not let it gate the thread append above.
-		if (!Array.isArray(event?.messages)) return;
-		const normalized = event.messages.map(normalizeRoleMessage).filter(Boolean);
-		const lastUser = [...normalized].reverse().find((m) => m.role === "user");
-		if (!lastUser || !shouldCaptureAsMemory(lastUser.content)) return;
+		// 2. Triage + distill: language-agnostic LLM-based capture.
+		//    Defensive guard — registration in index.js already gates on autoCapture,
+		//    but check here too so the handler is safe if called directly.
+		if (!cfg.autoCapture) return;
+
+		//    Skip when no new messages were added (e.g. heartbeat re-sync).
+		if (!result || result.messagesAdded === 0) {
+			logger.debug?.("capture: no new messages since last sync, skipping triage");
+			return;
+		}
+
+		//    Triage cooldown: skip expensive LLM triage/distillation if this
+		//    thread was already triaged recently. Thread append above still ran,
+		//    so no messages are lost — only the LLM cost is avoided.
+		if (cooldownMs > 0 && result.threadId) {
+			const lastCapture = _lastCaptureAt.get(result.threadId) || 0;
+			if (Date.now() - lastCapture < cooldownMs) {
+				logger.debug?.(
+					`capture: triage cooldown active for ${result.threadId}, skipping`,
+				);
+				return;
+			}
+		}
+
+		//    Skip short conversations — not worth the triage cost.
+		if (
+			!result.normalized ||
+			result.normalized.length < MIN_MESSAGES_FOR_DISTILL
+		) {
+			return;
+		}
 
-		const sessionKey = String(ctx?.sessionKey || ctx?.sessionId || "session");
-		const nextFp = fingerprint(lastUser.content);
-		const previousFp = seenBySession.get(sessionKey);
-		if (previousFp === nextFp) return;
-		seenBySession.set(sessionKey, nextFp);
+		const conversationText = buildConversationText(result.normalized);
+		if (conversationText.length < 100) return;
+
+		//    Record cooldown AFTER all eligibility checks pass, right before
+		//    the expensive LLM call. If triage was skipped by filters above,
+		//    the cooldown stays unset so the next call can retry.
+		if (cooldownMs > 0 && result.threadId) {
+			_setLastCapture(result.threadId, Date.now());
+		}
 
 		try {
-			const title = `OpenClaw note (${sessionKey})`;
-			const id = await client.addMemory(lastUser.content, title, 0.65);
-			logger.info(`capture: stored memory ${id}`);
+			const triage = await client.triageConversation(conversationText);
+			if (!triage?.should_distill) {
+				logger.debug?.(
+					`capture: triage skipped distillation — ${triage?.reason || "no reason"}`,
+				);
+				return;
+			}
+
+			logger.info(`capture: triage passed — ${triage.reason}`);
+
+			const distillResult = await client.distillThread({
+				threadId: result.threadId,
+				title: buildThreadTitle(ctx, "distilled"),
+				content: conversationText,
+			});
+
+			const count =
+				distillResult?.memories_created ??
+				distillResult?.created_memories?.length ??
+				0;
+			logger.info(
+				`capture: distilled ${count} memories from ${result.threadId}`,
+			);
 		} catch (err) {
 			const message = err instanceof Error ? err.message : String(err);
-			logger.warn(`capture: memory store failed: ${message}`);
+			logger.warn(`capture: triage/distill failed: ${message}`);
+			// Not fatal — thread is already captured above.
 		}
 	};
 }
 
 /**
  * Capture thread messages before reset or after compaction.
+ * Thread-only (no distillation) — these are lifecycle checkpoints.
  */
 export function buildBeforeResetCaptureHandler(client, _cfg, logger) {
 	return async (event, ctx) => {

package/src/hooks/recall.js

@@ -16,17 +16,12 @@ function escapeForPrompt(text) {
 /**
  * Builds the before_agent_start hook handler.
  *
- * Injects two layers of context:
+ * Injects two layers of context at session start:
  * 1. Working Memory — today's focus, priorities, unresolved flags
  * 2. Relevant memories — with types, labels, and source provenance
  *
- * The context framing is designed to make the agent use Nowledge Mem's
- * native tools (nowledge_mem_save, nowledge_mem_connections) when
- * appropriate, rather than just answering from injected snippets.
- *
- * Source provenance: memories extracted from Library documents carry
- * SOURCED_FROM edges. The nowledge_mem_connections tool surfaces these
- * when exploring graph neighborhoods.
+ * Tool guidance is minimal — the agent already sees full tool descriptions
+ * in its tool list. We only add a brief behavioral note.
  */
 export function buildRecallHandler(client, cfg, logger) {
 	return async (event) => {
@@ -47,22 +42,21 @@ export function buildRecallHandler(client, cfg, logger) {
 			logger.error(`recall: working memory read failed: ${err}`);
 		}
 
-	// 2. Relevant memories — enriched with scoring signals and labels
-	try {
-		const results = await client.searchRich(prompt, cfg.maxRecallResults);
-		if (results.length > 0) {
-			const lines = results.map((r) => {
-				const title = r.title || "(untitled)";
-				const score = `${(r.score * 100).toFixed(0)}%`;
-				const labels =
-					Array.isArray(r.labels) && r.labels.length > 0
-						? ` [${r.labels.join(", ")}]`
-						: "";
-				// Show the scoring breakdown so the agent understands match quality
-				const matchHint = r.relevanceReason ? ` — ${r.relevanceReason}` : "";
-				const snippet = escapeForPrompt(r.content.slice(0, 250));
-				return `${title} (${score}${matchHint})${labels}: ${snippet}`;
-			});
+		// 2. Relevant memories — enriched with scoring signals and labels
+		try {
+			const results = await client.searchRich(prompt, cfg.maxRecallResults);
+			if (results.length > 0) {
+				const lines = results.map((r) => {
+					const title = r.title || "(untitled)";
+					const score = `${(r.score * 100).toFixed(0)}%`;
+					const labels =
+						Array.isArray(r.labels) && r.labels.length > 0
+							? ` [${r.labels.join(", ")}]`
+							: "";
+					const matchHint = r.relevanceReason ? ` — ${r.relevanceReason}` : "";
+					const snippet = escapeForPrompt(r.content.slice(0, 250));
+					return `${title} (${score}${matchHint})${labels}: ${snippet}`;
+				});
 				sections.push(
 					[
 						"<recalled-knowledge>",
@@ -81,25 +75,10 @@ export function buildRecallHandler(client, cfg, logger) {
 		const context = [
 			"<nowledge-mem>",
 			"Context from the user's personal knowledge graph (Nowledge Mem).",
-			"The graph contains memories, entities, and source documents (Library files and URLs).",
-			"",
-			"Tool guidance:",
-			"- memory_search: find memories by topic (semantic + BM25 + graph signals — not just keyword matching)",
-			"- memory_get: read a full memory by its nowledgemem://memory/<id> path",
-			"- nowledge_mem_connections: cross-topic synthesis and provenance — use when asked how topics relate,",
-			"    which document knowledge came from, or how understanding evolved over time",
-			"- nowledge_mem_timeline: temporal queries — 'what was I working on last week?', 'what happened yesterday?'",
-			"    Use last_n_days=1 for today, 7 for this week, 30 for this month",
-			"- nowledge_mem_save: proactively save insights, decisions, preferences — don't wait to be asked",
-			"- nowledge_mem_context: read today's Working Memory (focus areas, priorities, flags)",
-			"- nowledge_mem_forget: delete a memory by id or query",
 			"",
 			...sections,
 			"",
-			"Act on recalled knowledge naturally.",
-			"For topic connections and source provenance: use nowledge_mem_connections.",
-			"For 'what was I doing last week/yesterday?': use nowledge_mem_timeline.",
-			"When conversation produces a valuable insight or decision: save it with nowledge_mem_save.",
+			"Act on recalled knowledge naturally. When the conversation produces a valuable insight or decision, save it with nowledge_mem_save.",
 			"</nowledge-mem>",
 		].join("\n");
 

package/src/index.js

@@ -5,7 +5,7 @@ import {
 	createRecallCommand,
 	createRememberCommand,
 } from "./commands/slash.js";
-import { parseConfig } from "./config.js";
+import { isDefaultApiUrl, parseConfig } from "./config.js";
 import {
 	buildAgentEndCaptureHandler,
 	buildBeforeResetCaptureHandler,
@@ -73,7 +73,7 @@ export default {
 			commands: ["nowledge-mem"],
 		});
 
-		const remoteMode = cfg.apiUrl && cfg.apiUrl !== "http://127.0.0.1:14242";
+		const remoteMode = !isDefaultApiUrl(cfg.apiUrl);
 		logger.info(
 			`nowledge-mem: initialized (recall=${cfg.autoRecall}, capture=${cfg.autoCapture}, mode=${remoteMode ? `remote → ${cfg.apiUrl}` : "local"})`,
 		);

package/src/tools/connections.js

@@ -48,7 +48,11 @@ function getNodeTitle(node) {
 
 function getNodeSnippet(node) {
 	const content =
-		node.metadata?.content || node.content || node.summary || node.description || "";
+		node.metadata?.content ||
+		node.content ||
+		node.summary ||
+		node.description ||
+		"";
 	return content.slice(0, 150);
 }
 
@@ -75,8 +79,7 @@ function groupConnectionsByEdgeType(edges, nodeMap, centerId) {
 	const groups = new Map();
 
 	for (const edge of edges) {
-		const neighborId =
-			edge.source === centerId ? edge.target : edge.source;
+		const neighborId = edge.source === centerId ? edge.target : edge.source;
 		const node = nodeMap.get(neighborId);
 		if (!node) continue;
 
@@ -236,9 +239,12 @@ export function createConnectionsTool(client, logger) {
 				// --- Other memory connections (RELATED, etc.) ---
 				for (const [edgeType, conns] of grouped.entries()) {
 					if (
-						["CRYSTALLIZED_FROM", "EVOLVES", "SOURCED_FROM", "MENTIONS"].includes(
-							edgeType,
-						)
+						[
+							"CRYSTALLIZED_FROM",
+							"EVOLVES",
+							"SOURCED_FROM",
+							"MENTIONS",
+						].includes(edgeType)
 					)
 						continue;
 
@@ -280,14 +286,19 @@ export function createConnectionsTool(client, logger) {
 				if (edges.length > 0) {
 					const lines = edges.map((edge) => {
 						const relation = edge.content_relation || "";
-						const relLabel = EVOLVES_RELATION_LABELS[relation] || relation || "";
+						const relLabel =
+							EVOLVES_RELATION_LABELS[relation] || relation || "";
 						// Show the "other" node relative to our target
 						const isOlderNode = edge.older_id === targetId;
 						const otherTitle = isOlderNode
-							? (edge.newer_title || "(untitled)")
-							: (edge.older_title || "(untitled)");
+							? edge.newer_title || "(untitled)"
+							: edge.older_title || "(untitled)";
+						const otherId = isOlderNode
+							? edge.newer_id
+							: edge.older_id;
 						const direction = isOlderNode ? "→" : "←";
-						return `  ${direction} ${otherTitle}${relLabel ? ` — ${relLabel}` : ""}`;
+						const idLine = otherId ? `\n    → id: ${otherId}` : "";
+						return `  ${direction} ${otherTitle}${relLabel ? ` — ${relLabel}` : ""}${idLine}`;
 					});
 					sections.push(`Knowledge evolution:\n${lines.join("\n")}`);
 				}
@@ -295,7 +306,10 @@ export function createConnectionsTool(client, logger) {
 				// No EVOLVES chain for this memory — normal
 			}
 
-			if (sections.length === 0 || (sections.length === 1 && sections[0].includes("No direct connections"))) {
+			if (
+				sections.length === 0 ||
+				(sections.length === 1 && sections[0].includes("No direct connections"))
+			) {
 				return {
 					content: [
 						{

package/src/tools/context.js

@@ -50,19 +50,23 @@ export function createContextTool(client, logger) {
 
 			// — PATCH MODE —
 			if (patchSection) {
-				const patchContent = safeParams.patch_content !== undefined
-					? String(safeParams.patch_content)
-					: undefined;
-				const patchAppend = safeParams.patch_append !== undefined
-					? String(safeParams.patch_append)
-					: undefined;
+				const patchContent =
+					safeParams.patch_content !== undefined
+						? String(safeParams.patch_content)
+						: undefined;
+				const patchAppend =
+					safeParams.patch_append !== undefined
+						? String(safeParams.patch_append)
+						: undefined;
 
 				if (patchContent === undefined && patchAppend === undefined) {
 					return {
-						content: [{
-							type: "text",
-							text: "patch_section requires either patch_content (replace) or patch_append (append). Please provide one.",
-						}],
+						content: [
+							{
+								type: "text",
+								text: "patch_section requires either patch_content (replace) or patch_append (append). Please provide one.",
+							},
+						],
 					};
 				}
 
@@ -73,19 +77,23 @@ export function createContextTool(client, logger) {
 					});
 					const action = patchAppend !== undefined ? "Appended to" : "Replaced";
 					return {
-						content: [{
-							type: "text",
-							text: `Working Memory updated. ${action} section: "${patchSection}".`,
-						}],
+						content: [
+							{
+								type: "text",
+								text: `Working Memory updated. ${action} section: "${patchSection}".`,
+							},
+						],
 					};
 				} catch (err) {
 					const msg = err instanceof Error ? err.message : String(err);
 					logger.error(`context patch failed: ${msg}`);
 					return {
-						content: [{
-							type: "text",
-							text: `Failed to patch Working Memory: ${msg}`,
-						}],
+						content: [
+							{
+								type: "text",
+								text: `Failed to patch Working Memory: ${msg}`,
+							},
+						],
 					};
 				}
 			}

package/src/tools/memory-search.js

@@ -13,14 +13,13 @@ export function createMemorySearchTool(client, logger) {
 	return {
 		name: "memory_search",
 		description:
-			"Search the user's knowledge graph using a multi-signal scoring pipeline: " +
-			"semantic (embedding), BM25 keyword, label match, graph & community signals, and recency/importance decay — " +
-			"not just simple vector similarity. " +
-			"Finds prior work, decisions, preferences, and facts. " +
-			"Returns snippets with memoryIds. " +
-			"Pass a memoryId to nowledge_mem_connections for cross-topic synthesis or source provenance. " +
-			"Supports bi-temporal filtering: event_date_from/to (when the fact HAPPENED) and " +
-			"recorded_date_from/to (when it was SAVED). Format: YYYY, YYYY-MM, or YYYY-MM-DD. " +
+			"Search the user's knowledge graph for prior decisions, preferences, facts, and past work. " +
+			"WHEN TO USE: Call this proactively when the user mentions past work, references previous decisions, " +
+			"asks about something they might have discussed before, or when prior context would improve your response. " +
+			"Don't wait to be asked — if the conversation topic might have relevant history, search for it. " +
+			"Uses multi-signal scoring: semantic, BM25 keyword, label, graph & community signals, recency/importance decay. " +
+			"Returns snippets with memoryIds — pass a memoryId to nowledge_mem_connections for cross-topic synthesis or source provenance. " +
+			"Supports bi-temporal filtering: event_date_from/to (when the fact HAPPENED), recorded_date_from/to (when it was SAVED). " +
 			"For browsing recent activity by day use nowledge_mem_timeline instead.",
 		parameters: {
 			type: "object",
@@ -132,8 +131,7 @@ export function createMemorySearchTool(client, logger) {
 						memoryId: entry.id,
 					};
 					// Scoring transparency: show which signals fired
-					if (entry.relevanceReason)
-						result.matchedVia = entry.relevanceReason;
+					if (entry.relevanceReason) result.matchedVia = entry.relevanceReason;
 					// Importance context
 					if (entry.importance !== undefined && entry.importance !== null)
 						result.importance = Number(entry.importance);

package/src/tools/save.js

@@ -61,7 +61,7 @@ export function createSaveTool(client, logger) {
 					type: "array",
 					items: { type: "string" },
 					description:
-						"Topic or project labels for this memory (e.g. [\"python\", \"infra\"]). Used in search filtering.",
+						'Topic or project labels for this memory (e.g. ["python", "infra"]). Used in search filtering.',
 				},
 				event_start: {
 					type: "string",
@@ -86,7 +86,9 @@ export function createSaveTool(client, logger) {
 		async execute(_toolCallId, params) {
 			const safeParams = params && typeof params === "object" ? params : {};
 			const text = String(safeParams.text ?? "").trim();
-			const title = safeParams.title ? String(safeParams.title).trim() : undefined;
+			const title = safeParams.title
+				? String(safeParams.title).trim()
+				: undefined;
 			const unitType =
 				typeof safeParams.unit_type === "string" &&
 				VALID_UNIT_TYPES.has(safeParams.unit_type)