@phuetz/code-buddy 1.6.1 → 2.0.0

package/dist/agent/self-improvement/evolution/variant-fitness.js

@@ -0,0 +1,217 @@
+/**
+ * Variant fitness harness (Phase A of git-versioned evolutionary self-improvement).
+ *
+ * Computes a single numeric fitness in [0,1] for a CHECKOUT of Code Buddy (a directory — the main
+ * repo for the baseline, a git worktree for a candidate variant). Fitness is a weighted blend of
+ * independent COMPONENTS, each producing a 0..1 score + pass/fail:
+ *   - deterministic components (typecheck, targeted unit tests, capability benchmark) → a stable,
+ *     reproducible baseline;
+ *   - stochastic components (eval task pass-rate via `eval/run-task.mjs`, which spawn the real CLI
+ *     and make LLM calls) → opt-in, weighted, used when willing to pay.
+ *
+ * The aggregation + regression logic is pure and unit-tested; the real components shell out.
+ * NOTHING here merges or mutates the repo — it only SCORES a checkout. Keep/merge stays human-gated.
+ *
+ * @module agent/self-improvement/evolution/variant-fitness
+ */
+import { spawn } from 'child_process';
+import { existsSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
+function msg(e) {
+    return e instanceof Error ? e.message : String(e);
+}
+/** Run a subprocess in the checkout, capped output + timeout. Never throws (resolves with code). */
+export function runProc(cmd, args, ctx) {
+    return new Promise((resolve) => {
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        const MAX = 1_000_000;
+        let child;
+        try {
+            child = spawn(cmd, args, { cwd: ctx.checkoutDir, env: ctx.env ?? process.env });
+        }
+        catch (err) {
+            resolve({ code: 1, stdout: '', stderr: msg(err), timedOut: false });
+            return;
+        }
+        const timer = setTimeout(() => {
+            timedOut = true;
+            try {
+                child.kill('SIGTERM');
+                setTimeout(() => {
+                    try {
+                        child.kill('SIGKILL');
+                    }
+                    catch {
+                        /* already gone */
+                    }
+                }, 1000);
+            }
+            catch {
+                /* ignore */
+            }
+        }, ctx.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+        child.stdout?.on('data', (d) => {
+            if (stdout.length < MAX)
+                stdout += d.toString();
+        });
+        child.stderr?.on('data', (d) => {
+            if (stderr.length < MAX)
+                stderr += d.toString();
+        });
+        child.on('error', (err) => {
+            clearTimeout(timer);
+            resolve({ code: 1, stdout, stderr: stderr + msg(err), timedOut });
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            resolve({ code: code ?? 1, stdout, stderr, timedOut });
+        });
+    });
+}
+function lastLines(s, n = 8) {
+    return s.trim().split('\n').slice(-n).join('\n');
+}
+/** Parse vitest summary lines: "Tests  3 passed (3)" / "Tests  2 failed | 5 passed (7)". */
+export function parseVitestCounts(out) {
+    const passed = /(\d+)\s+passed/.exec(out);
+    const failed = /(\d+)\s+failed/.exec(out);
+    return { passed: passed ? Number(passed[1]) : 0, failed: failed ? Number(failed[1]) : 0 };
+}
+export function listEvalTasks(checkoutDir) {
+    const dir = join(checkoutDir, 'eval', 'tasks');
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir).filter((t) => {
+        try {
+            return statSync(join(dir, t)).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    });
+}
+// ---- Built-in components -------------------------------------------------------------------
+/** TypeScript typecheck: `tsc --noEmit`. Deterministic, the cheapest correctness signal. */
+export function typecheckComponent(weight = 3) {
+    return {
+        name: 'typecheck',
+        weight,
+        deterministic: true,
+        async run(ctx) {
+            const r = await runProc('npx', ['tsc', '--noEmit'], ctx);
+            const passed = r.code === 0 && !r.timedOut;
+            return {
+                name: 'typecheck',
+                weight,
+                score: passed ? 1 : 0,
+                passed,
+                detail: passed ? 'tsc --noEmit clean' : lastLines(r.stdout + r.stderr),
+            };
+        },
+    };
+}
+/**
+ * Score a vitest run. ZERO collected tests is NOT evidence of correctness —
+ * it is the signature of a neutered harness (config excluded them, wrong cwd,
+ * `passWithNoTests`). The old `total===0 ? (code===0 ? 1 : 0)` rewarded exactly
+ * that gaming vector with a perfect score; zero tests now scores 0, never a pass.
+ * Pure + exported so the anti-gaming rule is testable without spawning vitest.
+ */
+export function scoreVitestRun(passed, failed, code, timedOut) {
+    const total = passed + failed;
+    return {
+        score: total > 0 ? passed / total : 0,
+        passed: total > 0 && failed === 0 && code === 0 && !timedOut,
+    };
+}
+/** Targeted unit tests: `vitest run <patterns>`. Deterministic; score = passed/(passed+failed). */
+export function unitTestsComponent(patterns, weight = 4) {
+    return {
+        name: 'unit-tests',
+        weight,
+        deterministic: true,
+        async run(ctx) {
+            const r = await runProc('npx', ['vitest', 'run', ...patterns], ctx);
+            const { passed, failed } = parseVitestCounts(r.stdout + r.stderr);
+            const total = passed + failed;
+            const { score, passed: passedFlag } = scoreVitestRun(passed, failed, r.code, r.timedOut);
+            return {
+                name: 'unit-tests',
+                weight,
+                score,
+                passed: passedFlag,
+                detail: total > 0 ? `${passed} passed / ${failed} failed` : `no tests collected — ${lastLines(r.stdout + r.stderr, 4)}`,
+                metrics: { passed, failed },
+            };
+        },
+    };
+}
+/**
+ * Whole-agent eval task pass-rate via `eval/run-task.mjs` (spawns the real CLI per task).
+ * STOCHASTIC (LLM calls) — opt-in. Requires the checkout to be built (dist/index.js).
+ */
+export function evalTasksComponent(tasks, weight = 5) {
+    return {
+        name: 'eval-tasks',
+        weight,
+        deterministic: false,
+        async run(ctx) {
+            const all = tasks ?? listEvalTasks(ctx.checkoutDir);
+            if (all.length === 0) {
+                return { name: 'eval-tasks', weight, score: 0, passed: false, detail: 'no eval tasks found' };
+            }
+            let pass = 0;
+            for (const t of all) {
+                const r = await runProc(process.execPath, ['eval/run-task.mjs', t], ctx);
+                if (r.code === 0 && !r.timedOut)
+                    pass++;
+            }
+            return {
+                name: 'eval-tasks',
+                weight,
+                score: pass / all.length,
+                passed: pass === all.length,
+                detail: `${pass}/${all.length} eval tasks passed`,
+                metrics: { passed: pass, total: all.length },
+            };
+        },
+    };
+}
+/** Default deterministic set → a fast, reproducible baseline (no LLM, no build). */
+export function defaultDeterministicComponents() {
+    return [typecheckComponent(), unitTestsComponent(['tests/agent/self-improvement'])];
+}
+// ---- Aggregation (pure, unit-tested) ------------------------------------------------------
+export function detectRegressions(baseline, current, eps = 1e-9) {
+    const byName = new Map(baseline.components.map((c) => [c.name, c]));
+    const out = [];
+    for (const r of current) {
+        const b = byName.get(r.name);
+        if (!b)
+            continue;
+        if (r.score < b.score - eps || (b.passed && !r.passed))
+            out.push(r.name);
+    }
+    return out;
+}
+/** Run components, aggregate to a weighted [0,1] fitness, flag regressions vs an optional baseline. */
+export async function computeFitness(ctx, components, baseline) {
+    const results = [];
+    for (const c of components) {
+        try {
+            results.push(await c.run(ctx));
+        }
+        catch (err) {
+            results.push({ name: c.name, weight: c.weight, score: 0, passed: false, detail: `error: ${msg(err)}` });
+        }
+    }
+    const totalWeight = results.reduce((s, r) => s + r.weight, 0) || 1;
+    const score = results.reduce((s, r) => s + r.weight * r.score, 0) / totalWeight;
+    const passedAll = results.length > 0 && results.every((r) => r.passed);
+    const regressions = baseline ? detectRegressions(baseline, results) : [];
+    return { score, passedAll, components: results, regressions };
+}
+//# sourceMappingURL=variant-fitness.js.map

package/dist/agent/self-improvement/evolution/variant-planner.d.ts

@@ -0,0 +1,41 @@
+import type { Weakness, Inspiration } from './evolution-engine.js';
+export interface VariantPlanStep {
+    title: string;
+    description: string;
+    rationale?: string;
+}
+export interface VariantPlan {
+    /** build-on: extend the best elite; diverge: deliberately different angle; fresh: from baseline. */
+    approach: 'build-on' | 'diverge' | 'fresh';
+    /** For build-on/diverge: the elite variant id this plan reacts to. */
+    basedOn?: string;
+    summary: string;
+    steps: VariantPlanStep[];
+}
+/** A chat call reduced to text-in/text-out; injected so the planner is testable + provider-agnostic. */
+export type PlanChat = (prompt: string) => Promise<string | null>;
+/** Grounds the plan in the collective knowledge graph: query → relevant knowledge snippets. Injected. */
+export type PlanRecall = (query: string) => Promise<string[]>;
+export type VariantPlanner = (args: {
+    weakness: Weakness;
+    inspirations: Inspiration[];
+}) => Promise<VariantPlan | null>;
+/** Goal-oriented planning prompt (borrows PlanningFlow's decompose framing, evolution-specific).
+ *  `knowledge` grounds the plan in the collective knowledge graph (ingested research + lessons). */
+export declare function buildPlanningPrompt(weakness: Weakness, inspirations: Inspiration[], knowledge?: string[]): string;
+/** Parse the model's JSON plan; markdown-fence tolerant, with a safe single-step fallback. */
+export declare function parseVariantPlan(text: string): VariantPlan;
+/** Render a plan to readable text — used both to drive the mutator and to store on the record. */
+export declare function renderVariantPlan(plan: VariantPlan): string;
+/** Build a plan from an injected chat call, grounded in the CKG via an optional recall. Never-throws → null. */
+export declare function planVariant(args: {
+    weakness: Weakness;
+    inspirations: Inspiration[];
+}, chat: PlanChat, recall?: PlanRecall): Promise<VariantPlan | null>;
+/** The default variant planner: plans in-process via the env provider, grounded in the CKG.
+ *  Inject `chat`/`recall` for tests. Set `recall: null` to disable grounding. */
+export declare function makeLlmVariantPlanner(opts?: {
+    model?: string;
+    chat?: PlanChat;
+    recall?: PlanRecall | null;
+}): VariantPlanner;

package/dist/agent/self-improvement/evolution/variant-planner.js

@@ -0,0 +1,156 @@
+/**
+ * Variant planner — the deliberate PLANNING step that decides how the next generation of Code Buddy
+ * is created, before the mutator touches any code.
+ *
+ * Today `agentMutator` just concatenates the goal + inspiration diffs into a raw prompt; that raw
+ * string was what got stored as the variant's "plan". This turns planning into a real step: given a
+ * weakness + the prior elite variants, an LLM decides the APPROACH (build on the best elite, diverge,
+ * or start fresh) and emits a rich, titled, rationalized step list. That plan then (a) drives the
+ * mutator (the headless agent executes it) and (b) is stored on the VariantRecord for audit.
+ *
+ * Pure + deterministic-testable: prompt build, parse (with markdown-fence strip + single-step
+ * fallback), and rendering are pure; the LLM call is an injected `chat` (so tests drive it without a
+ * provider, and the engine keeps its dependency-injection contract). Never-throws → null falls back
+ * to the engine's legacy ad-hoc prompt (zero regression when no provider is configured).
+ *
+ * @module agent/self-improvement/evolution/variant-planner
+ */
+import { logger } from '../../../utils/logger.js';
+const MAX_INSPIRATION_DIFF = 2500;
+/** Goal-oriented planning prompt (borrows PlanningFlow's decompose framing, evolution-specific).
+ *  `knowledge` grounds the plan in the collective knowledge graph (ingested research + lessons). */
+export function buildPlanningPrompt(weakness, inspirations, knowledge = []) {
+    const elites = inspirations.length === 0
+        ? '(aucune version antérieure — tu pars du baseline)'
+        : inspirations
+            .map((i) => {
+            const diff = (i.diff ?? '').slice(0, MAX_INSPIRATION_DIFF);
+            return `- id=${i.id} (fitness ${i.score.toFixed(3)}) — ${i.goal}\n${diff ? `  diff:\n${diff}` : '  (diff indisponible)'}`;
+        })
+            .join('\n');
+    const lines = [
+        "Tu planifies la PROCHAINE version du code source de Code Buddy pour progresser sur un objectif.",
+        'Décide une APPROCHE et un plan CONCRET et court. Ne modifie PAS les tests, benchmarks, gates ou le harnais d\'éval.',
+        '',
+        `Objectif (${weakness.kind}) : ${weakness.goal}`,
+        '',
+        'Versions antérieures les mieux notées (bâtis sur la meilleure OU diverge délibérément — ne copie pas bêtement) :',
+        elites,
+    ];
+    const grounding = knowledge.map((k) => `- ${k.replace(/\s+/g, ' ').trim().slice(0, 400)}`).filter((l) => l.length > 2);
+    if (grounding.length > 0) {
+        lines.push('', 'Connaissances de recherche pertinentes (mémoire collective — appuie-toi dessus quand c\'est pertinent) :', ...grounding);
+    }
+    lines.push('', 'Réponds STRICTEMENT en JSON, rien d\'autre :', '{"approach":"build-on|diverge|fresh","basedOn":"<id élite ou omis>","summary":"<1 phrase>",' +
+        '"steps":[{"title":"<court>","description":"<quoi faire>","rationale":"<pourquoi>"}]}');
+    return lines.join('\n');
+}
+function stripFences(text) {
+    return text
+        .replace(/^\s*```(?:json)?\s*/i, '')
+        .replace(/\s*```\s*$/i, '')
+        .trim();
+}
+const APPROACHES = new Set(['build-on', 'diverge', 'fresh']);
+/** Parse the model's JSON plan; markdown-fence tolerant, with a safe single-step fallback. */
+export function parseVariantPlan(text) {
+    const fallback = {
+        approach: 'fresh',
+        summary: (text ?? '').replace(/\s+/g, ' ').trim().slice(0, 200) || 'Plan indisponible',
+        steps: [{ title: 'Améliorer', description: (text ?? '').trim().slice(0, 500) || 'Appliquer une petite amélioration correcte.' }],
+    };
+    try {
+        const match = stripFences(text).match(/\{[\s\S]*\}/);
+        if (!match)
+            return fallback;
+        const raw = JSON.parse(match[0]);
+        const steps = Array.isArray(raw.steps)
+            ? raw.steps
+                .filter((s) => !!s && typeof s.title === 'string' && typeof s.description === 'string')
+                .map((s) => ({ title: s.title.trim(), description: s.description.trim(), ...(s.rationale ? { rationale: String(s.rationale).trim() } : {}) }))
+            : [];
+        if (steps.length === 0)
+            return fallback;
+        return {
+            approach: APPROACHES.has(raw.approach) ? raw.approach : 'fresh',
+            ...(typeof raw.basedOn === 'string' && raw.basedOn.trim() ? { basedOn: raw.basedOn.trim() } : {}),
+            summary: (typeof raw.summary === 'string' && raw.summary.trim()) || steps[0].title,
+            steps,
+        };
+    }
+    catch {
+        return fallback;
+    }
+}
+/** Render a plan to readable text — used both to drive the mutator and to store on the record. */
+export function renderVariantPlan(plan) {
+    const head = `Approche : ${plan.approach}${plan.basedOn ? ` (à partir de ${plan.basedOn})` : ''}\nRésumé : ${plan.summary}`;
+    const steps = plan.steps
+        .map((s, i) => `${i + 1}. ${s.title} — ${s.description}${s.rationale ? `\n   (pourquoi : ${s.rationale})` : ''}`)
+        .join('\n');
+    return `${head}\nÉtapes :\n${steps}`;
+}
+/** Build a plan from an injected chat call, grounded in the CKG via an optional recall. Never-throws → null. */
+export async function planVariant(args, chat, recall) {
+    try {
+        let knowledge = [];
+        if (recall) {
+            try {
+                knowledge = await recall(args.weakness.goal);
+            }
+            catch {
+                knowledge = []; // grounding is best-effort — a CKG hiccup must not block planning
+            }
+        }
+        const text = await chat(buildPlanningPrompt(args.weakness, args.inspirations, knowledge));
+        if (!text || !text.trim())
+            return null;
+        return parseVariantPlan(text);
+    }
+    catch (err) {
+        logger.debug(`[evolve] variant planning failed → falling back: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
+/** Default in-process chat: provider from env → CodeBuddyClient (mirrors llm-drafter). null if none. */
+function makeDefaultChat(model) {
+    return async (prompt) => {
+        try {
+            const { detectProviderFromEnv } = await import('../../../utils/provider-detector.js');
+            const { CodeBuddyClient } = await import('../../../codebuddy/client.js');
+            const detected = detectProviderFromEnv();
+            if (!detected)
+                return null;
+            const client = new CodeBuddyClient(detected.apiKey, model ?? detected.defaultModel, detected.baseURL);
+            const resp = await client.chat([
+                { role: 'system', content: 'Tu es un planificateur d\'amélioration de code. Réponds uniquement en JSON.' },
+                { role: 'user', content: prompt },
+            ], []);
+            return resp?.choices?.[0]?.message?.content ?? null;
+        }
+        catch {
+            return null;
+        }
+    };
+}
+/** Default CKG grounding: hybrid recall of relevant discoveries/lessons (mirrors llm-drafter). []-safe. */
+function makeDefaultRecall() {
+    return async (query) => {
+        try {
+            const { getCollectiveKnowledgeGraph } = await import('../../../memory/collective-knowledge-graph.js');
+            const hits = await getCollectiveKnowledgeGraph().recallHybrid(query, { limit: 4 });
+            return hits.map((h) => h.text).filter(Boolean);
+        }
+        catch {
+            return [];
+        }
+    };
+}
+/** The default variant planner: plans in-process via the env provider, grounded in the CKG.
+ *  Inject `chat`/`recall` for tests. Set `recall: null` to disable grounding. */
+export function makeLlmVariantPlanner(opts = {}) {
+    const chat = opts.chat ?? makeDefaultChat(opts.model);
+    const recall = opts.recall === null ? undefined : (opts.recall ?? makeDefaultRecall());
+    return (args) => planVariant(args, chat, recall);
+}
+//# sourceMappingURL=variant-planner.js.map

package/dist/agent/self-improvement/evolution/weakness-selector.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Weakness selection — the front of the loop: decide WHAT to improve, automatically. Closes
+ * "find a weakness → mutate toward it → evaluate → propose". Two sources:
+ *   - failing eval tasks (the agent currently can't do task X) — crisp but LLM-costly to detect;
+ *   - self-model hotspots (Code Explorer graph of Code Buddy's own repo) — cheap, no LLM.
+ *
+ * The mappers (hotspots/failures → Weakness) are pure + unit-tested; the fetchers are best-effort
+ * (return [] when Code Explorer / a provider key is absent) and injectable for tests.
+ *
+ * @module agent/self-improvement/evolution/weakness-selector
+ */
+import type { Weakness } from './evolution-engine.js';
+export interface HotspotInfo {
+    file: string;
+    score?: number;
+    reason?: string;
+}
+/** Pure: hotspots → weaknesses (refactor a hot/complex region without changing behavior). */
+export declare function hotspotsToWeaknesses(hotspots: HotspotInfo[], limit?: number): Weakness[];
+/** Pure: failing eval task ids → weaknesses (fix the underlying agent behavior, not the test). */
+export declare function evalFailuresToWeaknesses(failedTasks: string[], limit?: number): Weakness[];
+export type HotspotFetcher = (basePath: string) => Promise<HotspotInfo[]>;
+export type EvalFailureDetector = (basePath: string, env?: NodeJS.ProcessEnv) => Promise<string[]>;
+export interface SelectWeaknessOptions {
+    basePath?: string;
+    limit?: number;
+    includeEvalFailures?: boolean;
+    includeHotspots?: boolean;
+    /** Research-driven, article-grounded goals (matched to Code Buddy features). Opt-in. */
+    includeResearch?: boolean;
+    fetchHotspots?: HotspotFetcher;
+    detectEvalFailures?: EvalFailureDetector;
+    /** Injectable research source (default: fetchResearchGoals over the CKG). */
+    fetchResearchGoals?: () => Promise<Weakness[]>;
+    env?: NodeJS.ProcessEnv;
+}
+/** Gather weaknesses from the enabled sources, dedup, cap at `limit`. */
+export declare function selectWeaknesses(opts?: SelectWeaknessOptions): Promise<Weakness[]>;

package/dist/agent/self-improvement/evolution/weakness-selector.js

@@ -0,0 +1,108 @@
+/**
+ * Weakness selection — the front of the loop: decide WHAT to improve, automatically. Closes
+ * "find a weakness → mutate toward it → evaluate → propose". Two sources:
+ *   - failing eval tasks (the agent currently can't do task X) — crisp but LLM-costly to detect;
+ *   - self-model hotspots (Code Explorer graph of Code Buddy's own repo) — cheap, no LLM.
+ *
+ * The mappers (hotspots/failures → Weakness) are pure + unit-tested; the fetchers are best-effort
+ * (return [] when Code Explorer / a provider key is absent) and injectable for tests.
+ *
+ * @module agent/self-improvement/evolution/weakness-selector
+ */
+import { logger } from '../../../utils/logger.js';
+import { runProc, listEvalTasks } from './variant-fitness.js';
+/** Pure: hotspots → weaknesses (refactor a hot/complex region without changing behavior). */
+export function hotspotsToWeaknesses(hotspots, limit = 3) {
+    return hotspots
+        .filter((h) => h.file && h.file.trim().length > 0)
+        .slice(0, limit)
+        .map((h, i) => ({
+        id: `hotspot-${i + 1}`,
+        kind: 'hotspot',
+        goal: `Improve the hotspot ${h.file}${h.reason ? ` (${h.reason})` : ''}: reduce complexity/coupling WITHOUT changing behavior. All tests must stay green.`,
+    }));
+}
+/** Pure: failing eval task ids → weaknesses (fix the underlying agent behavior, not the test). */
+export function evalFailuresToWeaknesses(failedTasks, limit = 3) {
+    return failedTasks.slice(0, limit).map((t) => ({
+        id: `eval-${t}`,
+        kind: 'eval-failure',
+        goal: `Make the failing eval task "${t}" pass (see eval/tasks/${t}). Fix the underlying agent behavior — never the test/harness.`,
+    }));
+}
+/** Gather weaknesses from the enabled sources, dedup, cap at `limit`. */
+export async function selectWeaknesses(opts = {}) {
+    const basePath = opts.basePath ?? process.cwd();
+    const limit = opts.limit ?? 3;
+    const out = [];
+    if (opts.includeEvalFailures) {
+        const detect = opts.detectEvalFailures ?? defaultDetectEvalFailures;
+        try {
+            out.push(...evalFailuresToWeaknesses(await detect(basePath, opts.env), limit));
+        }
+        catch (err) {
+            logger.warn(`[evolve] eval-failure detection failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    if (opts.includeHotspots) {
+        const fetch = opts.fetchHotspots ?? defaultFetchHotspots;
+        try {
+            out.push(...hotspotsToWeaknesses(await fetch(basePath), limit));
+        }
+        catch (err) {
+            logger.warn(`[evolve] hotspot fetch failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    if (opts.includeResearch) {
+        const fetch = opts.fetchResearchGoals ?? defaultFetchResearchGoals(limit);
+        try {
+            out.push(...(await fetch()));
+        }
+        catch (err) {
+            logger.warn(`[evolve] research goal fetch failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    const seen = new Set();
+    return out.filter((w) => (seen.has(w.id) ? false : (seen.add(w.id), true))).slice(0, limit);
+}
+/** Default research source: article-grounded goals from the CKG (lazy import to avoid a cycle). */
+function defaultFetchResearchGoals(limit) {
+    return async () => {
+        const { fetchResearchGoals } = await import('./research-weakness-source.js');
+        return fetchResearchGoals({ limit });
+    };
+}
+/** Run each eval task; the ones that fail (non-zero exit) are current weaknesses. LLM-costly. */
+async function defaultDetectEvalFailures(basePath, env) {
+    const tasks = listEvalTasks(basePath);
+    const failed = [];
+    for (const t of tasks) {
+        const ctx = { checkoutDir: basePath, ...(env ? { env } : {}) };
+        const r = await runProc(process.execPath, ['eval/run-task.mjs', t], ctx);
+        if (r.code !== 0)
+            failed.push(t);
+    }
+    return failed;
+}
+function withTimeout(p, ms, fallback) {
+    return Promise.race([p, new Promise((resolve) => setTimeout(() => resolve(fallback), ms))]);
+}
+/** Best-effort: query Code Explorer hotspots of this repo. Returns [] if Code Explorer is absent
+ *  or slow (bounded by a timeout so --auto never hangs on MCP bootstrap). */
+async function defaultFetchHotspots(_basePath) {
+    try {
+        const { fetchCodeExplorerInsights } = await import('../../../research/code-explorer-source.js');
+        const pubs = await withTimeout(fetchCodeExplorerInsights({ ops: ['hotspots'] }), 30_000, []);
+        const fileRe = /[\w./-]+\.(?:ts|tsx|js|mjs|rs|py)/;
+        return pubs.map((p) => {
+            const text = `${p.title ?? ''} ${p.abstract ?? ''}`;
+            const m = fileRe.exec(text);
+            return { file: m ? m[0] : '', reason: (p.title ?? '').slice(0, 80) };
+        });
+    }
+    catch (err) {
+        logger.debug(`[evolve] Code Explorer hotspots unavailable: ${err instanceof Error ? err.message : String(err)}`);
+        return [];
+    }
+}
+//# sourceMappingURL=weakness-selector.js.map

package/dist/agent/self-improvement/evolution/worktree-scorer.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Worktree scorer (Phase B): materialize a git BRANCH in an isolated worktree, score it with the
+ * variant-fitness harness, then tear the worktree down. This is how a candidate variant is
+ * evaluated without touching the working tree or `main`.
+ *
+ * node_modules is symlinked from the base repo (git worktrees don't copy gitignored deps), which is
+ * correct as long as the variant didn't change dependencies (the common case; a deps change is a
+ * rare edge handled by a real install — flagged, not silently wrong). Disk is preflighted via the
+ * disk-guard. The worktree is always cleaned up (finally), the branch is kept as the artifact.
+ *
+ * @module agent/self-improvement/evolution/worktree-scorer
+ */
+import { type FitnessComponent, type FitnessReport } from './variant-fitness.js';
+export interface ScoreBranchOptions {
+    /** Repo root that owns the worktree. Default: process.cwd(). */
+    basePath?: string;
+    components?: FitnessComponent[];
+    /** Baseline report to flag regressions against. */
+    baseline?: FitnessReport;
+    timeoutMs?: number;
+    /** Env for the fitness subprocesses. If unset, a SCRUBBED env (no secrets) is used by default. */
+    env?: NodeJS.ProcessEnv;
+    /** Symlink node_modules from base into the worktree (default true). */
+    linkNodeModules?: boolean;
+    /**
+     * Baseline ref (e.g. 'main'). When set: a branch that touches a PROTECTED path is rejected
+     * unscored (anti-self-weakening), and protected paths are reset to this ref in the worktree
+     * before scoring (defense-in-depth).
+     */
+    baselineRef?: string;
+    /** Use a secret-scrubbed env by default (true). Set false (or pass env) when eval-tasks need keys. */
+    scrubEnv?: boolean;
+}
+export interface ScoreBranchResult {
+    branch: string;
+    worktreePath: string;
+    report: FitnessReport;
+}
+/**
+ * Score a branch in an isolated worktree. The branch must NOT be the one currently checked out in
+ * `basePath` (git refuses to add a worktree for an already-checked-out branch). Never throws on
+ * cleanup; throws only if the worktree cannot be created.
+ */
+export declare function scoreBranchInWorktree(branch: string, opts?: ScoreBranchOptions): Promise<ScoreBranchResult>;