@phuetz/code-buddy 1.1.0 → 1.3.0

package/dist/agent/self-improvement/authored-artifact-gate.js

@@ -0,0 +1,42 @@
+/**
+ * Authored-artifact gate — the static (no-execution) safety scan applied to any
+ * code the agent authors for itself (tools or skill scripts) BEFORE it is run or
+ * registered. Blocking and ordered; the behavioural held-out scoring (which DOES
+ * run the code, sandboxed) lives in sandbox-scorer.ts and runs only after this.
+ *
+ * @module agent/self-improvement/authored-artifact-gate
+ */
+import { matchAllDangerousPatterns } from '../../security/dangerous-patterns.js';
+/** Omission placeholders that signal truncated / non-self-contained code. */
+const OMISSION_RE = /\/\/\s*\.\.\.\s*(rest|remaining|other|more|implementation|code)\b|#\s*\.\.\.\s*(rest|remaining)\b/i;
+/** Obvious secret shapes — never let an authored artifact embed these. */
+const SECRET_RE = /(sk-[a-z0-9]{16,}|api[_-]?key\s*[:=]\s*['"]?\S{12,}|-----BEGIN [A-Z ]*PRIVATE KEY-----|ghp_[a-zA-Z0-9]{20,}|AKIA[0-9A-Z]{16})/i;
+/** Writing under src/ is the hard self-modification invariant — refuse it. */
+const SRC_WRITE_RE = /(writeFile|writeFileSync|appendFile\w*|fs\.\w*write|open\s*\([^)]*['"]w|>>?\s*['"]?\.{0,2}\/?src\/)/i;
+const MAX_CODE_BYTES = 64 * 1024;
+/**
+ * Statically inspect authored code. Returns ok=false with one or more reasons on
+ * any finding. `subsystem` selects the dangerous-pattern set ('code' for tools,
+ * 'skill' for skill scripts).
+ */
+export function inspectAuthoredCode(code, subsystem = 'code') {
+    const reasons = [];
+    const text = String(code ?? '');
+    if (!text.trim())
+        reasons.push('code is empty');
+    if (text.length > MAX_CODE_BYTES)
+        reasons.push(`code too large (${text.length} > ${MAX_CODE_BYTES} bytes)`);
+    const dangerous = matchAllDangerousPatterns(text, subsystem);
+    if (dangerous.length > 0) {
+        reasons.push(`matched ${dangerous.length} dangerous pattern(s): ${dangerous.map((d) => d.description).slice(0, 4).join('; ')}`);
+    }
+    if (SECRET_RE.test(text))
+        reasons.push('looks like it embeds a secret');
+    if (OMISSION_RE.test(text))
+        reasons.push('contains an omission placeholder (not self-contained)');
+    if (/src\//.test(text) && SRC_WRITE_RE.test(text)) {
+        reasons.push('writes under src/ (forbidden self-modification invariant)');
+    }
+    return { ok: reasons.length === 0, reasons };
+}
+//# sourceMappingURL=authored-artifact-gate.js.map

package/dist/agent/self-improvement/authored-tool-runtime.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Authored-tool runtime — shared by `register_tool` (the live capability) and the
+ * self-improvement engine's sandbox scorer (the gate). One definition of "how an
+ * authored tool runs" so the thing we GATE is exactly the thing we REGISTER.
+ *
+ * An authored tool runs its `code` SANDBOXED: a throwaway cwd, RPC off (no
+ * callback into the tool system), and its call arguments arrive as JSON in the
+ * CODEBUDDY_TOOL_INPUT env var; the script prints its result to stdout.
+ *
+ * @module agent/self-improvement/authored-tool-runtime
+ */
+import type { ITool } from '../../tools/registry/types.js';
+import { type ExecuteCodeLanguage } from '../../tools/execute-code-runner.js';
+export declare const AUTHORED_PREFIX = "authored__";
+export declare const AUTHORED_LANGUAGES: ExecuteCodeLanguage[];
+export interface AuthoredToolSpec {
+    /** Namespaced tool name (see toAuthoredName). */
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    language: ExecuteCodeLanguage;
+    code: string;
+}
+/** Namespace + sanitize a raw tool name to `authored__<slug>` (never shadows a built-in). */
+export declare function toAuthoredName(raw: string): string;
+/** Build an ITool that runs the authored `code` sandboxed when invoked. */
+export declare function buildAuthoredTool(spec: AuthoredToolSpec): ITool;

package/dist/agent/self-improvement/authored-tool-runtime.js

@@ -0,0 +1,57 @@
+/**
+ * Authored-tool runtime — shared by `register_tool` (the live capability) and the
+ * self-improvement engine's sandbox scorer (the gate). One definition of "how an
+ * authored tool runs" so the thing we GATE is exactly the thing we REGISTER.
+ *
+ * An authored tool runs its `code` SANDBOXED: a throwaway cwd, RPC off (no
+ * callback into the tool system), and its call arguments arrive as JSON in the
+ * CODEBUDDY_TOOL_INPUT env var; the script prints its result to stdout.
+ *
+ * @module agent/self-improvement/authored-tool-runtime
+ */
+import * as os from 'os';
+import * as path from 'path';
+import { randomUUID } from 'crypto';
+import { executeCode } from '../../tools/execute-code-runner.js';
+export const AUTHORED_PREFIX = 'authored__';
+export const AUTHORED_LANGUAGES = ['javascript', 'typescript', 'python'];
+/** Namespace + sanitize a raw tool name to `authored__<slug>` (never shadows a built-in). */
+export function toAuthoredName(raw) {
+    const base = String(raw)
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9_]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+    return base.startsWith(AUTHORED_PREFIX) ? base : `${AUTHORED_PREFIX}${base || 'tool'}`;
+}
+/** Build an ITool that runs the authored `code` sandboxed when invoked. */
+export function buildAuthoredTool(spec) {
+    const { name, description, parameters, language, code } = spec;
+    return {
+        name,
+        description,
+        async execute(input) {
+            const rootDir = path.join(os.tmpdir(), `cb-authored-${randomUUID()}`);
+            try {
+                const res = await executeCode({ code, language, env: { CODEBUDDY_TOOL_INPUT: JSON.stringify(input ?? {}) } }, { rootDir, rpcEnabled: false });
+                if (!res.ok) {
+                    return {
+                        success: false,
+                        error: `authored tool "${name}" failed (exit ${res.exitCode}): ${res.stderr.slice(0, 2000) || res.error || 'no output'}`,
+                    };
+                }
+                return { success: true, output: res.stdout.slice(0, 100_000) || '(no stdout)' };
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    error: `authored tool "${name}" error: ${err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+        },
+        getSchema() {
+            return { name, description, parameters: parameters };
+        },
+    };
+}
+//# sourceMappingURL=authored-tool-runtime.js.map

package/dist/agent/self-improvement/authored-tool-store.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Authored-tool store — durable persistence for tools the agent has authored and
+ * kept (auto-apply). Without this, authored tools live only for the session; with
+ * it, they are reloaded into both registries at startup so a self-improvement
+ * survives a restart. A flat JSON file alongside the evolutionary archive.
+ *
+ * @module agent/self-improvement/authored-tool-store
+ */
+import type { AuthoredToolSpec } from './authored-tool-runtime.js';
+export declare const AUTHORED_TOOL_STORE_SCHEMA_VERSION = 1;
+export interface AuthoredToolStoreOptions {
+    workDir?: string;
+}
+export declare class AuthoredToolStore {
+    private readonly filePath;
+    constructor(options?: AuthoredToolStoreOptions);
+    get path(): string;
+    private read;
+    private write;
+    list(): AuthoredToolSpec[];
+    /** Upsert a spec by name (a re-authored tool replaces the prior version). */
+    add(spec: AuthoredToolSpec): void;
+    remove(name: string): boolean;
+}

package/dist/agent/self-improvement/authored-tool-store.js

@@ -0,0 +1,57 @@
+/**
+ * Authored-tool store — durable persistence for tools the agent has authored and
+ * kept (auto-apply). Without this, authored tools live only for the session; with
+ * it, they are reloaded into both registries at startup so a self-improvement
+ * survives a restart. A flat JSON file alongside the evolutionary archive.
+ *
+ * @module agent/self-improvement/authored-tool-store
+ */
+import fs from 'fs';
+import path from 'path';
+export const AUTHORED_TOOL_STORE_SCHEMA_VERSION = 1;
+export class AuthoredToolStore {
+    filePath;
+    constructor(options = {}) {
+        const root = options.workDir ?? process.cwd();
+        this.filePath = path.join(root, '.codebuddy', 'self-improvement', 'authored-tools.json');
+    }
+    get path() {
+        return this.filePath;
+    }
+    read() {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(this.filePath, 'utf-8'));
+            if (Array.isArray(parsed.tools)) {
+                return { schemaVersion: AUTHORED_TOOL_STORE_SCHEMA_VERSION, tools: parsed.tools };
+            }
+        }
+        catch {
+            /* no store yet */
+        }
+        return { schemaVersion: AUTHORED_TOOL_STORE_SCHEMA_VERSION, tools: [] };
+    }
+    write(file) {
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+        fs.writeFileSync(this.filePath, JSON.stringify(file, null, 2), 'utf-8');
+    }
+    list() {
+        return this.read().tools;
+    }
+    /** Upsert a spec by name (a re-authored tool replaces the prior version). */
+    add(spec) {
+        const file = this.read();
+        file.tools = file.tools.filter((t) => t.name !== spec.name);
+        file.tools.push(spec);
+        this.write(file);
+    }
+    remove(name) {
+        const file = this.read();
+        const before = file.tools.length;
+        file.tools = file.tools.filter((t) => t.name !== name);
+        if (file.tools.length === before)
+            return false;
+        this.write(file);
+        return true;
+    }
+}
+//# sourceMappingURL=authored-tool-store.js.map

package/dist/agent/self-improvement/llm-tool-proposer.d.ts

@@ -0,0 +1,41 @@
+/**
+ * LLM tool proposer — authors a candidate tool with the agent's own model from a
+ * REDACTED scenario view (capability + visible cases only; never the held-out
+ * cases). The behavioural held-out gate validates every draft, so even a gamed or
+ * broken draft is caught — the LLM is a generator, not a trusted oracle.
+ *
+ * Lazy + graceful: if no provider is configured the proposer declines (null) and
+ * the engine simply finds no proposal.
+ *
+ * @module agent/self-improvement/llm-tool-proposer
+ */
+import { type AuthoredToolSpec } from './authored-tool-runtime.js';
+import type { ProposerScenarioView, ToolProposer } from './tool-proposer.js';
+import type { ToolProposal } from './tool-types.js';
+interface MinimalClient {
+    chat(messages: Array<{
+        role: string;
+        content: string;
+    }>, tools?: unknown[]): Promise<{
+        choices?: Array<{
+            message?: {
+                content?: string | null;
+            };
+        }>;
+    }>;
+}
+export declare function buildToolDraftPrompt(view: ProposerScenarioView): string;
+/** Parse + validate a model draft into an AuthoredToolSpec, or null. */
+export declare function parseToolDraft(text: string): AuthoredToolSpec | null;
+export interface LlmToolProposerOptions {
+    /** Override the chat client (tests). Defaults to provider-detected CodeBuddyClient. */
+    client?: MinimalClient | null;
+}
+export declare class LlmToolProposer implements ToolProposer {
+    private readonly options;
+    private clientPromise;
+    constructor(options?: LlmToolProposerOptions);
+    private getClient;
+    propose(view: ProposerScenarioView): Promise<ToolProposal | null>;
+}
+export {};

package/dist/agent/self-improvement/llm-tool-proposer.js

@@ -0,0 +1,136 @@
+/**
+ * LLM tool proposer — authors a candidate tool with the agent's own model from a
+ * REDACTED scenario view (capability + visible cases only; never the held-out
+ * cases). The behavioural held-out gate validates every draft, so even a gamed or
+ * broken draft is caught — the LLM is a generator, not a trusted oracle.
+ *
+ * Lazy + graceful: if no provider is configured the proposer declines (null) and
+ * the engine simply finds no proposal.
+ *
+ * @module agent/self-improvement/llm-tool-proposer
+ */
+import { AUTHORED_LANGUAGES, toAuthoredName } from './authored-tool-runtime.js';
+export function buildToolDraftPrompt(view) {
+    const examples = view.visibleCases
+        .map((c, i) => `  ${i + 1}. input ${JSON.stringify(c.input)} → output must contain ${JSON.stringify(c.expectIncludes)}`)
+        .join('\n');
+    return [
+        `Author a small, self-contained tool for this capability:`,
+        `  ${view.capability}`,
+        ``,
+        `Example behaviour (these are ONLY examples — the tool must GENERALIZE to any valid input;`,
+        `do NOT hardcode these outputs, that will be rejected by a held-out check):`,
+        examples,
+        ``,
+        `The tool runs as a standalone script: it reads its arguments as JSON from the`,
+        `environment variable CODEBUDDY_TOOL_INPUT and prints ONLY its result to stdout.`,
+        `It must not touch the network or the filesystem.`,
+        ``,
+        `Return ONLY a JSON object (no prose, no code fence) with exactly these fields:`,
+        `{"name": "<short_snake_case>", "description": "<one line>",`,
+        ` "params": <JSON Schema for the input object>,`,
+        ` "language": "javascript" | "python",`,
+        ` "code": "<the full script source>"}`,
+    ].join('\n');
+}
+/** Extract the first balanced top-level JSON object from a model response. */
+function extractJsonObject(text) {
+    const start = text.indexOf('{');
+    if (start < 0)
+        return null;
+    let depth = 0;
+    let inStr = false;
+    let esc = false;
+    for (let i = start; i < text.length; i++) {
+        const ch = text[i];
+        if (inStr) {
+            if (esc)
+                esc = false;
+            else if (ch === '\\')
+                esc = true;
+            else if (ch === '"')
+                inStr = false;
+        }
+        else if (ch === '"')
+            inStr = true;
+        else if (ch === '{')
+            depth++;
+        else if (ch === '}') {
+            depth--;
+            if (depth === 0)
+                return text.slice(start, i + 1);
+        }
+    }
+    return null;
+}
+/** Parse + validate a model draft into an AuthoredToolSpec, or null. */
+export function parseToolDraft(text) {
+    const json = extractJsonObject(text);
+    if (!json)
+        return null;
+    let raw;
+    try {
+        raw = JSON.parse(json);
+    }
+    catch {
+        return null;
+    }
+    const name = String(raw.name ?? '').trim();
+    const description = String(raw.description ?? '').trim();
+    const code = typeof raw.code === 'string' ? raw.code : '';
+    const language = String(raw.language ?? 'javascript').toLowerCase();
+    if (!name || !description || !code.trim())
+        return null;
+    if (!AUTHORED_LANGUAGES.includes(language))
+        return null;
+    const parameters = raw.params && typeof raw.params === 'object'
+        ? raw.params
+        : { type: 'object', properties: {} };
+    return { name: toAuthoredName(name), description, parameters, language, code };
+}
+export class LlmToolProposer {
+    options;
+    clientPromise;
+    constructor(options = {}) {
+        this.options = options;
+        this.clientPromise = options.client !== undefined ? Promise.resolve(options.client) : null;
+    }
+    getClient() {
+        if (!this.clientPromise) {
+            this.clientPromise = (async () => {
+                try {
+                    const { detectProviderFromEnv } = await import('../../utils/provider-detector.js');
+                    const { CodeBuddyClient } = await import('../../codebuddy/client.js');
+                    const detected = detectProviderFromEnv();
+                    if (!detected)
+                        return null;
+                    return new CodeBuddyClient(detected.apiKey, detected.defaultModel, detected.baseURL);
+                }
+                catch {
+                    return null;
+                }
+            })();
+        }
+        return this.clientPromise;
+    }
+    async propose(view) {
+        const client = await this.getClient();
+        if (!client)
+            return null;
+        try {
+            const prompt = buildToolDraftPrompt(view);
+            const response = await client.chat([{ role: 'user', content: prompt }], []);
+            const text = response?.choices?.[0]?.message?.content?.trim();
+            if (!text)
+                return null;
+            const spec = parseToolDraft(text);
+            if (!spec)
+                return null;
+            return { id: `llm-tool:${view.id}`, targetScenarioId: view.id, spec };
+        }
+        catch {
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=llm-tool-proposer.js.map

package/dist/agent/self-improvement/sandbox-scorer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Sandbox scorer — behavioural scoring of an authored tool. Builds the tool and
+ * RUNS it (sandboxed, via authored-tool-runtime: throwaway cwd, RPC off) on a set
+ * of cases, asserting the output. The tool is NOT registered to score it, so a
+ * rejected proposal leaves both registries untouched (no rollback needed).
+ *
+ * @module agent/self-improvement/sandbox-scorer
+ */
+import { type AuthoredToolSpec } from './authored-tool-runtime.js';
+import type { ToolCase } from './tool-types.js';
+export interface ToolScore {
+    passed: number;
+    total: number;
+    failures: string[];
+}
+/** Run the authored tool over `cases`; a case passes if its output contains all expectIncludes. */
+export declare function scoreToolCases(spec: AuthoredToolSpec, cases: ToolCase[]): Promise<ToolScore>;

package/dist/agent/self-improvement/sandbox-scorer.js

@@ -0,0 +1,43 @@
+/**
+ * Sandbox scorer — behavioural scoring of an authored tool. Builds the tool and
+ * RUNS it (sandboxed, via authored-tool-runtime: throwaway cwd, RPC off) on a set
+ * of cases, asserting the output. The tool is NOT registered to score it, so a
+ * rejected proposal leaves both registries untouched (no rollback needed).
+ *
+ * @module agent/self-improvement/sandbox-scorer
+ */
+import { buildAuthoredTool } from './authored-tool-runtime.js';
+/** Run the authored tool over `cases`; a case passes if its output contains all expectIncludes. */
+export async function scoreToolCases(spec, cases) {
+    const tool = buildAuthoredTool(spec);
+    const failures = [];
+    let passed = 0;
+    for (let i = 0; i < cases.length; i++) {
+        const c = cases[i];
+        let output = '';
+        let ok = true;
+        try {
+            const res = await tool.execute(c.input);
+            output = `${res.output ?? ''}`;
+            if (!res.success) {
+                ok = false;
+                failures.push(`case ${i}: tool errored (${(res.error ?? '').slice(0, 120)})`);
+            }
+        }
+        catch (err) {
+            ok = false;
+            failures.push(`case ${i}: threw (${err instanceof Error ? err.message : String(err)})`);
+        }
+        if (ok) {
+            const missing = c.expectIncludes.filter((s) => !output.includes(s));
+            if (missing.length > 0) {
+                failures.push(`case ${i}: output missing ${JSON.stringify(missing)} (got ${JSON.stringify(output.slice(0, 80))})`);
+            }
+            else {
+                passed++;
+            }
+        }
+    }
+    return { passed, total: cases.length, failures };
+}
+//# sourceMappingURL=sandbox-scorer.js.map

package/dist/agent/self-improvement/self-knowledge.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Self-knowledge — the prompt block that makes Code Buddy aware it can extend
+ * and improve itself, and the hard limits on doing so.
+ *
+ * Injected (gated) by the prompt builder when `CODEBUDDY_SELF_IMPROVE=true`.
+ * Kept tiny and stable so it doesn't disturb prompt-cache stability.
+ */
+export declare function buildSelfKnowledgeBlock(): string;

package/dist/agent/self-improvement/self-knowledge.js

@@ -0,0 +1,24 @@
+/**
+ * Self-knowledge — the prompt block that makes Code Buddy aware it can extend
+ * and improve itself, and the hard limits on doing so.
+ *
+ * Injected (gated) by the prompt builder when `CODEBUDDY_SELF_IMPROVE=true`.
+ * Kept tiny and stable so it doesn't disturb prompt-cache stability.
+ */
+export function buildSelfKnowledgeBlock() {
+    return [
+        'You are Code Buddy — a coding agent that can extend and improve itself.',
+        '',
+        '- You can author a NEW tool for yourself with `register_tool` (name, description,',
+        '  params, language, code). Once registered it is namespaced `authored__<name>` and',
+        '  becomes callable by you on your next turn — the code you build can call your own tools.',
+        '- You can author/edit skills with `skill_manage`.',
+        '- Self-extensions are gated for safety: authored code is scanned for secrets and',
+        '  dangerous patterns, runs sandboxed, and is kept only if it measurably helps.',
+        '- HARD LIMIT: you may NOT modify your own source under `src/`. That invariant',
+        '  exists so an improvement can never weaken the gates that validate it.',
+        '- When a task would benefit from a reusable capability you do not yet have,',
+        '  consider authoring a small, well-scoped tool for it, then call it.',
+    ].join('\n');
+}
+//# sourceMappingURL=self-knowledge.js.map

package/dist/agent/self-improvement/skill-benchmark.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Seed coverage benchmark for self-authored SKILLS. Each scenario is a situation
+ * the agent should have reusable guidance for; an authored skill "covers" it when
+ * its content surfaces the expected terms. Curated separately from any proposer.
+ *
+ * @module agent/self-improvement/skill-benchmark
+ */
+import type { SkillBenchmarkScenario } from './skill-types.js';
+export declare const SEED_SKILL_SCENARIOS: SkillBenchmarkScenario[];

package/dist/agent/self-improvement/skill-benchmark.js

@@ -0,0 +1,22 @@
+/**
+ * Seed coverage benchmark for self-authored SKILLS. Each scenario is a situation
+ * the agent should have reusable guidance for; an authored skill "covers" it when
+ * its content surfaces the expected terms. Curated separately from any proposer.
+ *
+ * @module agent/self-improvement/skill-benchmark
+ */
+export const SEED_SKILL_SCENARIOS = [
+    {
+        id: 'git-bisect',
+        query: 'find which commit introduced a regression',
+        expectIncludes: ['git bisect', 'good', 'bad'],
+        description: 'guidance for bisecting a regression',
+    },
+    {
+        id: 'safe-delete',
+        query: 'delete files safely without losing data',
+        expectIncludes: ['backup', 'dry run', 'confirm'],
+        description: 'guidance for deleting files safely',
+    },
+];
+//# sourceMappingURL=skill-benchmark.js.map

package/dist/agent/self-improvement/skill-consolidator.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Skill consolidator — merges a CLUSTER of overlapping authored skills into one
+ * "umbrella" skill (Hermes's idea) but with OUR distinctive safety net: the merge
+ * is accepted only if the umbrella still passes the firewall AND COVERS EVERY
+ * scenario the absorbed siblings covered. A merge that drops coverage is rejected
+ * (Hermes consolidates by LLM judgment alone; we gate it empirically).
+ *
+ * Operates only on authored-* skills; pinned siblings are skipped (kept intact);
+ * absorbed siblings are ARCHIVED (recoverable), never deleted; each is recorded in
+ * the evolutionary archive with `absorbedInto` for audit.
+ *
+ * @module agent/self-improvement/skill-consolidator
+ */
+import { EvolutionaryArchive } from './evolutionary-archive.js';
+import { LiveSkillMutator } from './skill-mutator.js';
+import type { SkillBenchmarkScenario } from './skill-types.js';
+export interface ClusterSibling {
+    name: string;
+    scenario: SkillBenchmarkScenario;
+}
+export interface ConsolidationCluster {
+    siblings: ClusterSibling[];
+}
+export interface UmbrellaProposal {
+    name: string;
+    content: string;
+}
+export interface UmbrellaProposer {
+    propose(cluster: ConsolidationCluster): Promise<UmbrellaProposal | null>;
+}
+export type ConsolidationRejection = 'cluster-too-small' | 'no-proposal' | 'firewall' | 'coverage-loss';
+export interface ConsolidationOutcome {
+    accepted: boolean;
+    umbrellaName?: string;
+    absorbed: string[];
+    skippedPinned: string[];
+    rejectionReason?: ConsolidationRejection;
+    reasons: string[];
+}
+/** Build a cluster from installed authored skills that map to a known scenario. */
+export declare function buildClusterFromInstalled(mutator: LiveSkillMutator, scenarios: SkillBenchmarkScenario[]): ConsolidationCluster;
+export declare function consolidateCluster(cluster: ConsolidationCluster, proposer: UmbrellaProposer, mutator: LiveSkillMutator, archive: EvolutionaryArchive, options: {
+    keepOnAccept: boolean;
+}): Promise<ConsolidationOutcome>;
+/** Deterministic umbrella proposer (fixture for tests). */
+export declare class StaticUmbrellaProposer implements UmbrellaProposer {
+    private readonly umbrella;
+    constructor(umbrella: UmbrellaProposal | null);
+    propose(): Promise<UmbrellaProposal | null>;
+}
+interface MinimalClient {
+    chat(messages: Array<{
+        role: string;
+        content: string;
+    }>, tools?: unknown[]): Promise<{
+        choices?: Array<{
+            message?: {
+                content?: string | null;
+            };
+        }>;
+    }>;
+}
+export declare class LlmUmbrellaProposer implements UmbrellaProposer {
+    private clientPromise;
+    constructor(options?: {
+        client?: MinimalClient | null;
+    });
+    private getClient;
+    propose(cluster: ConsolidationCluster): Promise<UmbrellaProposal | null>;
+}
+export {};