Skip to content

armgit / ECC

Public Imported from GitHub
0

The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.

fix(continuous-learning): /evolve never produces skill or agent candidates (#2664)

romanclaudersoai18a97868b5b7d
diff --git a/skills/continuous-learning-v2/scripts/instinct-cli.py b/skills/continuous-learning-v2/scripts/instinct-cli.py
index 9bc3b6898..98f3724b5 100755
--- a/skills/continuous-learning-v2/scripts/instinct-cli.py
+++ b/skills/continuous-learning-v2/scripts/instinct-cli.py
@@ -1145,6 +1145,163 @@ def cmd_export(args) -> int:
# Evolve Command
# ─────────────────────────────────────────────
+# Words carrying no topical signal in a trigger sentence.
+TRIGGER_STOP_WORDS = {
+ 'when', 'while', 'the', 'and', 'or', 'to', 'of', 'in', 'on', 'for', 'with',
+ 'that', 'this', 'from', 'into', 'at', 'by', 'as', 'is', 'are', 'be', 'it',
+ 'its', 'they', 'them', 'their', 'you', 'your', 'new', 'any', 'all', 'about',
+ 'after', 'before', 'over', 'via', 'use', 'using', 'need', 'needs', 'not',
+}
+
+# Overlap coefficient (shared / smaller set) two triggers need to cluster.
+# Jaccard is the wrong metric here: trigger keyword sets average ~7 words, so
+# even clearly-related pairs top out near 0.33 and nothing ever groups.
+TRIGGER_SIMILARITY_THRESHOLD = 0.5
+
+# Guard against one incidental shared word pulling unrelated instincts together.
+TRIGGER_MIN_SHARED_KEYWORDS = 2
+
+
+# Evolved artefact slugs are trimmed to keep file names short. The cut has to
+# land on a word boundary: a hard slice produced names like
+# "investigating-comple" and "learning-about-compl", which read as typos.
+EVOLVED_SKILL_SLUG_LENGTH = 30
+EVOLVED_COMMAND_SLUG_LENGTH = 20
+EVOLVED_AGENT_SLUG_LENGTH = 20
+
+
+def _truncate_slug(slug: str, max_length: int) -> str:
+ """Trim a slug to max_length without splitting a word.
+
+ Falls back to a hard cut only when the first word is already longer than
+ the limit, because then there is no boundary left to retreat to.
+ """
+ if len(slug) <= max_length:
+ return slug
+ head = slug[:max_length]
+ # The cut can already land on a separator, in which case head is a whole
+ # sequence of words and dropping one more would lose a word for nothing.
+ if slug[max_length] == '-':
+ return head.rstrip('-')
+ boundary = head.rfind('-')
+ if boundary > 0:
+ return head[:boundary]
+ return head.strip('-')
+
+
+def _evolved_skill_name(trigger: str) -> str:
+ """Slug used for a generated skill directory. Shared by preview and writer."""
+ return _truncate_slug(
+ re.sub(r'[^a-z0-9]+', '-', str(trigger or '').lower()).strip('-'),
+ EVOLVED_SKILL_SLUG_LENGTH,
+ )
+
+
+def _evolved_command_name(trigger: str) -> str:
+ """Slug used for a generated command file. Shared by preview and writer."""
+ stripped = str(trigger or 'unknown').lower().replace('when ', '').replace('implementing ', '')
+ return _truncate_slug(
+ re.sub(r'[^a-z0-9]+', '-', stripped).strip('-'),
+ EVOLVED_COMMAND_SLUG_LENGTH,
+ )
+
+
+def _evolved_agent_name(trigger: str) -> str:
+ """Slug used for a generated agent file. Shared by preview and writer."""
+ return _truncate_slug(
+ re.sub(r'[^a-z0-9]+', '-', str(trigger or '').lower()).strip('-'),
+ EVOLVED_AGENT_SLUG_LENGTH,
+ )
+
+
+# How many candidates of each kind the analysis prints before summarising the
+# rest. The preview is a sample, never the whole set, so it always says so.
+PREVIEW_LIMIT = 5
+
+
+def _print_preview_remainder(total: int, shown: int, noun: str) -> None:
+ """State how many candidates the preview left out.
+
+ Without this the truncated list reads as the complete set.
+ """
+ if total > shown:
+ print(f" ... and {total - shown} more {noun} not shown\n")
+
+
+def _assign_unique_slugs(items: list, slug_fn) -> list:
+ """Pair every item with a collision-free slug, preserving input order.
+
+ Word-boundary trimming makes collisions more likely because two triggers
+ can now share a whole prefix, and a collision previously meant one
+ generated file silently overwriting another. Preview and writer both call
+ this over the same ordered list, so the names shown and the names written
+ stay identical.
+ """
+ used = set()
+ assigned = []
+ for item in items:
+ base = slug_fn(item)
+ if not base:
+ assigned.append((item, ''))
+ continue
+ name = base
+ suffix = 2
+ while name in used:
+ name = f"{base}-{suffix}"
+ suffix += 1
+ used.add(name)
+ assigned.append((item, name))
+ return assigned
+
+
+def _trigger_keywords(trigger: str) -> set:
+ """Reduce a trigger sentence to the words that carry its topic."""
+ words = re.findall(r'[a-z0-9]+', str(trigger or '').lower())
+ return {w for w in words if len(w) > 2 and w not in TRIGGER_STOP_WORDS}
+
+
+def _cluster_by_keyword_overlap(instincts: list) -> dict:
+ """Group instincts whose triggers share enough keywords.
+
+ Triggers are free-form sentences, so grouping on the whole normalized
+ string puts every instinct in its own bucket and no skill or agent
+ candidate is ever produced. Greedy clustering on keyword overlap groups
+ the near-duplicate instincts that accumulate in a project.
+ """
+ clusters = [] # [(shared_keywords, [instincts])]
+
+ for inst in instincts:
+ keywords = _trigger_keywords(inst.get('trigger', ''))
+ if not keywords:
+ continue
+
+ best_index, best_score, best_shared = -1, 0.0, 0
+ for index, (cluster_keywords, _members) in enumerate(clusters):
+ shared = len(keywords & cluster_keywords)
+ smaller = min(len(keywords), len(cluster_keywords))
+ score = shared / smaller if smaller else 0.0
+ if score > best_score:
+ best_index, best_score, best_shared = index, score, shared
+
+ if (best_index >= 0
+ and best_score >= TRIGGER_SIMILARITY_THRESHOLD
+ and best_shared >= TRIGGER_MIN_SHARED_KEYWORDS):
+ cluster_keywords, members = clusters[best_index]
+ members.append(inst)
+ # Keep the shared core so a cluster stays on one topic.
+ clusters[best_index] = (cluster_keywords & keywords, members)
+ else:
+ clusters.append((keywords, [inst]))
+
+ grouped = {}
+ for cluster_keywords, members in clusters:
+ label = ' '.join(sorted(cluster_keywords)[:4]) or 'general'
+ while label in grouped:
+ label += ' +'
+ grouped[label] = members
+ return grouped
+
+
def cmd_evolve(args) -> int:
"""Analyze instincts and suggest evolutions to skills/commands/agents."""
project = detect_project()
@@ -1175,14 +1332,7 @@ def cmd_evolve(args) -> int:
print(f"High confidence instincts (>=80%): {len(high_conf)}")
# Find clusters (instincts with similar triggers)
- trigger_clusters = defaultdict(list)
- for inst in instincts:
- trigger = inst.get('trigger', '')
- # Normalize trigger
- trigger_key = trigger.lower()
- for keyword in ['when', 'creating', 'writing', 'adding', 'implementing', 'testing']:
- trigger_key = trigger_key.replace(keyword, '').strip()
- trigger_clusters[trigger_key].append(inst)
+ trigger_clusters = _cluster_by_keyword_overlap(instincts)
# Find clusters with 2+ instincts (good skill candidates)
skill_candidates = []
@@ -1203,8 +1353,8 @@ def cmd_evolve(args) -> int:
print(f"\nPotential skill clusters found: {len(skill_candidates)}")
if skill_candidates:
- print(f"\n## SKILL CANDIDATES\n")
- for i, cand in enumerate(skill_candidates[:5], 1):
+ print(f"\n## SKILL CANDIDATES ({len(skill_candidates)})\n")
+ for i, cand in enumerate(skill_candidates[:PREVIEW_LIMIT], 1):
scope_info = ', '.join(cand['scopes'])
print(f"{i}. Cluster: \"{cand['trigger']}\"")
print(f" Instincts: {len(cand['instincts'])}")
@@ -1215,37 +1365,51 @@ def cmd_evolve(args) -> int:
for inst in cand['instincts'][:3]:
print(f" - {inst.get('id')} [{inst.get('scope', '?')}]")
print()
+ _print_preview_remainder(len(skill_candidates), PREVIEW_LIMIT, 'skill clusters')
# Command candidates (workflow instincts with high confidence)
workflow_instincts = [i for i in instincts if i.get('domain') == 'workflow' and i.get('confidence', 0) >= 0.7]
if workflow_instincts:
print(f"\n## COMMAND CANDIDATES ({len(workflow_instincts)})\n")
- for inst in workflow_instincts[:5]:
- trigger = inst.get('trigger', 'unknown')
- cmd_name = trigger.replace('when ', '').replace('implementing ', '').replace('a ', '')
- cmd_name = cmd_name.replace(' ', '-')[:20]
+ # Slugs come from the same helper the writer uses, over the same ordered
+ # list, or the preview advertises names that differ from the files
+ # --generate actually writes.
+ for inst, cmd_name in _assign_unique_slugs(
+ workflow_instincts,
+ lambda i: _evolved_command_name(i.get('trigger', 'unknown')),
+ )[:PREVIEW_LIMIT]:
print(f" /{cmd_name}")
print(f" From: {inst.get('id')} [{inst.get('scope', '?')}]")
print(f" Confidence: {inst.get('confidence', 0.5):.0%}")
print()
+ _print_preview_remainder(len(workflow_instincts), PREVIEW_LIMIT, 'command candidates')
# Agent candidates (complex multi-step patterns)
agent_candidates = [c for c in skill_candidates if len(c['instincts']) >= 3 and c['avg_confidence'] >= 0.75]
if agent_candidates:
print(f"\n## AGENT CANDIDATES ({len(agent_candidates)})\n")
- for cand in agent_candidates[:3]:
- agent_name = cand['trigger'].replace(' ', '-')[:20] + '-agent'
+ for cand, agent_name in _assign_unique_slugs(
+ agent_candidates,
+ lambda c: _evolved_agent_name(str(c.get('trigger', '')).strip()),
+ )[:PREVIEW_LIMIT]:
print(f" {agent_name}")
print(f" Covers {len(cand['instincts'])} instincts")
print(f" Avg confidence: {cand['avg_confidence']:.0%}")
print()
+ _print_preview_remainder(len(agent_candidates), PREVIEW_LIMIT, 'agent candidates')
# Promotion candidates (project instincts that could be global)
_show_promotion_candidates(project)
if args.generate:
evolved_dir = project["evolved_dir"] if project["id"] != "global" else GLOBAL_EVOLVED_DIR
- generated = _generate_evolved(skill_candidates, workflow_instincts, agent_candidates, evolved_dir)
+ generated = _generate_evolved(
+ skill_candidates,
+ workflow_instincts,
+ agent_candidates,
+ evolved_dir,
+ limit=max(0, getattr(args, 'limit', 0) or 0),
+ )
if generated:
print(f"\nGenerated {len(generated)} evolved structures:")
for path in generated:
@@ -1770,17 +1934,33 @@ def _cmd_projects_merge(args) -> int:
# Generate Evolved Structures
# ─────────────────────────────────────────────
-def _generate_evolved(skill_candidates: list, workflow_instincts: list, agent_candidates: list, evolved_dir: Path) -> list[str]:
- """Generate skill/command/agent files from analyzed instinct clusters."""
+def _generate_evolved(skill_candidates: list, workflow_instincts: list, agent_candidates: list, evolved_dir: Path, limit: int = 0) -> list[str]:
+ """Generate skill/command/agent files from analyzed instinct clusters.
+
+ ``limit`` caps how many candidates of each kind are written; 0 writes them
+ all. Anything a cap leaves out is reported, because the previous fixed
+ caps (5 skills, 5 commands, 3 agents) discarded most candidates without
+ saying a word — 35 command candidates produced 5 files and no warning.
+ """
generated = []
- # Generate skills from top candidates
- for cand in skill_candidates[:5]:
+ def bounded(assigned: list, kind: str) -> list:
+ if limit and len(assigned) > limit:
+ print(f"\nNote: writing {limit} of {len(assigned)} {kind} candidates "
+ f"(--limit {limit}); {len(assigned) - limit} skipped.")
+ return assigned[:limit]
+ return assigned
+
+ # Generate skills from candidate clusters
+ for cand, name in bounded(
+ _assign_unique_slugs(
+ skill_candidates,
+ lambda c: _evolved_skill_name(str(c.get('trigger', '')).strip()),
+ ),
+ 'skill',
+ ):
trigger = cand['trigger'].strip()
- if not trigger:
- continue
- name = re.sub(r'[^a-z0-9]+', '-', trigger.lower()).strip('-')[:30]
- if not name:
+ if not trigger or not name:
continue
skill_dir = evolved_dir / "skills" / name
@@ -1802,10 +1982,13 @@ def _generate_evolved(skill_candidates: list, workflow_instincts: list, agent_ca
generated.append(str(skill_dir / "SKILL.md"))
# Generate commands from workflow instincts
- for inst in workflow_instincts[:5]:
- trigger = inst.get('trigger', 'unknown')
- cmd_name = re.sub(r'[^a-z0-9]+', '-', trigger.lower().replace('when ', '').replace('implementing ', ''))
- cmd_name = cmd_name.strip('-')[:20]
+ for inst, cmd_name in bounded(
+ _assign_unique_slugs(
+ workflow_instincts,
+ lambda i: _evolved_command_name(i.get('trigger', 'unknown')),
+ ),
+ 'command',
+ ):
if not cmd_name:
continue
@@ -1819,9 +2002,13 @@ def _generate_evolved(skill_candidates: list, workflow_instincts: list, agent_ca
generated.append(str(cmd_file))
# Generate agents from complex clusters
- for cand in agent_candidates[:3]:
- trigger = cand['trigger'].strip()
- agent_name = re.sub(r'[^a-z0-9]+', '-', trigger.lower()).strip('-')[:20]
+ for cand, agent_name in bounded(
+ _assign_unique_slugs(
+ agent_candidates,
+ lambda c: _evolved_agent_name(str(c.get('trigger', '')).strip()),
+ ),
+ 'agent',
+ ):
if not agent_name:
continue
@@ -2018,6 +2205,8 @@ def main() -> int:
# Evolve
evolve_parser = subparsers.add_parser('evolve', help='Analyze and evolve instincts')
evolve_parser.add_argument('--generate', action='store_true', help='Generate evolved structures')
+ evolve_parser.add_argument('--limit', type=int, default=0, metavar='N',
+ help='Max candidates of each kind to generate (default: 0 = all)')
# Promote (new in v2.1)
promote_parser = subparsers.add_parser('promote', help='Promote project instincts to global scope')
diff --git a/tests/scripts/instinct-cli-evolve-generate.test.js b/tests/scripts/instinct-cli-evolve-generate.test.js
new file mode 100644
index 000000000..956111f45
--- /dev/null
+++ b/tests/scripts/instinct-cli-evolve-generate.test.js
@@ -0,0 +1,249 @@
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+let passed = 0;
+let failed = 0;
+
+const repoRoot = path.resolve(__dirname, '..', '..');
+const cliPath = path.join(
+ repoRoot,
+ 'skills',
+ 'continuous-learning-v2',
+ 'scripts',
+ 'instinct-cli.py'
+);
+
+function detectPython3() {
+ for (const bin of ['python3', 'python']) {
+ const r = spawnSync(bin, ['--version'], { encoding: 'utf8' });
+ if (r.status === 0 && /Python 3/.test(r.stdout + r.stderr)) return bin;
+ }
+ return null;
+}
+
+const PYTHON3 = detectPython3();
+if (!PYTHON3) {
+ console.log('\n=== Testing instinct-cli.py evolve generation ===\n');
+ console.log(' - skipped: Python 3 not found in PATH');
+ console.log('\nPassed: 0');
+ console.log('Failed: 0');
+ process.exit(0);
+}
+
+function test(name, fn) {
+ try {
+ fn();
+ console.log(` ✓ ${name}`);
+ passed += 1;
+ } catch (error) {
+ console.log(` ✗ ${name}`);
+ console.log(` Error: ${error.message}`);
+ failed += 1;
+ }
+}
+
+function createTempDir() {
+ return fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-instinct-cli-evolve-'));
+}
+
+function cleanupDir(dir) {
+ fs.rmSync(dir, { recursive: true, force: true });
+}
+
+function writeInstinct(root, id, trigger, confidence = 0.8, domain = 'workflow') {
+ const dir = path.join(root, 'instincts', 'personal');
+ fs.mkdirSync(dir, { recursive: true });
+ fs.writeFileSync(
+ path.join(dir, `${id}.yaml`),
+ [
+ '---',
+ `id: ${id}`,
+ `trigger: "${trigger}"`,
+ `confidence: ${confidence}`,
+ `domain: ${domain}`,
+ '---',
+ '',
+ `## Action`,
+ '',
+ `Action for ${id}.`,
+ '',
+ ].join('\n')
+ );
+}
+
+// CLV2_NO_PROJECT pins the run to global scope, so seeded instincts live in
+// <root>/instincts/personal and generated files land in <root>/evolved.
+function runCli(root, args) {
+ return spawnSync(PYTHON3, [cliPath, ...args], {
+ cwd: repoRoot,
+ encoding: 'utf8',
+ env: {
+ ...process.env,
+ CLV2_HOMUNCULUS_DIR: root,
+ CLV2_NO_PROJECT: '1',
+ HOME: path.join(root, 'home'),
+ USERPROFILE: path.join(root, 'home'),
+ CLAUDE_PROJECT_DIR: '',
+ },
+ });
+}
+
+function generatedCommands(root) {
+ const dir = path.join(root, 'evolved', 'commands');
+ if (!fs.existsSync(dir)) return [];
+ return fs.readdirSync(dir).sort();
+}
+
+// Eight unrelated workflow triggers: no two share enough keywords to cluster,
+// so each one is its own command candidate.
+const EIGHT_TRIGGERS = [
+ ['run-tests', 'when running tests'],
+ ['build-images', 'when building images'],
+ ['deploy-services', 'when deploying services'],
+ ['profile-memory', 'when profiling memory'],
+ ['rotate-secrets', 'when rotating secrets'],
+ ['tag-releases', 'when tagging releases'],
+ ['prune-caches', 'when pruning caches'],
+ ['review-requests', 'when reviewing pull requests'],
+];
+
+function seedEight(root) {
+ for (const [id, trigger] of EIGHT_TRIGGERS) {
+ writeInstinct(root, id, trigger);
+ }
+}
+
+console.log('\n=== Testing instinct-cli.py evolve generation ===\n');
+
+test('generated command names are cut on a word boundary', () => {
+ const root = createTempDir();
+ try {
+ writeInstinct(root, 'archaeology', 'when investigating complex systems');
+ writeInstinct(root, 'codebases', 'when learning about complex codebases');
+ writeInstinct(root, 'large-text', 'when analyzing large text files');
+
+ const result = runCli(root, ['evolve', '--generate']);
+ assert.strictEqual(result.status, 0, result.stderr);
+
+ const names = generatedCommands(root);
+ // A hard slice used to yield investigating-comple.md and
+ // learning-about-compl.md, which read as typos.
+ assert.deepStrictEqual(names, [
+ 'analyzing-large-text.md',
+ 'investigating.md',
+ 'learning-about.md',
+ ]);
+ } finally {
+ cleanupDir(root);
+ }
+});
+
+test('a cut landing on a separator keeps the whole word', () => {
+ const root = createTempDir();
+ try {
+ writeInstinct(root, 'a', 'when analyzing large text files');
+ writeInstinct(root, 'b', 'when running tests');
+ writeInstinct(root, 'c', 'when building images');
+
+ assert.strictEqual(runCli(root, ['evolve', '--generate']).status, 0);
+ // "analyzing-large-text" is exactly the slug limit and ends on a word, so
+ // nothing further may be dropped.
+ assert.ok(generatedCommands(root).includes('analyzing-large-text.md'));
+ } finally {
+ cleanupDir(root);
+ }
+});
+
+test('every command candidate is generated, not just the first five', () => {
+ const root = createTempDir();
+ try {
+ seedEight(root);
+
+ const result = runCli(root, ['evolve', '--generate']);
+ assert.strictEqual(result.status, 0, result.stderr);
+ assert.strictEqual(
+ generatedCommands(root).length,
+ EIGHT_TRIGGERS.length,
+ 'a fixed cap silently dropped candidates'
+ );
+ } finally {
+ cleanupDir(root);
+ }
+});
+
+test('--limit caps generation and reports what it skipped', () => {
+ const root = createTempDir();
+ try {
+ seedEight(root);
+
+ const result = runCli(root, ['evolve', '--generate', '--limit', '3']);
+ assert.strictEqual(result.status, 0, result.stderr);
+ assert.strictEqual(generatedCommands(root).length, 3);
+ assert.match(result.stdout, /writing 3 of 8 command candidates/);
+ assert.match(result.stdout, /5 skipped/);
+ } finally {
+ cleanupDir(root);
+ }
+});
+
+test('colliding slugs produce distinct files instead of overwriting', () => {
+ const root = createTempDir();
+ try {
+ // Both triggers trim to "investigating".
+ writeInstinct(root, 'first', 'when investigating complex systems');
+ writeInstinct(root, 'second', 'when investigating extraordinarily convoluted pipelines');
+ writeInstinct(root, 'third', 'when running tests');
+
+ assert.strictEqual(runCli(root, ['evolve', '--generate']).status, 0);
+
+ const names = generatedCommands(root);
+ assert.ok(names.includes('investigating.md'), `missing base name in ${names}`);
+ assert.ok(names.includes('investigating-2.md'), `missing deduped name in ${names}`);
+ assert.strictEqual(new Set(names).size, names.length);
+ } finally {
+ cleanupDir(root);
+ }
+});
+
+test('preview states how many candidates it left out', () => {
+ const root = createTempDir();
+ try {
+ seedEight(root);
+
+ const result = runCli(root, ['evolve']);
+ assert.strictEqual(result.status, 0, result.stderr);
+ assert.match(result.stdout, /COMMAND CANDIDATES \(8\)/);
+ assert.match(result.stdout, /and 3 more command candidates not shown/);
+ } finally {
+ cleanupDir(root);
+ }
+});
+
+test('preview names match the files --generate writes', () => {
+ const root = createTempDir();
+ try {
+ writeInstinct(root, 'first', 'when investigating complex systems');
+ writeInstinct(root, 'second', 'when investigating extraordinarily convoluted pipelines');
+ writeInstinct(root, 'third', 'when running tests');
+
+ const preview = runCli(root, ['evolve']);
+ assert.strictEqual(preview.status, 0, preview.stderr);
+ assert.match(preview.stdout, /\/investigating\b/);
+ assert.match(preview.stdout, /\/investigating-2\b/);
+
+ assert.strictEqual(runCli(root, ['evolve', '--generate']).status, 0);
+ const names = generatedCommands(root);
+ assert.ok(names.includes('investigating.md'));
+ assert.ok(names.includes('investigating-2.md'));
+ } finally {
+ cleanupDir(root);
+ }
+});
+
+console.log(`\nPassed: ${passed}`);
+console.log(`Failed: ${failed}`);
+
+process.exit(failed > 0 ? 1 : 0);
diff --git a/tests/scripts/instinct-cli-evolve.test.js b/tests/scripts/instinct-cli-evolve.test.js
new file mode 100644
index 000000000..d7ca31df6
--- /dev/null
+++ b/tests/scripts/instinct-cli-evolve.test.js
@@ -0,0 +1,188 @@
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+let passed = 0;
+let failed = 0;
+
+const repoRoot = path.resolve(__dirname, '..', '..');
+const cliPath = path.join(
+ repoRoot,
+ 'skills',
+ 'continuous-learning-v2',
+ 'scripts',
+ 'instinct-cli.py'
+);
+
+function detectPython3() {
+ for (const bin of ['python3', 'python']) {
+ const r = spawnSync(bin, ['--version'], { encoding: 'utf8' });
+ if (r.status === 0 && /Python 3/.test(r.stdout + r.stderr)) return bin;
+ }
+ return null;
+}
+
+const PYTHON3 = detectPython3();
+if (!PYTHON3) {
+ console.log('\n=== Testing instinct-cli.py evolve clustering ===\n');
+ console.log(' - skipped: Python 3 not found in PATH');
+ console.log('\nPassed: 0');
+ console.log('Failed: 0');
+ process.exit(0);
+}
+
+function test(name, fn) {
+ try {
+ fn();
+ console.log(` ✓ ${name}`);
+ passed += 1;
+ } catch (error) {
+ console.log(` ✗ ${name}`);
+ console.log(` Error: ${error.message}`);
+ failed += 1;
+ }
+}
+
+function createTempDir() {
+ return fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-instinct-cli-evolve-'));
+}
+
+function cleanupDir(dir) {
+ fs.rmSync(dir, { recursive: true, force: true });
+}
+
+function writeInstinct(root, id, trigger, confidence = 0.8, domain = 'workflow') {
+ const filePath = path.join(root, 'instincts', 'personal', `${id}.yaml`);
+ fs.mkdirSync(path.dirname(filePath), { recursive: true });
+ fs.writeFileSync(
+ filePath,
+ [
+ '---',
+ `id: ${id}`,
+ `trigger: ${trigger}`,
+ `confidence: ${confidence}`,
+ `domain: ${domain}`,
+ 'scope: global',
+ '---',
+ '',
+ '## Action',
+ '',
+ `Action for ${id}.`,
+ '',
+ ].join('\n')
+ );
+}
+
+// cwd is the temp dir (not a git repo) so project detection falls back to
+// global scope and the fixture instincts are the only ones loaded.
+function runEvolve(root, args = []) {
+ return spawnSync(PYTHON3, [cliPath, 'evolve', ...args], {
+ cwd: root,
+ encoding: 'utf8',
+ env: {
+ ...process.env,
+ CLV2_HOMUNCULUS_DIR: root,
+ HOME: path.join(root, 'home'),
+ USERPROFILE: path.join(root, 'home'),
+ CLAUDE_PROJECT_DIR: '',
+ },
+ });
+}
+
+function clusterCount(stdout) {
+ const match = stdout.match(/Potential skill clusters found:\s*(\d+)/);
+ assert.ok(match, `cluster count missing from output:\n${stdout}`);
+ return Number(match[1]);
+}
+
+console.log('\n=== Testing instinct-cli.py evolve clustering ===\n');
+
+// evolve refuses to analyze fewer than 3 instincts, so each fixture adds a
+// filler whose trigger shares no keywords with the pair under test.
+const FILLER = ['filler-unrelated', 'when rotating expired signing certificates'];
+
+test('instincts with overlapping trigger keywords form one cluster', () => {
+ const root = createTempDir();
+ try {
+ writeInstinct(root, 'l10n-merge', 'when adding a language to the localization dictionary');
+ writeInstinct(root, 'l10n-verify', 'when verifying the localization dictionary for a language');
+ writeInstinct(root, ...FILLER);
+
+ const result = runEvolve(root);
+ assert.strictEqual(result.status, 0, result.stderr);
+ assert.strictEqual(clusterCount(result.stdout), 1);
+ } finally {
+ cleanupDir(root);
+ }
+});
+
+test('unrelated triggers do not cluster together', () => {
+ const root = createTempDir();
+ try {
+ writeInstinct(root, 'docker-build', 'when building container images for deployment');
+ writeInstinct(root, 'sql-index', 'when tuning slow database queries');
+ writeInstinct(root, ...FILLER);
+
+ const result = runEvolve(root);
+ assert.strictEqual(result.status, 0, result.stderr);
+ assert.strictEqual(clusterCount(result.stdout), 0);
+ } finally {
+ cleanupDir(root);
+ }
+});
+
+test('a single shared keyword is not enough to cluster', () => {
+ const root = createTempDir();
+ try {
+ writeInstinct(root, 'bash-archives', 'when sampling compressed archives with bash pipelines');
+ writeInstinct(root, 'bash-signing', 'when inspecting bash exit codes after failures');
+ writeInstinct(root, ...FILLER);
+
+ const result = runEvolve(root);
+ assert.strictEqual(result.status, 0, result.stderr);
+ assert.strictEqual(clusterCount(result.stdout), 0);
+ } finally {
+ cleanupDir(root);
+ }
+});
+
+test('preview command name matches the file --generate writes', () => {
+ const root = createTempDir();
+ try {
+ writeInstinct(root, 'reddit-scrape', 'when extracting data from Reddit pages');
+ writeInstinct(root, 'filler-one', 'when rotating expired signing certificates', 0.8, 'testing');
+ writeInstinct(root, 'filler-two', 'when pruning stale feature branches', 0.8, 'testing');
+
+ const preview = runEvolve(root);
+ assert.strictEqual(preview.status, 0, preview.stderr);
+
+ const match = preview.stdout.match(/^\s+\/(\S+)$/m);
+ assert.ok(match, `no command candidate in output:\n${preview.stdout}`);
+ const previewName = match[1];
+
+ // The old preview stripped every "a " occurrence, mangling "data from"
+ // into "datfrom" and advertising a name --generate never wrote.
+ assert.ok(
+ !previewName.includes('datfrom'),
+ `preview mangled the trigger: ${previewName}`
+ );
+
+ const generated = runEvolve(root, ['--generate']);
+ assert.strictEqual(generated.status, 0, generated.stderr);
+
+ const commandFile = path.join(root, 'evolved', 'commands', `${previewName}.md`);
+ assert.ok(
+ fs.existsSync(commandFile),
+ `expected ${commandFile}, got: ${fs.readdirSync(path.join(root, 'evolved', 'commands')).join(', ')}`
+ );
+ } finally {
+ cleanupDir(root);
+ }
+});
+
+console.log(`\nPassed: ${passed}`);
+console.log(`Failed: ${failed}`);
+
+process.exit(failed > 0 ? 1 : 0);