@evomap/evolver 1.70.0 → 1.74.0

package/assets/gep/candidates.jsonl

@@ -1,6 +1 @@
-{"type":"CapabilityCandidate","id":"cand_b9a66a5c","title":"Harden session log detection and fallback behavior","source":"signals","created_at":"2026-04-27T05:47:45.106Z","signals":["memory_missing","user_missing","session_logs_missing"],"tags":["memory_missing","user_missing","session_logs_missing","area:memory"],"shape":{"title":"Harden session log detection and fallback behavior","input":"Recent session transcript + memory snippets + user instructions","output":"A safe, auditable evolution patch guided by GEP assets","invariants":"Protocol order, small reversible patches, validation, append-only events","params":"Signals: memory_missing, user_missing, session_logs_missing","failure_points":"Missing signals, over-broad changes, skipped validation, missing knowledge solidification","evidence":"Signal present: session_logs_missing"}}
-{"type":"CapabilityCandidate","id":"cand_b9a66a5c","title":"Harden session log detection and fallback behavior","source":"signals","created_at":"2026-04-27T05:47:47.051Z","signals":["bounty_task","external_task","seo","approaches","different","compare","comparison","note","within","optimization","keyword","red","xiaohongshu","xiaohongshu-ops","memory_missing","user_missing","session_logs_missing"],"tags":["bounty_task","external_task","seo","approaches","different","compare","comparison","note","within","optimization","keyword","red","xiaohongshu","xiaohongshu-ops","memory_missing","user_missing","session_logs_missing","area:orchestration","area:memory"],"shape":{"title":"Harden session log detection and fallback behavior","input":"Recent session transcript + memory snippets + user instructions","output":"A safe, auditable evolution patch guided by GEP assets","invariants":"Protocol order, small reversible patches, validation, append-only events","params":"Signals: bounty_task, external_task, seo, approaches, different, compare, comparison, note, within, optimization, keyword, red, xiaohongshu, xiaohongshu-ops, memory_missing, user_missing, session_logs_missing","failure_points":"Missing signals, over-broad changes, skipped validation, missing knowledge solidification","evidence":"Signal present: session_logs_missing"}}
-{"type":"CapabilityCandidate","id":"cand_b9a66a5c","title":"Harden session log detection and fallback behavior","source":"signals","created_at":"2026-04-27T05:47:48.939Z","signals":["bounty_task","external_task","seo","approaches","different","compare","comparison","note","within","optimization","keyword","red","xiaohongshu","xiaohongshu-ops","memory_missing","user_missing","session_logs_missing"],"tags":["bounty_task","external_task","seo","approaches","different","compare","comparison","note","within","optimization","keyword","red","xiaohongshu","xiaohongshu-ops","memory_missing","user_missing","session_logs_missing","area:orchestration","area:memory"],"shape":{"title":"Harden session log detection and fallback behavior","input":"Recent session transcript + memory snippets + user instructions","output":"A safe, auditable evolution patch guided by GEP assets","invariants":"Protocol order, small reversible patches, validation, append-only events","params":"Signals: bounty_task, external_task, seo, approaches, different, compare, comparison, note, within, optimization, keyword, red, xiaohongshu, xiaohongshu-ops, memory_missing, user_missing, session_logs_missing","failure_points":"Missing signals, over-broad changes, skipped validation, missing knowledge solidification","evidence":"Signal present: session_logs_missing"}}
-{"type":"CapabilityCandidate","id":"cand_b9a66a5c","title":"Harden session log detection and fallback behavior","source":"signals","created_at":"2026-04-27T05:49:00.343Z","signals":["bounty_task","external_task","seo","approaches","different","compare","comparison","note","within","optimization","keyword","red","xiaohongshu","xiaohongshu-ops","memory_missing","user_missing","session_logs_missing"],"tags":["bounty_task","external_task","seo","approaches","different","compare","comparison","note","within","optimization","keyword","red","xiaohongshu","xiaohongshu-ops","memory_missing","user_missing","session_logs_missing","area:orchestration","area:memory"],"shape":{"title":"Harden session log detection and fallback behavior","input":"Recent session transcript + memory snippets + user instructions","output":"A safe, auditable evolution patch guided by GEP assets","invariants":"Protocol order, small reversible patches, validation, append-only events","params":"Signals: bounty_task, external_task, seo, approaches, different, compare, comparison, note, within, optimization, keyword, red, xiaohongshu, xiaohongshu-ops, memory_missing, user_missing, session_logs_missing","failure_points":"Missing signals, over-broad changes, skipped validation, missing knowledge solidification","evidence":"Signal present: session_logs_missing"}}
-{"type":"CapabilityCandidate","id":"cand_b9a66a5c","title":"Harden session log detection and fallback behavior","source":"signals","created_at":"2026-04-27T05:49:02.561Z","signals":["bounty_task","external_task","skills","monetize","how","monetization","reduce","optimization","prompt","negative","image-generation","ai-art","ai-image-generation","memory_missing","user_missing","session_logs_missing"],"tags":["bounty_task","external_task","skills","monetize","how","monetization","reduce","optimization","prompt","negative","image-generation","ai-art","ai-image-generation","memory_missing","user_missing","session_logs_missing","problem:protocol","action:optimize","area:prompt","area:orchestration","area:memory","area:skills"],"shape":{"title":"Harden session log detection and fallback behavior","input":"Recent session transcript + memory snippets + user instructions","output":"A safe, auditable evolution patch guided by GEP assets","invariants":"Protocol order, small reversible patches, validation, append-only events","params":"Signals: bounty_task, external_task, skills, monetize, how, monetization, reduce, optimization, prompt, negative, image-generation, ai-art, ai-image-generation, memory_missing, user_missing, session_logs_missing","failure_points":"Missing signals, over-broad changes, skipped validation, missing knowledge solidification","evidence":"Signal present: session_logs_missing"}}
-{"type":"CapabilityCandidate","id":"cand_b9a66a5c","title":"Harden session log detection and fallback behavior","source":"signals","created_at":"2026-04-27T05:49:04.551Z","signals":["bounty_task","external_task","seo","approaches","different","compare","comparison","note","within","optimization","keyword","red","xiaohongshu","xiaohongshu-ops","memory_missing","user_missing","session_logs_missing"],"tags":["bounty_task","external_task","seo","approaches","different","compare","comparison","note","within","optimization","keyword","red","xiaohongshu","xiaohongshu-ops","memory_missing","user_missing","session_logs_missing","area:orchestration","area:memory"],"shape":{"title":"Harden session log detection and fallback behavior","input":"Recent session transcript + memory snippets + user instructions","output":"A safe, auditable evolution patch guided by GEP assets","invariants":"Protocol order, small reversible patches, validation, append-only events","params":"Signals: bounty_task, external_task, seo, approaches, different, compare, comparison, note, within, optimization, keyword, red, xiaohongshu, xiaohongshu-ops, memory_missing, user_missing, session_logs_missing","failure_points":"Missing signals, over-broad changes, skipped validation, missing knowledge solidification","evidence":"Signal present: session_logs_missing"}}
+{"type":"CapabilityCandidate","id":"cand_b9a66a5c","title":"Harden session log detection and fallback behavior","source":"signals","created_at":"2026-04-28T03:36:59.386Z","signals":["memory_missing","user_missing","session_logs_missing"],"tags":["memory_missing","user_missing","session_logs_missing","area:memory"],"shape":{"title":"Harden session log detection and fallback behavior","input":"Recent session transcript + memory snippets + user instructions","output":"A safe, auditable evolution patch guided by GEP assets","invariants":"Protocol order, small reversible patches, validation, append-only events","params":"Signals: memory_missing, user_missing, session_logs_missing","failure_points":"Missing signals, over-broad changes, skipped validation, missing knowledge solidification","evidence":"Signal present: session_logs_missing"}}

