@evomap/evolver 1.67.4 → 1.68.0-beta.1

package/README.ja-JP.md

@@ -42,7 +42,56 @@ Evolverは **[EvoMap](https://evomap.ai)** のコアエンジンです。EvoMap
 - **[Node.js](https://nodejs.org/)** >= 18
 - **[Git](https://git-scm.com/)** -- 必須。Evolverはロールバック、影響範囲の算出、solidifyにgitを使用します。git管理外のディレクトリで実行すると、明確なエラーメッセージが表示されます。
 
-### セットアップ
+### npm からインストール（推奨）
+
+```bash
+npm install -g @evomap/evolver
+```
+
+`evolver` CLI がグローバルにインストールされます。`evolver --help` で確認してください。
+
+Linux/macOS で `EACCES` エラーが出る場合は、`sudo` ではなくユーザーレベルの prefix を設定してください:
+
+```bash
+npm config set prefix ~/.npm-global
+echo 'export PATH="$HOME/.npm-global/bin:$PATH"' >> ~/.bashrc
+source ~/.bashrc
+```
+
+### プラットフォーム統合
+
+Evolver は `setup-hooks` で主要な Agent ランタイムに統合できます。統合したいプラットフォームごとに 1 回実行してください。
+
+#### Cursor
+
+```bash
+evolver setup-hooks --platform=cursor
+```
+
+`~/.cursor/hooks.json` を書き込み、`~/.cursor/hooks/` に hook スクリプトを配置します。Cursor を再起動（または新しいセッションを開始）すると有効化されます。Hook は `sessionStart`、`afterFileEdit`、`stop` で発火します。
+
+#### Claude Code
+
+```bash
+evolver setup-hooks --platform=claude-code
+```
+
+`~/.claude/` を通して Claude Code の hook システムに Evolver を登録します。インストール後、Claude Code CLI を再起動してください。
+
+#### OpenClaw
+
+OpenClaw は Evolver が stdout に出力する `sessions_spawn(...)` プロトコルを解釈するため、**hook のインストールは不要**です。OpenClaw workspace に Evolver をクローンし、セッション内で実行してください:
+
+```bash
+cd <your-openclaw-workspace>
+git clone https://github.com/EvoMap/evolver.git
+cd evolver
+npm install
+```
+
+Evolver が OpenClaw セッション内で実行されると、ホストが stdout のディレクティブ（`sessions_spawn(...)` など）を拾い、後続のアクションを自動で連鎖させます。
+
+### ソースからインストール（上級者向け）
 
 ```bash
 git clone https://github.com/EvoMap/evolver.git
@@ -50,7 +99,11 @@ cd evolver
 npm install
 ```
 
-[EvoMapネットワーク](https://evomap.ai)に接続するには、`.env` ファイルを作成します（任意）:
+エンジン自体を改造したい、未リリースビルドを試したい、ソースツリーを調査したい場合に使用します。
+
+### EvoMap ネットワークへの接続（任意）
+
+[EvoMap ネットワーク](https://evomap.ai)に接続するには、プロジェクトルートに `.env` ファイルを作成します:
 
 ```bash
 # Node ID を取得するには https://evomap.ai で登録してください

package/README.md

@@ -42,7 +42,56 @@ Keywords: protocol-constrained evolution, audit trail, genes and capsules, promp
 - **[Node.js](https://nodejs.org/)** >= 18
 - **[Git](https://git-scm.com/)** -- Required. Evolver uses git for rollback, blast radius calculation, and solidify. Running in a non-git directory will fail with a clear error message.
 
-### Setup
+### Install from npm (recommended)
+
+```bash
+npm install -g @evomap/evolver
+```
+
+This installs the `evolver` CLI globally. Verify with `evolver --help`.
+
+If you hit `EACCES` on Linux/macOS, configure a user-level prefix instead of using `sudo`:
+
+```bash
+npm config set prefix ~/.npm-global
+echo 'export PATH="$HOME/.npm-global/bin:$PATH"' >> ~/.bashrc
+source ~/.bashrc
+```
+
+### Platform integration
+
+Evolver integrates with major agent runtimes through `setup-hooks`. Run the command once per platform you want to wire up.
+
+#### Cursor
+
+```bash
+evolver setup-hooks --platform=cursor
+```
+
+Writes `~/.cursor/hooks.json` and installs hook scripts under `~/.cursor/hooks/`. Restart Cursor (or open a new session) to activate. Hooks fire on `sessionStart`, `afterFileEdit`, and `stop`.
+
+#### Claude Code
+
+```bash
+evolver setup-hooks --platform=claude-code
+```
+
+Registers Evolver with Claude Code's hook system via `~/.claude/`. Restart the Claude Code CLI after installation.
+
+#### OpenClaw
+
+OpenClaw interprets the `sessions_spawn(...)` protocol that Evolver emits on stdout, so no hooks are required. Clone Evolver into your OpenClaw workspace and invoke it from within a session:
+
+```bash
+cd <your-openclaw-workspace>
+git clone https://github.com/EvoMap/evolver.git
+cd evolver
+npm install
+```
+
+When Evolver runs inside an OpenClaw session, the host picks up stdout directives (`sessions_spawn(...)`, etc.) and chains follow-up actions automatically.
+
+### Install from source (advanced)
 
 ```bash
 git clone https://github.com/EvoMap/evolver.git
@@ -50,7 +99,11 @@ cd evolver
 npm install
 ```
 
-To connect to the [EvoMap network](https://evomap.ai), create a `.env` file (optional):
+Use this mode if you want to hack on the engine itself, run unreleased builds, or inspect the source tree.
+
+### Connect to the EvoMap network (optional)
+
+To connect to the [EvoMap network](https://evomap.ai), create a `.env` file in your project root:
 
 ```bash
 # Register at https://evomap.ai to get your Node ID

package/README.zh-CN.md

@@ -40,7 +40,56 @@ Evolver 是 **[EvoMap](https://evomap.ai)** 的核心引擎。EvoMap 是一个 A
 - **[Node.js](https://nodejs.org/)** >= 18
 - **[Git](https://git-scm.com/)** -- 必需。Evolver 依赖 git 进行回滚、变更范围计算和固化（solidify）。在非 git 目录中运行会直接报错并退出。
 
-### 安装步骤
+### 从 npm 安装（推荐）
+
+```bash
+npm install -g @evomap/evolver
+```
+
+此命令将全局安装 `evolver` CLI。通过 `evolver --help` 验证。
+
+如在 Linux/macOS 上遇到 `EACCES` 错误，建议配置用户级 prefix，而不是使用 `sudo`：
+
+```bash
+npm config set prefix ~/.npm-global
+echo 'export PATH="$HOME/.npm-global/bin:$PATH"' >> ~/.bashrc
+source ~/.bashrc
+```
+
+### 平台集成
+
+Evolver 通过 `setup-hooks` 命令与主流 Agent 运行时集成。每个需要接入的平台执行一次即可。
+
+#### Cursor
+
+```bash
+evolver setup-hooks --platform=cursor
+```
+
+会写入 `~/.cursor/hooks.json`，并将 hook 脚本安装到 `~/.cursor/hooks/`。重启 Cursor（或开新会话）后生效。钩子在 `sessionStart`、`afterFileEdit`、`stop` 时触发。
+
+#### Claude Code
+
+```bash
+evolver setup-hooks --platform=claude-code
+```
+
+通过 `~/.claude/` 向 Claude Code 的 hook 系统注册 Evolver。安装完成后重启 Claude Code CLI。
+
+#### OpenClaw
+
+OpenClaw 会识别 Evolver 向 stdout 输出的 `sessions_spawn(...)` 协议，**无需安装 hooks**。将 Evolver 克隆到 OpenClaw workspace 中，在会话内运行即可：
+
+```bash
+cd <your-openclaw-workspace>
+git clone https://github.com/EvoMap/evolver.git
+cd evolver
+npm install
+```
+
+在 OpenClaw 会话中运行 Evolver 时，宿主会自动识别 stdout 指令（如 `sessions_spawn(...)`）并串联后续动作。
+
+### 从源码安装（进阶）
 
 ```bash
 git clone https://github.com/EvoMap/evolver.git
@@ -48,7 +97,11 @@ cd evolver
 npm install
 ```
 
-如需连接 [EvoMap 网络](https://evomap.ai)，创建 `.env` 文件（可选）：
+适用于需要修改引擎本身、运行未发布构建、或审查源码的场景。
+
+### 连接 EvoMap 网络（可选）
+
+如需连接 [EvoMap 网络](https://evomap.ai)，在项目根目录创建 `.env` 文件：
 
 ```bash
 # 在 https://evomap.ai 注册后获取 Node ID

package/SECURITY.md

@@ -0,0 +1,66 @@
+# Security Policy
+
+## Supported Versions
+
+We support the latest minor version of `@evomap/evolver` on npm. Only the current release line receives security updates; older minor versions are not backported.
+
+| Version   | Supported           |
+| --------- | ------------------- |
+| 1.67.x    | Yes (current)       |
+| < 1.67    | No                  |
+
+Run `npm view @evomap/evolver version` to check the latest published version.
+
+## Reporting a Vulnerability
+
+Please do **not** open a public GitHub issue for security vulnerabilities. Instead, use one of the private channels below.
+
+### Preferred: GitHub Private Vulnerability Reporting
+
+Submit a private report via:
+
+  https://github.com/EvoMap/evolver/security/advisories/new
+
+This is the fastest and most secure channel. Only repository maintainers will see the report.
+
+### Alternative: Email
+
+If you cannot use GitHub advisories, email `team@evomap.ai` with subject line `[SECURITY] evolver: <short title>`.
+
+### What to include
+
+- A clear description of the vulnerability and its impact
+- Affected version(s) and environment (OS, Node.js version)
+- Steps to reproduce or a minimal proof-of-concept
+- Any suggested mitigation or patch
+
+### What to expect
+
+- **Acknowledgement**: within 48 hours of receipt
+- **Initial assessment**: within 7 days (severity, affected versions, mitigation plan)
+- **Fix timeline**: critical issues are targeted for a patch release within 14 days; lower severity follows the normal release cadence
+- **Disclosure**: we practice coordinated disclosure. Once a fix is available, we publish a GitHub Security Advisory crediting the reporter (unless anonymity is requested)
+
+### Scope
+
+In scope:
+
+- `@evomap/evolver` npm package source code
+- Default configuration and built-in protocols (GEP, A2A Proxy)
+- Supply-chain risks (malicious dependencies, install scripts)
+
+Out of scope:
+
+- Vulnerabilities in the EvoMap Hub service itself -- please report those separately to `security@evomap.ai`
+- Third-party LLM providers, user-authored genes, or user-generated content
+- Social engineering and physical attacks
+
+## Safe Harbor
+
+Good-faith security research conducted under this policy is authorized. We will not pursue legal action against researchers who:
+
+- Give us reasonable time to respond before public disclosure
+- Avoid accessing data that does not belong to them
+- Do not degrade service for other users
+
+Thank you for helping keep the EvoMap ecosystem safe.

package/index.js

@@ -65,6 +65,15 @@ function parseMs(v, fallback) {
   return fallback;
 }
 
+function getLastSignals(statePath) {
+  try {
+    const st = readJsonSafe(statePath);
+    return (st && st.last_run && Array.isArray(st.last_run.signals)) ? st.last_run.signals : [];
+  } catch (e) {
+    return [];
+  }
+}
+
 // Singleton Guard - prevent multiple evolver daemon instances
 function acquireLock() {
   const lockFile = path.join(__dirname, 'evolver.pid');
@@ -129,12 +138,13 @@ async function main() {
     if (isLoop) {
         // Internal daemon loop (no wrapper required).
         if (!acquireLock()) process.exit(0);
-        process.on('exit', () => {
+        function shutdown() {
           releaseLock();
           try { require('./src/gep/a2aProtocol').stopEventStream(); } catch (e) {}
-        });
-        process.on('SIGINT', () => { releaseLock(); try { require('./src/gep/a2aProtocol').stopEventStream(); } catch (e) {} process.exit(); });
-        process.on('SIGTERM', () => { releaseLock(); try { require('./src/gep/a2aProtocol').stopEventStream(); } catch (e) {} process.exit(); });
+        }
+        process.on('exit', shutdown);
+        process.on('SIGINT', () => { shutdown(); process.exit(); });
+        process.on('SIGTERM', () => { shutdown(); process.exit(); });
         process.on('uncaughtException', (err) => {
           console.error('[FATAL] Uncaught exception:', err && err.stack ? err.stack : String(err));
           releaseLock();
@@ -157,7 +167,7 @@ async function main() {
         }
         console.log(`Loop mode enabled (internal daemon, bridge=${process.env.EVOLVE_BRIDGE}, verbose=${isVerbose}).`);
 
-        const { getEvolutionDir } = require('./src/gep/paths');
+        const { getEvolutionDir, getEvolverLogPath } = require('./src/gep/paths');
         const solidifyStatePath = path.join(getEvolutionDir(), 'evolution_solidify_state.json');
 
         const minSleepMs = parseMs(process.env.EVOLVER_MIN_SLEEP_MS, 2000);
@@ -217,6 +227,11 @@ async function main() {
           console.warn('[ATP] Auto-init failed: ' + (atpInitErr && atpInitErr.message || atpInitErr));
         }
 
+        // Hoist module refs used inside the loop to avoid repeated module lookups per cycle
+        const idleScheduler = require('./src/gep/idleScheduler');
+        const { shouldDistillFromFailures: shouldDF, autoDistillFromFailures: autoDF } = require('./src/gep/skillDistiller');
+        const { tryExplore } = require('./src/gep/explore');
+
         let currentSleepMs = minSleepMs;
         let cycleCount = 0;
 
@@ -263,26 +278,24 @@ async function main() {
           // operations (distillation, reflection) during detected idle windows.
           let omlsMultiplier = 1;
           try {
-            const { getScheduleRecommendation } = require('./src/gep/idleScheduler');
-            const schedule = getScheduleRecommendation();
+            const schedule = idleScheduler.getScheduleRecommendation();
             if (schedule.enabled && schedule.sleep_multiplier > 0) {
               omlsMultiplier = schedule.sleep_multiplier;
               if (schedule.should_distill) {
                 try {
-                  const { shouldDistillFromFailures: shouldDF, autoDistillFromFailures: autoDF } = require('./src/gep/skillDistiller');
                   if (shouldDF()) {
                     const dfResult = autoDF();
                     if (dfResult && dfResult.ok) {
                       console.log('[OMLS] Idle-window failure distillation: ' + dfResult.gene.id);
                     }
                   }
-                } catch (e) {}
+                } catch (e) {
+                  if (isVerbose) console.warn('[OMLS] Distill error: ' + (e.message || e));
+                }
               }
               if (schedule.should_explore) {
                 try {
-                  const { tryExplore } = require('./src/gep/explore');
-                  const repoRoot = require('./src/gep/paths').getRepoRoot();
-                  const exploreResult = await tryExplore([], schedule, repoRoot);
+                  const exploreResult = await tryExplore([], schedule, getRepoRoot());
                   if (exploreResult && exploreResult.signals && exploreResult.signals.length > 0) {
                     console.log('[OMLS] Explore discovered ' + exploreResult.signals.length + ' signals: ' + exploreResult.signals.slice(0, 5).join(', '));
                   }
@@ -294,7 +307,9 @@ async function main() {
                 console.log(`[OMLS] idle=${schedule.idle_seconds}s intensity=${schedule.intensity} multiplier=${omlsMultiplier}`);
               }
             }
-          } catch (e) {}
+          } catch (e) {
+            if (isVerbose) console.warn('[OMLS] Scheduler error: ' + (e.message || e));
+          }
 
           // Suicide check (memory leak protection)
           if (suicideEnabled) {
@@ -302,7 +317,6 @@ async function main() {
             if (cycleCount >= maxCyclesPerProcess || memMb > maxRssMb) {
               console.log(`[Daemon] Restarting self (cycles=${cycleCount}, rssMb=${memMb.toFixed(0)})`);
               try {
-                const { getEvolverLogPath } = require('./src/gep/paths');
                 const logFd = fs.openSync(getEvolverLogPath(), 'a');
                 const spawnOpts = {
                   detached: true,
@@ -322,8 +336,7 @@ async function main() {
 
           let saturationMultiplier = 1;
           try {
-            const st1 = readJsonSafe(solidifyStatePath);
-            const lastSignals = st1 && st1.last_run && Array.isArray(st1.last_run.signals) ? st1.last_run.signals : [];
+            const lastSignals = getLastSignals(solidifyStatePath);
             if (lastSignals.includes('force_steady_state')) {
               saturationMultiplier = 4;
               console.log('[Daemon] Saturation detected. Entering steady-state mode (4x sleep).');
@@ -331,14 +344,17 @@ async function main() {
               saturationMultiplier = 2;
               console.log('[Daemon] Approaching saturation. Reducing evolution frequency (2x sleep).');
             }
-          } catch (e) {}
+          } catch (e) {
+            if (isVerbose) console.warn('[Daemon] Saturation check error: ' + (e.message || e));
+          }
 
           // Jitter to avoid lockstep restarts.
           const jitter = Math.floor(Math.random() * 250);
           const totalSleepMs = Math.max(minSleepMs, (currentSleepMs + jitter) * saturationMultiplier * omlsMultiplier);
           if (isVerbose) {
             const memMb = (process.memoryUsage().rss / 1024 / 1024).toFixed(1);
-            console.log(`[Verbose] cycle=${cycleCount} ok=${ok} dt=${dt}ms sleep=${totalSleepMs}ms (base=${currentSleepMs} jitter=${jitter} sat=${saturationMultiplier}x) rss=${memMb}MB signals=[${(function() { try { var st = readJsonSafe(solidifyStatePath); return st && st.last_run && Array.isArray(st.last_run.signals) ? st.last_run.signals.join(',') : ''; } catch(e) { return ''; } })()}]`);
+            const signals = getLastSignals(solidifyStatePath).join(',');
+            console.log(`[Verbose] cycle=${cycleCount} ok=${ok} dt=${dt}ms sleep=${totalSleepMs}ms (base=${currentSleepMs} jitter=${jitter} sat=${saturationMultiplier}x) rss=${memMb}MB signals=[${signals}]`);
           }
           await sleepMs(totalSleepMs);
 
@@ -438,11 +454,11 @@ async function main() {
           if (!res || !res.ok) {
             if (res && res.validation && !res.validation.ok) {
               urgentOpts.validationFailed = true;
-              var failedStep = res.validation.results && res.validation.results.find(function (r) { return !r.ok; });
+              const failedStep = res.validation.results && res.validation.results.find(function (r) { return !r.ok; });
               urgentOpts.validationErrors = failedStep ? (failedStep.err || failedStep.cmd || '') : '';
             }
             urgentOpts.geneId = res && res.gene ? res.gene.id : undefined;
-            var evtOutcome = res && res.event && res.event.outcome;
+            const evtOutcome = res && res.event && res.event.outcome;
             if (evtOutcome && typeof evtOutcome.score === 'number' && evtOutcome.score < 0.3) {
               urgentOpts.lowConfidence = true;
               urgentOpts.confidenceScore = evtOutcome.score;
@@ -454,13 +470,13 @@ async function main() {
               urgentOpts.signals = res.event && Array.isArray(res.event.signals) ? res.event.signals : [];
             }
             if (res && res.constraintCheck && Array.isArray(res.constraintCheck.violations)) {
-              var llmRejectV = res.constraintCheck.violations.find(function (v) { return String(v).startsWith('llm_review_rejected'); });
+              const llmRejectV = res.constraintCheck.violations.find(function (v) { return String(v).startsWith('llm_review_rejected'); });
               if (llmRejectV) {
                 urgentOpts.llmReviewRejected = true;
                 urgentOpts.llmReviewReason = String(llmRejectV).replace('llm_review_rejected: ', '');
               }
             }
-            var lr = readJsonSafe(path.join(require('./src/gep/paths').getEvolutionDir(), 'evolution_solidify_state.json'));
+            const lr = readJsonSafe(path.join(require('./src/gep/paths').getEvolutionDir(), 'evolution_solidify_state.json'));
             if (lr && lr.last_run && lr.last_run.active_task_id) {
               urgentOpts.taskCompletionFailed = true;
               urgentOpts.taskTitle = lr.last_run.active_task_title || '';
@@ -473,13 +489,13 @@ async function main() {
           }
 
           if (Object.keys(urgentOpts).length > 0) {
-            var urgentQs = generateUrgentQuestions(urgentOpts);
+            const urgentQs = generateUrgentQuestions(urgentOpts);
             if (urgentQs.length > 0) {
               console.log('[UrgentQ] Generated ' + urgentQs.length + ' urgent question(s) from solidify outcome.');
               try {
-                var fetchRes = await fetchTasks({ questions: urgentQs });
+                const fetchRes = await fetchTasks({ questions: urgentQs });
                 if (fetchRes.questions_created) {
-                  var accepted = fetchRes.questions_created.filter(function (q) { return !q.error; });
+                  const accepted = fetchRes.questions_created.filter(function (q) { return !q.error; });
                   if (accepted.length > 0) {
                     console.log('[UrgentQ] Hub accepted ' + accepted.length + ' urgent question(s) as bounties.');
                   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evomap/evolver",
-  "version": "1.67.4",
+  "version": "1.68.0-beta.1",
   "description": "A GEP-powered self-evolution engine for AI agents. Features automated log analysis and Genome Evolution Protocol (GEP) for auditable, reusable evolution assets.",
   "main": "index.js",
   "bin": {

package/src/adapters/scripts/evolver-session-end.js

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+// evolver-session-end.js
+// Records evolution outcome at session end.
+// Collects git diff stats, extracts signals, records via Hub API or local memory.
+// Input: stdin JSON. Output: stdout JSON with followup_message.
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+function findEvolverRoot() {
+  const candidates = [
+    process.env.EVOLVER_ROOT,
+    path.resolve(__dirname, '..', '..', '..'),
+  ];
+  for (const c of candidates) {
+    if (c && fs.existsSync(path.join(c, 'package.json'))) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(c, 'package.json'), 'utf8'));
+        if (pkg.name === '@evomap/evolver' || pkg.name === 'evolver') return c;
+      } catch { /* skip */ }
+    }
+  }
+  const homeSkills = path.join(require('os').homedir(), 'skills', 'evolver');
+  if (fs.existsSync(path.join(homeSkills, 'package.json'))) return homeSkills;
+  return null;
+}
+
+function findMemoryGraph(evolverRoot) {
+  if (process.env.MEMORY_GRAPH_PATH && fs.existsSync(process.env.MEMORY_GRAPH_PATH)) {
+    return process.env.MEMORY_GRAPH_PATH;
+  }
+  const candidates = [
+    evolverRoot && path.join(evolverRoot, 'memory', 'evolution', 'memory_graph.jsonl'),
+    evolverRoot && path.join(evolverRoot, 'MEMORY', 'evolution', 'memory_graph.jsonl'),
+  ];
+  for (const c of candidates) {
+    if (c && fs.existsSync(c)) return c;
+  }
+  if (evolverRoot) {
+    const defaultPath = path.join(evolverRoot, 'memory', 'evolution', 'memory_graph.jsonl');
+    fs.mkdirSync(path.dirname(defaultPath), { recursive: true });
+    return defaultPath;
+  }
+  return null;
+}
+
+function getGitDiffStats() {
+  try {
+    const cwd = process.cwd();
+    const stat = execSync('git diff --stat HEAD~1 2>/dev/null || git diff --stat 2>/dev/null || echo ""', {
+      cwd,
+      encoding: 'utf8',
+      timeout: 5000,
+    }).trim();
+    const diffContent = execSync('git diff HEAD~1 --no-color 2>/dev/null || git diff --no-color 2>/dev/null || echo ""', {
+      cwd,
+      encoding: 'utf8',
+      timeout: 5000,
+    }).trim();
+    const filesChanged = (stat.match(/\d+ files? changed/) || ['0'])[0];
+    const insertions = (stat.match(/(\d+) insertions?/) || [null, '0'])[1];
+    const deletions = (stat.match(/(\d+) deletions?/) || [null, '0'])[1];
+    return {
+      stat,
+      summary: `${filesChanged}, +${insertions}/-${deletions}`,
+      diffSnippet: diffContent.slice(0, 2000),
+      hasChanges: stat.length > 0,
+    };
+  } catch {
+    return { stat: '', summary: 'unknown', diffSnippet: '', hasChanges: false };
+  }
+}
+
+function detectSignals(text) {
+  if (!text) return [];
+  const lower = text.toLowerCase();
+  const signals = [];
+  if (/error:|exception:|failed/i.test(lower)) signals.push('log_error');
+  if (/timeout|slow|latency|bottleneck/i.test(lower)) signals.push('perf_bottleneck');
+  if (/add|implement|feature|new function|new module/i.test(lower)) signals.push('user_feature_request');
+  if (/improve|enhance|refactor|optimize/i.test(lower)) signals.push('user_improvement_suggestion');
+  if (/not supported|unsupported|not implemented/i.test(lower)) signals.push('capability_gap');
+  if (/deploy|ci|pipeline|build failed/i.test(lower)) signals.push('deployment_issue');
+  if (/test fail|assertion|expect\(/i.test(lower)) signals.push('test_failure');
+  return [...new Set(signals)];
+}
+
+function recordToHub(outcome) {
+  const hubUrl = process.env.EVOMAP_HUB_URL || process.env.A2A_HUB_URL;
+  const apiKey = process.env.EVOMAP_API_KEY || process.env.A2A_NODE_SECRET;
+  const nodeId = process.env.EVOMAP_NODE_ID || process.env.A2A_NODE_ID;
+  if (!hubUrl || !apiKey) return false;
+
+  try {
+    const payload = JSON.stringify({
+      gene_id: outcome.geneId || 'ad_hoc',
+      signals: outcome.signals,
+      status: outcome.status,
+      score: outcome.score,
+      summary: outcome.summary,
+      sender_id: nodeId || undefined,
+    });
+    const curlCmd = `curl -s -m 8 -X POST`
+      + ` -H "Content-Type: application/json"`
+      + ` -H "Authorization: Bearer ${apiKey}"`
+      + ` -d '${payload.replace(/'/g, "'\\''")}'`
+      + ` "${hubUrl.replace(/\/+$/, '')}/a2a/evolution/record"`;
+    execSync(curlCmd, { timeout: 10000, stdio: ['pipe', 'pipe', 'pipe'] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function recordToLocal(graphPath, outcome) {
+  try {
+    const entry = {
+      timestamp: new Date().toISOString(),
+      gene_id: outcome.geneId || 'ad_hoc',
+      signals: outcome.signals,
+      outcome: {
+        status: outcome.status,
+        score: outcome.score,
+        note: outcome.summary,
+      },
+      source: 'hook:session-end',
+    };
+    fs.appendFileSync(graphPath, JSON.stringify(entry) + '\n', 'utf8');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function main() {
+  let inputData = '';
+  let handled = false;
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => { inputData += chunk; });
+  process.stdin.on('end', () => {
+    if (handled) return;
+    handled = true;
+    try {
+      const diffInfo = getGitDiffStats();
+
+      if (!diffInfo.hasChanges) {
+        process.stdout.write(JSON.stringify({}));
+        return;
+      }
+
+      const signals = detectSignals(diffInfo.diffSnippet);
+      if (signals.length === 0) signals.push('stable_success_plateau');
+
+      const hasErrors = signals.includes('log_error') || signals.includes('test_failure');
+      const status = hasErrors ? 'failed' : 'success';
+      const score = hasErrors ? 0.3 : 0.8;
+
+      const outcome = {
+        geneId: 'ad_hoc',
+        signals,
+        status,
+        score,
+        summary: `Session end: ${diffInfo.summary}. Signals: [${signals.join(', ')}]`,
+      };
+
+      const evolverRoot = findEvolverRoot();
+      const graphPath = findMemoryGraph(evolverRoot);
+
+      const hubOk = recordToHub(outcome);
+      const localOk = graphPath ? recordToLocal(graphPath, outcome) : false;
+
+      const target = hubOk ? 'Hub' : localOk ? 'local memory' : 'nowhere (no Hub or local path)';
+      const msg = `[Evolution] Session outcome recorded to ${target}: ${outcome.summary}`;
+
+      process.stdout.write(JSON.stringify({
+        followup_message: msg,
+        stopMessage: msg,
+        additionalContext: msg,
+      }));
+    } catch (e) {
+      process.stdout.write(JSON.stringify({}));
+    }
+  });
+
+  setTimeout(() => {
+    if (handled) return;
+    handled = true;
+    process.stdout.write(JSON.stringify({}));
+    process.exit(0);
+  }, 7000);
+}
+
+main();