package/index.js

@@ -266,7 +266,10 @@ async function main() {
           console.warn('[ATP] Auto-init failed: ' + (atpInitErr && atpInitErr.message || atpInitErr));
         }
 
-        // ATP: opt-in capability-gap auto-buyer (default OFF, must be explicitly enabled).
+        // ATP: capability-gap auto-buyer. Default ON as of ATP liquidity
+        // unlock; disable with EVOLVER_ATP_AUTOBUY=off. Also starts the
+        // merchant-side auto-deliver daemon so claimed ATP tasks actually
+        // call submitDelivery and settle instead of expiring.
         try {
           try {
             const { runPrompt } = require('./src/atp/cliAutobuyPrompt');
@@ -274,8 +277,8 @@ async function main() {
           } catch (promptErr) {
             console.warn('[ATP-AutoBuyer] first-run prompt failed: ' + (promptErr && promptErr.message || promptErr));
           }
-          const autoBuyRaw = (process.env.EVOLVER_ATP_AUTOBUY || 'off').toLowerCase().trim();
-          const autoBuyOn = autoBuyRaw === 'on' || autoBuyRaw === '1' || autoBuyRaw === 'true';
+          const autoBuyRaw = (process.env.EVOLVER_ATP_AUTOBUY || 'on').toLowerCase().trim();
+          const autoBuyOn = autoBuyRaw !== 'off' && autoBuyRaw !== '0' && autoBuyRaw !== 'false';
           if (autoBuyOn) {
             const hubUrl = process.env.A2A_HUB_URL || process.env.EVOMAP_HUB_URL || '';
             if (hubUrl) {
@@ -285,7 +288,20 @@ async function main() {
                 perOrderCap: Number(process.env.ATP_AUTOBUY_PER_ORDER_CAP_CREDITS) || undefined,
               });
             } else {
-              console.warn('[ATP-AutoBuyer] EVOLVER_ATP_AUTOBUY=on but no hub URL configured, skipping.');
+              console.warn('[ATP-AutoBuyer] autobuy enabled but no hub URL configured, skipping.');
+            }
+          }
+          const autoDeliverRaw = (process.env.EVOLVER_ATP_AUTODELIVER || 'on').toLowerCase().trim();
+          const autoDeliverOn = autoDeliverRaw !== 'off' && autoDeliverRaw !== '0' && autoDeliverRaw !== 'false';
+          if (autoDeliverOn) {
+            const hubUrl = process.env.A2A_HUB_URL || process.env.EVOMAP_HUB_URL || '';
+            if (hubUrl) {
+              const autoDeliver = require('./src/atp/autoDeliver');
+              autoDeliver.start({
+                pollMs: Number(process.env.ATP_AUTODELIVER_POLL_MS) || undefined,
+              });
+            } else {
+              console.warn('[ATP-AutoDeliver] autodeliver enabled but no hub URL configured, skipping.');
             }
           }
         } catch (autoBuyInitErr) {
@@ -847,6 +863,23 @@ async function main() {
       const data = await resp.json();
       const outFlag = args.find(a => typeof a === 'string' && a.startsWith('--out='));
       const safeId = String(data.skill_id || skillId).replace(/[^a-zA-Z0-9_\-\.]/g, '_');
+      // Reject safeId values that would either stay inside cwd instead of
+      // descending into skills/, or escape cwd entirely. The sanitizing regex
+      // above permits `.`, so `..` / `.` / empty survive it; `path.join('.',
+      // 'skills', '..')` collapses to `.` which turns the download directory
+      // into the user's working directory and lets Hub-supplied bundled_files
+      // overwrite `index.js`, `package.json`, etc. See GHSA-cfcj-hqpf-hccf.
+      if (
+        safeId === '' ||
+        safeId === '.' ||
+        safeId === '..' ||
+        safeId.includes('/') ||
+        safeId.includes('\\') ||
+        safeId.includes('\0')
+      ) {
+        console.error('[fetch] Hub returned an invalid skill_id: ' + JSON.stringify(safeId));
+        process.exit(1);
+      }
       let outDir;
       if (outFlag) {
         const rawOut = outFlag.slice('--out='.length);
@@ -869,7 +902,16 @@ async function main() {
         }
         outDir = resolvedOut;
       } else {
-        outDir = path.join('.', 'skills', safeId);
+        // Defense in depth: apply the same traversal check to the default
+        // branch so any remaining path-smuggling shape in `safeId` is caught.
+        const candidate = path.resolve(process.cwd(), 'skills', safeId);
+        const skillsRoot = path.resolve(process.cwd(), 'skills');
+        const rel = path.relative(skillsRoot, candidate);
+        if (rel.startsWith('..') || path.isAbsolute(rel)) {
+          console.error('[fetch] Hub-provided skill_id escapes skills/ directory: ' + JSON.stringify(safeId));
+          process.exit(1);
+        }
+        outDir = candidate;
       }
 
       if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
@@ -885,12 +927,24 @@ async function main() {
         '.yml', '.yaml',
       ]);
       const MAX_SKILL_FILE_BYTES = 512 * 1024;
+      // Even with outDir locked to skills/, a legitimate-looking skill can
+      // ship a bundled file named `package.json`, `index.js`, or any other
+      // top-level project artifact whose name collides with something the
+      // user may later copy back up. Prefix-guard the resolved path so every
+      // write stays strictly within the resolved outDir (no trailing `/..`
+      // in basename, no absolute path smuggling) and never points at cwd.
+      const resolvedOutDir = path.resolve(outDir);
+      const resolvedCwd = path.resolve(process.cwd());
 
       const bundled = Array.isArray(data.bundled_files) ? data.bundled_files : [];
       const skippedFiles = [];
       for (const file of bundled) {
         if (!file || !file.name || typeof file.content !== 'string') continue;
         const safeName = path.basename(file.name);
+        if (!safeName || safeName === '.' || safeName === '..') {
+          skippedFiles.push(String(file.name));
+          continue;
+        }
         const ext = path.extname(safeName).toLowerCase();
         if (!ALLOWED_SKILL_EXTENSIONS.has(ext)) {
           console.warn('[fetch] Skipped skill file with disallowed extension: ' + safeName);
@@ -902,7 +956,23 @@ async function main() {
           skippedFiles.push(safeName);
           continue;
         }
-        fs.writeFileSync(path.join(outDir, safeName), file.content, 'utf8');
+        const destPath = path.resolve(resolvedOutDir, safeName);
+        const relToOut = path.relative(resolvedOutDir, destPath);
+        if (relToOut.startsWith('..') || path.isAbsolute(relToOut)) {
+          console.warn('[fetch] Skipped bundled file whose resolved path escapes outDir: ' + safeName);
+          skippedFiles.push(safeName);
+          continue;
+        }
+        // Never let a bundled write touch the evolver's own cwd -- this is
+        // the concrete attack shape from GHSA-cfcj-hqpf-hccf (fetch default
+        // branch writing to `./index.js`). outDir should always be under
+        // skills/ now, but belt-and-braces keep the guarantee explicit.
+        if (path.dirname(destPath) === resolvedCwd) {
+          console.warn('[fetch] Skipped bundled file that would land in cwd: ' + safeName);
+          skippedFiles.push(safeName);
+          continue;
+        }
+        fs.writeFileSync(destPath, file.content, 'utf8');
       }
 
       console.log('[fetch] Skill downloaded to: ' + outDir);
@@ -1002,6 +1072,45 @@ async function main() {
       process.exit(1);
     }
 
+  } else if (command === 'atp-complete') {
+    // Invoked by a spawned Cursor sub-session after it has written the ATP
+    // task answer to a file. Drives publish -> task/complete -> atp/deliver.
+    try {
+      const subArgs = args.slice(1);
+      function flag(name) {
+        const pref = '--' + name + '=';
+        const hit = subArgs.find(function (a) { return typeof a === 'string' && a.startsWith(pref); });
+        return hit ? hit.slice(pref.length) : null;
+      }
+      function list(name) {
+        const raw = flag(name);
+        if (!raw) return null;
+        return raw.split(',').map(function (s) { return String(s).trim(); }).filter(Boolean);
+      }
+      const taskId = flag('task-id');
+      const orderId = flag('order-id');
+      const answerFile = flag('answer-file');
+      const summary = flag('summary');
+      const capabilities = list('capabilities');
+      const signals = list('signals');
+      if (!taskId || !orderId || !answerFile) {
+        console.error('[ATP-Complete] Missing required flags: --task-id, --order-id, --answer-file');
+        console.error('Usage: node index.js atp-complete --task-id=<tid> --order-id=<oid> --answer-file=<path> [--summary="..."] [--capabilities=cap1,cap2] [--signals=sig1,sig2]');
+        process.exit(2);
+      }
+      const { completeAtpTask } = require('./src/atp/atpExecute');
+      const res = await completeAtpTask({ taskId, orderId, answerFile, summary, capabilities, signals });
+      if (res && res.ok) {
+        console.log('[ATP-Complete] OK asset_id=' + res.assetId + (res.deliveryId ? ' delivery_id=' + res.deliveryId : ''));
+        process.exit(0);
+      }
+      console.error('[ATP-Complete] FAILED stage=' + (res && res.stage) + ' error=' + (res && res.error));
+      process.exit(1);
+    } catch (atpCompleteErr) {
+      console.error('[ATP-Complete] Error:', atpCompleteErr && atpCompleteErr.message || atpCompleteErr);
+      process.exit(1);
+    }
+
   } else if (command === 'buy' || command === 'orders' || command === 'verify') {
     try {
       const atpCli = require('./src/atp/cli');
@@ -1031,7 +1140,7 @@ async function main() {
     }
 
   } else {
-    console.log(`Usage: node index.js [run|/evolve|solidify|review|distill|fetch|asset-log|setup-hooks|buy|orders|verify] [--loop]
+    console.log(`Usage: node index.js [run|/evolve|solidify|review|distill|fetch|asset-log|setup-hooks|buy|orders|verify|atp-complete] [--loop]
   - fetch flags:
     - --skill=<id> | -s <id>   (skill ID to download)
     - --out=<dir>              (output directory, default: ./skills/<skill_id>)
@@ -1071,6 +1180,13 @@ async function main() {
     - --json                   (raw JSON)
   - verify <orderId>           (confirm delivery or trigger AI judge)
     - --action=confirm|ai_judge (default confirm)
+  - atp-complete               (internal: spawned Cursor sub-session uses this to settle an ATP task)
+    - --task-id=<tid>          (Hub task id, required)
+    - --order-id=<oid>         (ATP DeliveryProof id, required)
+    - --answer-file=<path>     (file containing the merchant answer, required)
+    - --summary="..."          (capsule summary, optional)
+    - --capabilities=a,b       (listing capabilities, optional)
+    - --signals=s1,s2          (task signals, optional)
 
 Validator role (decentralized validation, default ON since v1.69.0):
   - EVOLVER_VALIDATOR_ENABLED=0    opt out (env beats persisted flag and default)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evomap/evolver",
-  "version": "1.70.0",
+  "version": "1.74.0",
   "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/scripts/validate-suite.js

@@ -1,6 +1,8 @@
-// Usage: node scripts/validate-suite.js [test-glob-pattern]
+// Usage: node scripts/validate-suite.js [test-glob-pattern | test-file]
 // Runs the evolver test suite -- repo root is derived from script location, no shell glob needed.
-const { execSync } = require('child_process');
+// Accepts either a directory glob pattern (e.g. `test/*.test.js`) or a concrete test file path.
+// See community PR #514.
+const { execFileSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 
@@ -8,10 +10,22 @@ const EVOLVER_REPO_ROOT = path.join(__dirname, '..');
 const pattern = process.argv[2] || 'test/*.test.js';
 
 function expandTestGlob(repoRoot, pat) {
-  const dir = pat.replace(/\/\*\.test\.js$/, '');
+  const fullPattern = path.isAbsolute(pat) ? pat : path.join(repoRoot, pat);
+  if (fs.existsSync(fullPattern) && fs.statSync(fullPattern).isFile()) {
+    return fullPattern.endsWith('.test.js') ? [fullPattern] : [];
+  }
+
+  const dir = path.dirname(pat);
+  const basenamePattern = path.basename(pat);
   const fullDir = path.isAbsolute(dir) ? dir : path.join(repoRoot, dir);
+  if (!fs.existsSync(fullDir) || !fs.statSync(fullDir).isDirectory()) return [];
+
+  const escaped = basenamePattern
+    .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
+    .replace(/\*/g, '.*');
+  const matcher = new RegExp('^' + escaped + '$');
   return fs.readdirSync(fullDir)
-    .filter(f => f.endsWith('.test.js'))
+    .filter(f => f.endsWith('.test.js') && matcher.test(f))
     .map(f => path.join(fullDir, f))
     .sort();
 }
@@ -22,7 +36,6 @@ if (files.length === 0) {
   process.exit(1);
 }
 
-const cmd = 'node --test ' + files.join(' ');
 const env = Object.assign({}, process.env, {
   NODE_ENV: 'test',
   EVOLVER_REPO_ROOT,
@@ -30,9 +43,11 @@ const env = Object.assign({}, process.env, {
 });
 delete env.EVOLVE_BRIDGE;
 delete env.OPENCLAW_WORKSPACE;
+// Clear NODE_TEST_CONTEXT so nested runs from within node --test work.
+delete env.NODE_TEST_CONTEXT;
 
 try {
-  const output = execSync(cmd, {
+  const output = execFileSync(process.execPath, ['--test', ...files], {
     cwd: EVOLVER_REPO_ROOT,
     stdio: ['pipe', 'pipe', 'pipe'],
     timeout: 180000,

package/src/adapters/hookAdapter.js

@@ -6,6 +6,7 @@ const PLATFORMS = {
   cursor: { name: 'Cursor', configDir: '.cursor', detector: '.cursor' },
   'claude-code': { name: 'Claude Code', configDir: '.claude', detector: '.claude' },
   codex: { name: 'Codex', configDir: '.codex', detector: '.codex' },
+  kiro: { name: 'Kiro', configDir: '.kiro', detector: '.kiro' },
 };
 
 function detectPlatform(cwd) {
@@ -35,6 +36,7 @@ function loadAdapter(platformId) {
     case 'cursor': return require('./cursor');
     case 'claude-code': return require('./claudeCode');
     case 'codex': return require('./codex');
+    case 'kiro': return require('./kiro');
     default: return null;
   }
 }
@@ -163,7 +165,7 @@ async function setupHooks({ platform, cwd, force, uninstall, evolverRoot } = {})
   const platformId = platform || detectPlatform(effectiveCwd);
 
   if (!platformId) {
-    console.error('[setup-hooks] Could not detect platform. Use --platform=cursor|claude-code|codex');
+    console.error('[setup-hooks] Could not detect platform. Use --platform=cursor|claude-code|codex|kiro');
     return { ok: false, error: 'platform_not_detected' };
   }
 

package/src/adapters/kiro.js

@@ -0,0 +1,203 @@
+const fs = require('fs');
+const path = require('path');
+const { copyHookScripts, removeHookScripts } = require('./hookAdapter');
+
+const HOOK_SCRIPTS_DIR_NAME = 'hooks';
+const EVOLVER_MARKER = '<!-- evolver-evolution-memory -->';
+const HOOK_FILE_SUFFIX = '.kiro.hook';
+const HOOK_FILES = {
+  sessionStart: 'evolver-session-start.kiro.hook',
+  signalDetect: 'evolver-signal-detect.kiro.hook',
+  sessionEnd: 'evolver-session-end.kiro.hook',
+};
+
+function buildHookConfig(kind, scriptsBase) {
+  // Kiro has no dedicated sessionStart event; `promptSubmit` is the closest
+  // analogue. The session-start JS script itself guards against per-prompt
+  // re-injection via a session-scoped state file when
+  // EVOLVER_SESSION_START_DEDUP=1 is set (injected inline into the command
+  // because Kiro runCommand has no env field).
+  const sessionStartCmd = `EVOLVER_SESSION_START_DEDUP=1 node ${scriptsBase}/evolver-session-start.js`;
+  const hookTemplates = {
+    sessionStart: {
+      name: 'Evolver Session Start',
+      version: '1',
+      description:
+        'Reads recent evolution memory from the local memory graph and injects it as context when a prompt is submitted.',
+      when: { type: 'promptSubmit' },
+      then: {
+        type: 'runCommand',
+        command: sessionStartCmd,
+        timeout: 3,
+      },
+      _evolver_managed: true,
+    },
+    signalDetect: {
+      name: 'Evolver Signal Detect',
+      version: '1',
+      description:
+        'Detects evolution signals (errors, perf bottlenecks, capability gaps, test failures) in file content after write operations.',
+      when: { type: 'postToolUse', toolTypes: ['write'] },
+      then: {
+        type: 'runCommand',
+        command: `node ${scriptsBase}/evolver-signal-detect.js`,
+        timeout: 2,
+      },
+      _evolver_managed: true,
+    },
+    sessionEnd: {
+      name: 'Evolver Session End',
+      version: '1',
+      description:
+        'Records evolution outcome at session end by analyzing git diff stats and writing to the local memory graph.',
+      when: { type: 'agentStop' },
+      then: {
+        type: 'runCommand',
+        command: `node ${scriptsBase}/evolver-session-end.js`,
+        timeout: 8,
+      },
+      _evolver_managed: true,
+    },
+  };
+  return hookTemplates[kind];
+}
+
+function buildAgentsMdSection() {
+  return `${EVOLVER_MARKER}
+## Evolution Memory (Evolver)
+
+This project uses evolver for self-evolution. Hooks automatically:
+1. Inject recent evolution memory on prompt submit
+2. Detect evolution signals during file edits
+3. Record outcomes at session end
+
+For substantive tasks, call \`gep_recall\` before work and \`gep_record_outcome\` after.
+Signals: log_error, perf_bottleneck, user_feature_request, capability_gap, deployment_issue, test_failure.`;
+}
+
+function appendSectionToFile(filePath, marker, content) {
+  let existing = '';
+  try { existing = fs.readFileSync(filePath, 'utf8'); } catch { /* new file */ }
+  if (existing.includes(marker)) return false;
+  const separator = existing.length > 0 && !existing.endsWith('\n') ? '\n\n' : '\n';
+  fs.writeFileSync(filePath, existing + separator + content + '\n', 'utf8');
+  return true;
+}
+
+function writeHookFile(hooksDir, fileName, config) {
+  const tmp = path.join(hooksDir, fileName + '.tmp');
+  const dest = path.join(hooksDir, fileName);
+  fs.writeFileSync(tmp, JSON.stringify(config, null, 2) + '\n', 'utf8');
+  fs.renameSync(tmp, dest);
+  return dest;
+}
+
+function isEvolverManagedHookFile(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8').trim();
+    if (!raw) return false;
+    const data = JSON.parse(raw);
+    if (data && data._evolver_managed === true) return true;
+    if (typeof data.name === 'string' && /^evolver\b/i.test(data.name)) return true;
+    if (data.then && typeof data.then.command === 'string' &&
+        /evolver-(session|signal)/.test(data.then.command)) return true;
+  } catch { /* treat as non-evolver */ }
+  return false;
+}
+
+function install({ configRoot, evolverRoot, force }) {
+  const kiroDir = path.join(configRoot, '.kiro');
+  const hooksDir = path.join(kiroDir, HOOK_SCRIPTS_DIR_NAME);
+  const agentsMdPath = path.join(configRoot, 'AGENTS.md');
+  const scriptsBase = '.kiro/hooks';
+
+  const hookPaths = Object.values(HOOK_FILES).map(name => path.join(hooksDir, name));
+
+  if (!force) {
+    const existingEvolverHook = hookPaths.find(p => fs.existsSync(p) && isEvolverManagedHookFile(p));
+    if (existingEvolverHook) {
+      console.log('[kiro] Evolver hooks already installed. Use --force to overwrite.');
+      return { ok: true, skipped: true };
+    }
+  }
+
+  fs.mkdirSync(hooksDir, { recursive: true });
+
+  const written = [];
+  for (const [kind, fileName] of Object.entries(HOOK_FILES)) {
+    const cfg = buildHookConfig(kind, scriptsBase);
+    const dest = writeHookFile(hooksDir, fileName, cfg);
+    written.push(dest);
+    console.log('[kiro] Wrote ' + dest);
+  }
+
+  const copied = copyHookScripts(hooksDir, path.join(evolverRoot, 'src', 'adapters'));
+  console.log('[kiro] Copied ' + copied.length + ' hook scripts to ' + hooksDir);
+
+  const injected = appendSectionToFile(agentsMdPath, EVOLVER_MARKER, buildAgentsMdSection());
+  if (injected) {
+    console.log('[kiro] Injected evolution section into ' + agentsMdPath);
+  }
+
+  console.log('[kiro] Installation complete.');
+  console.log('[kiro] Kiro auto-discovers *.kiro.hook files in .kiro/hooks/ -- no restart needed.');
+
+  return {
+    ok: true,
+    platform: 'kiro',
+    files: [...written, agentsMdPath, ...copied],
+  };
+}
+
+function uninstall({ configRoot }) {
+  const kiroDir = path.join(configRoot, '.kiro');
+  const hooksDir = path.join(kiroDir, HOOK_SCRIPTS_DIR_NAME);
+  const agentsMdPath = path.join(configRoot, 'AGENTS.md');
+
+  let changed = false;
+  let removedCount = 0;
+
+  if (fs.existsSync(hooksDir)) {
+    try {
+      const entries = fs.readdirSync(hooksDir);
+      for (const entry of entries) {
+        if (!entry.endsWith(HOOK_FILE_SUFFIX)) continue;
+        const full = path.join(hooksDir, entry);
+        if (isEvolverManagedHookFile(full)) {
+          try { fs.unlinkSync(full); removedCount++; changed = true; } catch { /* ignore */ }
+        }
+      }
+    } catch { /* ignore */ }
+  }
+
+  const scripts = removeHookScripts(hooksDir);
+  if (scripts > 0) changed = true;
+
+  try {
+    if (fs.existsSync(agentsMdPath)) {
+      let content = fs.readFileSync(agentsMdPath, 'utf8');
+      if (content.includes(EVOLVER_MARKER)) {
+        const idx = content.indexOf(EVOLVER_MARKER);
+        const nextSection = content.indexOf('\n## ', idx + EVOLVER_MARKER.length);
+        const endIdx = nextSection !== -1 ? nextSection : content.length;
+        content = content.slice(0, idx).trimEnd() + (nextSection !== -1 ? content.slice(endIdx) : '');
+        fs.writeFileSync(agentsMdPath, content.trimEnd() + '\n', 'utf8');
+        changed = true;
+      }
+    }
+  } catch { /* ignore */ }
+
+  console.log(changed
+    ? `[kiro] Uninstalled evolver hooks (${removedCount} hook files + ${scripts} scripts removed).`
+    : '[kiro] No evolver hooks found to uninstall.');
+
+  return { ok: true, removed: changed };
+}
+
+module.exports = {
+  install,
+  uninstall,
+  buildHookConfig,
+  isEvolverManagedHookFile,
+  HOOK_FILES,
+};

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

@@ -5,6 +5,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 
 function findEvolverRoot() {
   const candidates = [
@@ -58,7 +59,68 @@ function formatOutcome(entry) {
   return `[${icon}] ${ts} score=${score} signals=[${signals}] ${note}`.slice(0, 200);
 }
 
+// Dedup guard: on platforms like Kiro, the sessionStart-equivalent event
+// (`promptSubmit`) fires on every user message in a session. Without this
+// guard, recent memory would be re-injected on every prompt. We key the
+// dedup on (platform, cwd) with a short TTL so a fresh agent session within
+// the same workspace still gets the injection, but mid-session prompts do
+// not. Cursor/Claude Code/Codex have true sessionStart events and should
+// bypass this check (controlled by EVOLVER_SESSION_START_DEDUP env var,
+// which the Kiro adapter sets on the hook command line implicitly via the
+// runtime environment, and other adapters leave unset).
+function getDedupStatePath() {
+  const dir = process.env.EVOLVER_SESSION_STATE_DIR
+    || path.join(os.homedir(), '.evolver');
+  try { fs.mkdirSync(dir, { recursive: true }); } catch { /* ignore */ }
+  return path.join(dir, 'session-start-state.json');
+}
+
+function shouldSkipInjection() {
+  // Only apply dedup when explicitly enabled (set by Kiro adapter) OR when
+  // we detect a per-prompt-firing platform via PROMPT_SUBMIT heuristic in
+  // stdin. The stdin is drained in main(), so we rely on env flag here.
+  const dedupEnabled = String(process.env.EVOLVER_SESSION_START_DEDUP || '').toLowerCase() === '1'
+    || String(process.env.EVOLVER_SESSION_START_DEDUP || '').toLowerCase() === 'true';
+  if (!dedupEnabled) return false;
+
+  const ttlMs = Number(process.env.EVOLVER_SESSION_START_DEDUP_TTL_MS) || (30 * 60 * 1000);
+  const key = process.cwd();
+  const statePath = getDedupStatePath();
+
+  let state = {};
+  try {
+    if (fs.existsSync(statePath)) {
+      state = JSON.parse(fs.readFileSync(statePath, 'utf8')) || {};
+    }
+  } catch { state = {}; }
+
+  const now = Date.now();
+  const last = state[key];
+  if (typeof last === 'number' && now - last < ttlMs) {
+    return true;
+  }
+
+  state[key] = now;
+  try {
+    for (const k of Object.keys(state)) {
+      if (typeof state[k] !== 'number' || now - state[k] > 24 * 60 * 60 * 1000) {
+        delete state[k];
+      }
+    }
+    const tmp = statePath + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(state), 'utf8');
+    fs.renameSync(tmp, statePath);
+  } catch { /* best-effort */ }
+
+  return false;
+}
+
 function main() {
+  if (shouldSkipInjection()) {
+    process.stdout.write(JSON.stringify({}));
+    return;
+  }
+
   const evolverRoot = findEvolverRoot();
   const graphPath = findMemoryGraph(evolverRoot);