@phuetz/code-buddy 1.2.0 → 1.3.0

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

@@ -0,0 +1,62 @@
+/**
+ * Skill gate — validates an authored skill proposal. Ordered, blocking, fail-closed:
+ *   G1 static scan (authored-artifact-gate, subsystem 'skill': dangerous patterns
+ *      in any embedded code, secrets, no-src, omissions)
+ *   G2 SKILL FIREWALL (the headline skill safety check: prompt-injection /
+ *      exfiltration surface — a skill is INJECTED into the agent's context)
+ *   G3 COVERAGE — the skill must surface the scenario's expected guidance.
+ * Installation happens only on accept+keep (auto-apply); scoring never installs.
+ *
+ * @module agent/self-improvement/skill-gate
+ */
+import { inspectAuthoredCode } from './authored-artifact-gate.js';
+import { scanAuthoredSkillContent } from './skill-mutator.js';
+/** Deterministic coverage check: the skill content surfaces all expected guidance. */
+export function coversScenario(content, scenario) {
+    const lower = content.toLowerCase();
+    return scenario.expectIncludes.every((s) => lower.includes(s.toLowerCase()));
+}
+export function validateSkillProposal(proposal, scenario, mutator, options) {
+    const base = { proposalId: proposal.id, scenarioId: scenario.id };
+    const content = proposal.spec.content ?? '';
+    // G1 — static scan (no execution).
+    const scan = inspectAuthoredCode(content, 'skill');
+    if (!scan.ok) {
+        return { ...base, accepted: false, rejectionReason: 'static-scan', reasons: scan.reasons };
+    }
+    // G2 — skill firewall (prompt-injection / exfiltration). The headline defence.
+    const fw = scanAuthoredSkillContent(content);
+    if (!fw.safe) {
+        return {
+            ...base,
+            accepted: false,
+            rejectionReason: 'firewall',
+            reasons: [`skill firewall flagged it (${fw.verdict})`, ...fw.reasons],
+        };
+    }
+    // G3 — coverage: the skill must actually surface the expected guidance.
+    const lower = content.toLowerCase();
+    const missing = scenario.expectIncludes.filter((s) => !lower.includes(s.toLowerCase()));
+    if (missing.length > 0) {
+        return {
+            ...base,
+            accepted: false,
+            rejectionReason: 'coverage-fail',
+            reasons: [`skill does not surface expected guidance: ${JSON.stringify(missing)}`],
+        };
+    }
+    // Accepted. Install (auto-apply) or just report (propose-only).
+    let appliedRef;
+    if (options.keepOnAccept) {
+        appliedRef = mutator.create(proposal.spec).name;
+    }
+    return {
+        ...base,
+        accepted: true,
+        reasons: options.keepOnAccept
+            ? ['accepted and installed (auto-apply): firewall-clean + covers the scenario']
+            : ['accepted (propose-only): firewall-clean + covers the scenario, not installed'],
+        ...(appliedRef ? { appliedRef } : {}),
+    };
+}
+//# sourceMappingURL=skill-gate.js.map

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

@@ -0,0 +1,74 @@
+/**
+ * Skill mutator — installs / refines / pins / archives authored SKILL.md files
+ * under `.codebuddy/skills/<authored-name>/` (ONE level deep so the SkillRegistry's
+ * 1-level walk actually loads them) with proven, reversible operations and the
+ * firewall scan used to gate authored skill content.
+ *
+ * Authored skills always carry YAML frontmatter (name + description) so the
+ * registry can parse them; the body is the model's markdown. All destructive ops
+ * honour a `pinned: true` frontmatter flag and operate ONLY on authored skills.
+ *
+ * @module agent/self-improvement/skill-mutator
+ */
+import type { SkillSpec } from './skill-types.js';
+export declare const AUTHORED_SKILL_PREFIX = "authored-";
+export declare function toAuthoredSkillName(raw: string): string;
+export declare function isAuthoredSkillName(name: string): boolean;
+/** Ensure the content begins with YAML frontmatter carrying name + description. */
+export declare function ensureFrontmatter(name: string, description: string, content: string): string;
+export declare function readPinned(content: string): boolean;
+/** Set or clear the `pinned` flag inside the frontmatter (frontmatter must exist). */
+export declare function setPinned(content: string, value: boolean): string;
+export interface SkillFirewallCheck {
+    safe: boolean;
+    verdict: string;
+    reasons: string[];
+}
+/** Write the skill body to a throwaway file and run the firewall scan (no install). */
+export declare function scanAuthoredSkillContent(content: string): SkillFirewallCheck;
+/** Safety re-gate over authored skill CONTENT (static scan + firewall). */
+export declare function safetyGateSkill(content: string): {
+    ok: boolean;
+    reasons: string[];
+};
+export interface SkillMutatorPort {
+    create(spec: SkillSpec): {
+        name: string;
+    };
+    remove(name: string): boolean;
+    has(name: string): boolean;
+}
+export interface MutationResult {
+    ok: boolean;
+    reasons: string[];
+}
+/** Dual-purpose mutator: the engine's port + the curation operations. */
+export declare class LiveSkillMutator implements SkillMutatorPort {
+    private readonly skillsRoot;
+    constructor(skillsRoot?: string);
+    /** 1 level deep so the registry's findSkillFiles (1-level) loads it. */
+    private dirFor;
+    private skillFile;
+    private reload;
+    private readContent;
+    has(name: string): boolean;
+    isPinned(name: string): boolean;
+    create(spec: SkillSpec): {
+        name: string;
+    };
+    /** Full re-author of an existing authored skill, re-gated. Refuses pinned. */
+    update(name: string, newContent: string, description?: string): MutationResult;
+    /** Find/replace within an authored skill body (exact; fail on multiple unless replaceAll). */
+    patch(name: string, oldStr: string, newStr: string, opts?: {
+        replaceAll?: boolean;
+    }): MutationResult;
+    remove(name: string): boolean;
+    /** Recoverable removal — move to .archive/. Refuses pinned. */
+    archive(name: string): boolean;
+    restore(name: string): boolean;
+    pin(name: string): boolean;
+    unpin(name: string): boolean;
+    private setPin;
+    /** List installed authored skills (by the authored- prefix). */
+    listAuthored(): string[];
+}

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

@@ -0,0 +1,223 @@
+/**
+ * Skill mutator — installs / refines / pins / archives authored SKILL.md files
+ * under `.codebuddy/skills/<authored-name>/` (ONE level deep so the SkillRegistry's
+ * 1-level walk actually loads them) with proven, reversible operations and the
+ * firewall scan used to gate authored skill content.
+ *
+ * Authored skills always carry YAML frontmatter (name + description) so the
+ * registry can parse them; the body is the model's markdown. All destructive ops
+ * honour a `pinned: true` frontmatter flag and operate ONLY on authored skills.
+ *
+ * @module agent/self-improvement/skill-mutator
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { randomUUID } from 'crypto';
+import { getSkillRegistry } from '../../skills/registry.js';
+import { scanSkillFirewall } from '../../security/skill-scanner.js';
+import { inspectAuthoredCode } from './authored-artifact-gate.js';
+export const AUTHORED_SKILL_PREFIX = 'authored-';
+const ARCHIVE_DIR = '.archive';
+export function toAuthoredSkillName(raw) {
+    const base = String(raw)
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return base.startsWith(AUTHORED_SKILL_PREFIX) ? base : `${AUTHORED_SKILL_PREFIX}${base || 'skill'}`;
+}
+export function isAuthoredSkillName(name) {
+    return name.startsWith(AUTHORED_SKILL_PREFIX);
+}
+// ── frontmatter helpers (our controlled format; avoids the registry parser's
+//    tier + validation requirements for a simple flag toggle) ────────────────
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+/** Ensure the content begins with YAML frontmatter carrying name + description. */
+export function ensureFrontmatter(name, description, content) {
+    if (FRONTMATTER_RE.test(content))
+        return content;
+    const desc = description.replace(/"/g, "'").replace(/\r?\n/g, ' ').trim();
+    return `---\nname: ${name}\ndescription: "${desc}"\n---\n\n${content.trim()}\n`;
+}
+export function readPinned(content) {
+    const m = content.match(FRONTMATTER_RE);
+    if (!m)
+        return false;
+    return /^\s*pinned\s*:\s*true\s*$/im.test(m[1]);
+}
+/** Set or clear the `pinned` flag inside the frontmatter (frontmatter must exist). */
+export function setPinned(content, value) {
+    const m = content.match(FRONTMATTER_RE);
+    if (!m)
+        return content; // no frontmatter → nothing to pin (create() always adds it)
+    let body = m[1];
+    if (/^\s*pinned\s*:.*$/im.test(body)) {
+        body = body.replace(/^\s*pinned\s*:.*$/im, `pinned: ${value}`);
+    }
+    else {
+        body = `${body}\npinned: ${value}`;
+    }
+    return content.replace(FRONTMATTER_RE, `---\n${body}\n---\n`);
+}
+/** Write the skill body to a throwaway file and run the firewall scan (no install). */
+export function scanAuthoredSkillContent(content) {
+    const dir = path.join(os.tmpdir(), `cb-skillscan-${randomUUID()}`);
+    const file = path.join(dir, 'SKILL.md');
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(file, content, 'utf-8');
+    try {
+        const report = scanSkillFirewall(file);
+        return {
+            safe: !report.quarantineRequired,
+            verdict: String(report.verdict),
+            reasons: report.quarantineRequired ? [report.summary] : [],
+        };
+    }
+    catch (err) {
+        return { safe: false, verdict: 'scan-error', reasons: [err instanceof Error ? err.message : String(err)] };
+    }
+    finally {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+}
+/** Safety re-gate over authored skill CONTENT (static scan + firewall). */
+export function safetyGateSkill(content) {
+    const scan = inspectAuthoredCode(content, 'skill');
+    if (!scan.ok)
+        return { ok: false, reasons: scan.reasons };
+    const fw = scanAuthoredSkillContent(content);
+    if (!fw.safe)
+        return { ok: false, reasons: [`firewall: ${fw.verdict}`, ...fw.reasons] };
+    return { ok: true, reasons: [] };
+}
+/** Dual-purpose mutator: the engine's port + the curation operations. */
+export class LiveSkillMutator {
+    skillsRoot;
+    constructor(skillsRoot) {
+        this.skillsRoot = skillsRoot ?? path.join(process.cwd(), '.codebuddy', 'skills');
+    }
+    /** 1 level deep so the registry's findSkillFiles (1-level) loads it. */
+    dirFor(name) {
+        return path.join(this.skillsRoot, name);
+    }
+    skillFile(name) {
+        return path.join(this.dirFor(name), 'SKILL.md');
+    }
+    reload() {
+        void getSkillRegistry().reloadAll().catch(() => { });
+    }
+    readContent(name) {
+        const f = this.skillFile(name);
+        return fs.existsSync(f) ? fs.readFileSync(f, 'utf-8') : null;
+    }
+    has(name) {
+        return fs.existsSync(this.skillFile(name));
+    }
+    isPinned(name) {
+        const c = this.readContent(name);
+        return c ? readPinned(c) : false;
+    }
+    create(spec) {
+        const dir = this.dirFor(spec.name);
+        fs.mkdirSync(dir, { recursive: true });
+        const content = ensureFrontmatter(spec.name, spec.description, spec.content);
+        fs.writeFileSync(this.skillFile(spec.name), content, 'utf-8');
+        this.reload();
+        return { name: spec.name };
+    }
+    /** Full re-author of an existing authored skill, re-gated. Refuses pinned. */
+    update(name, newContent, description = '') {
+        if (!isAuthoredSkillName(name))
+            return { ok: false, reasons: ['not an authored skill'] };
+        if (!this.has(name))
+            return { ok: false, reasons: ['skill does not exist'] };
+        if (this.isPinned(name))
+            return { ok: false, reasons: ['skill is pinned'] };
+        const withFm = ensureFrontmatter(name, description, newContent);
+        const gate = safetyGateSkill(withFm);
+        if (!gate.ok)
+            return gate;
+        fs.writeFileSync(this.skillFile(name), withFm, 'utf-8');
+        this.reload();
+        return { ok: true, reasons: [] };
+    }
+    /** Find/replace within an authored skill body (exact; fail on multiple unless replaceAll). */
+    patch(name, oldStr, newStr, opts = {}) {
+        const content = this.readContent(name);
+        if (content === null)
+            return { ok: false, reasons: ['skill does not exist'] };
+        if (this.isPinned(name))
+            return { ok: false, reasons: ['skill is pinned'] };
+        const count = content.split(oldStr).length - 1;
+        if (count === 0)
+            return { ok: false, reasons: ['old_string not found'] };
+        if (count > 1 && !opts.replaceAll) {
+            return { ok: false, reasons: [`old_string matches ${count} times — pass replaceAll or add context`] };
+        }
+        const patched = opts.replaceAll ? content.split(oldStr).join(newStr) : content.replace(oldStr, newStr);
+        return this.update(name, patched);
+    }
+    remove(name) {
+        if (this.isPinned(name))
+            return false;
+        const dir = this.dirFor(name);
+        const existed = fs.existsSync(dir);
+        if (existed)
+            fs.rmSync(dir, { recursive: true, force: true });
+        this.reload();
+        return existed;
+    }
+    /** Recoverable removal — move to .archive/. Refuses pinned. */
+    archive(name) {
+        if (this.isPinned(name))
+            return false;
+        const dir = this.dirFor(name);
+        if (!fs.existsSync(dir))
+            return false;
+        const archiveRoot = path.join(this.skillsRoot, ARCHIVE_DIR);
+        fs.mkdirSync(archiveRoot, { recursive: true });
+        let dest = path.join(archiveRoot, name);
+        if (fs.existsSync(dest))
+            dest = `${dest}-${randomUUID().slice(0, 8)}`;
+        fs.renameSync(dir, dest);
+        this.reload();
+        return true;
+    }
+    restore(name) {
+        const src = path.join(this.skillsRoot, ARCHIVE_DIR, name);
+        if (!fs.existsSync(src))
+            return false;
+        const dir = this.dirFor(name);
+        if (fs.existsSync(dir))
+            return false; // don't clobber a live skill
+        fs.renameSync(src, dir);
+        this.reload();
+        return true;
+    }
+    pin(name) {
+        return this.setPin(name, true);
+    }
+    unpin(name) {
+        return this.setPin(name, false);
+    }
+    setPin(name, value) {
+        const content = this.readContent(name);
+        if (content === null)
+            return false;
+        const withFm = ensureFrontmatter(name, '', content);
+        fs.writeFileSync(this.skillFile(name), setPinned(withFm, value), 'utf-8');
+        this.reload();
+        return true;
+    }
+    /** List installed authored skills (by the authored- prefix). */
+    listAuthored() {
+        if (!fs.existsSync(this.skillsRoot))
+            return [];
+        return fs
+            .readdirSync(this.skillsRoot, { withFileTypes: true })
+            .filter((e) => e.isDirectory() && isAuthoredSkillName(e.name) && fs.existsSync(path.join(this.skillsRoot, e.name, 'SKILL.md')))
+            .map((e) => e.name);
+    }
+}
+//# sourceMappingURL=skill-mutator.js.map

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

@@ -0,0 +1,40 @@
+/**
+ * Skill proposers — author a SKILL.md for a coverage scenario. A skill is pure
+ * guidance, so there is no held-out set to hide (unlike tools); the proposer may
+ * see the scenario in full. Safety is enforced downstream by the firewall gate.
+ *
+ * @module agent/self-improvement/skill-proposer
+ */
+import type { SkillBenchmarkScenario, SkillProposal, SkillSpec } from './skill-types.js';
+export interface SkillProposer {
+    propose(scenario: SkillBenchmarkScenario): Promise<SkillProposal | null>;
+}
+/** Deterministic proposer backed by a fixture map (scenarioId → spec). */
+export declare class StaticSkillProposer implements SkillProposer {
+    private readonly specs;
+    constructor(specs: Map<string, SkillSpec>);
+    propose(scenario: SkillBenchmarkScenario): Promise<SkillProposal | null>;
+}
+interface MinimalClient {
+    chat(messages: Array<{
+        role: string;
+        content: string;
+    }>, tools?: unknown[]): Promise<{
+        choices?: Array<{
+            message?: {
+                content?: string | null;
+            };
+        }>;
+    }>;
+}
+export declare function buildSkillDraftPrompt(scenario: SkillBenchmarkScenario): string;
+export interface LlmSkillProposerOptions {
+    client?: MinimalClient | null;
+}
+export declare class LlmSkillProposer implements SkillProposer {
+    private clientPromise;
+    constructor(options?: LlmSkillProposerOptions);
+    private getClient;
+    propose(scenario: SkillBenchmarkScenario): Promise<SkillProposal | null>;
+}
+export {};

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

@@ -0,0 +1,82 @@
+/**
+ * Skill proposers — author a SKILL.md for a coverage scenario. A skill is pure
+ * guidance, so there is no held-out set to hide (unlike tools); the proposer may
+ * see the scenario in full. Safety is enforced downstream by the firewall gate.
+ *
+ * @module agent/self-improvement/skill-proposer
+ */
+import { toAuthoredSkillName } from './skill-mutator.js';
+/** Deterministic proposer backed by a fixture map (scenarioId → spec). */
+export class StaticSkillProposer {
+    specs;
+    constructor(specs) {
+        this.specs = specs;
+    }
+    async propose(scenario) {
+        const spec = this.specs.get(scenario.id);
+        if (!spec)
+            return null;
+        return { id: `skill-proposal:${scenario.id}`, targetScenarioId: scenario.id, spec };
+    }
+}
+export function buildSkillDraftPrompt(scenario) {
+    return [
+        `Write a SKILL.md that gives you reusable guidance for this situation:`,
+        `  ${scenario.query}`,
+        ``,
+        `It MUST clearly cover these points (use these exact terms): ${JSON.stringify(scenario.expectIncludes)}.`,
+        ``,
+        `Format: a short markdown skill — a title line, a one-line "when to use", then`,
+        `concrete steps/notes. Keep it focused. Do NOT include any instruction to ignore`,
+        `safety rules, reveal or exfiltrate secrets/credentials, or run destructive`,
+        `commands — such content is rejected by a safety firewall.`,
+        ``,
+        `Return ONLY the SKILL.md markdown (no surrounding prose).`,
+    ].join('\n');
+}
+export class LlmSkillProposer {
+    clientPromise;
+    constructor(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(scenario) {
+        const client = await this.getClient();
+        if (!client)
+            return null;
+        try {
+            const prompt = buildSkillDraftPrompt(scenario);
+            const response = await client.chat([{ role: 'user', content: prompt }], []);
+            const content = response?.choices?.[0]?.message?.content?.trim();
+            if (!content)
+                return null;
+            const spec = {
+                name: toAuthoredSkillName(scenario.id),
+                description: scenario.description,
+                content,
+            };
+            return { id: `llm-skill:${scenario.id}`, targetScenarioId: scenario.id, spec };
+        }
+        catch {
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=skill-proposer.js.map

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

@@ -0,0 +1,41 @@
+/**
+ * Types for the SKILL self-improvement path. A skill is procedural guidance
+ * (a SKILL.md injected into context), not a deterministic function — so it is
+ * gated by SAFETY (the skill firewall: prompt-injection / exfiltration surface)
+ * plus COVERAGE (does it actually surface the expected guidance?), rather than
+ * the behavioural held-out gate used for executable tools. Honest by design:
+ * there is nothing to "run", so there is no behavioural held-out for pure
+ * guidance — the held-out gate stays the tool path's concern.
+ *
+ * @module agent/self-improvement/skill-types
+ */
+export interface SkillSpec {
+    /** Authored skill name (slugged, namespaced authored-*). */
+    name: string;
+    description: string;
+    /** The full SKILL.md body. */
+    content: string;
+}
+/** Coverage scenario: the authored skill should surface `expectIncludes` for `query`. */
+export interface SkillBenchmarkScenario {
+    id: string;
+    query: string;
+    expectIncludes: string[];
+    description: string;
+}
+export interface SkillProposal {
+    id: string;
+    targetScenarioId: string;
+    experienceId?: string;
+    spec: SkillSpec;
+}
+export type SkillGateRejection = 'static-scan' | 'firewall' | 'coverage-fail';
+export interface SkillGateOutcome {
+    accepted: boolean;
+    proposalId: string;
+    scenarioId: string;
+    rejectionReason?: SkillGateRejection;
+    reasons: string[];
+    /** Name of the skill left installed (only when accepted AND kept). */
+    appliedRef?: string;
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Types for the SKILL self-improvement path. A skill is procedural guidance
+ * (a SKILL.md injected into context), not a deterministic function — so it is
+ * gated by SAFETY (the skill firewall: prompt-injection / exfiltration surface)
+ * plus COVERAGE (does it actually surface the expected guidance?), rather than
+ * the behavioural held-out gate used for executable tools. Honest by design:
+ * there is nothing to "run", so there is no behavioural held-out for pure
+ * guidance — the held-out gate stays the tool path's concern.
+ *
+ * @module agent/self-improvement/skill-types
+ */
+export {};
+//# sourceMappingURL=skill-types.js.map

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

@@ -0,0 +1,10 @@
+/**
+ * Seed behavioural benchmark for self-authored TOOLS. Each scenario describes a
+ * small, deterministic capability with VISIBLE cases (shown to the proposer) and
+ * HELD-OUT cases (fresh inputs, never shown) — so a tool that hardcodes the
+ * visible answers is caught. Curated separately from any proposer.
+ *
+ * @module agent/self-improvement/tool-benchmark
+ */
+import type { ToolBenchmarkScenario } from './tool-types.js';
+export declare const SEED_TOOL_SCENARIOS: ToolBenchmarkScenario[];

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

@@ -0,0 +1,37 @@
+/**
+ * Seed behavioural benchmark for self-authored TOOLS. Each scenario describes a
+ * small, deterministic capability with VISIBLE cases (shown to the proposer) and
+ * HELD-OUT cases (fresh inputs, never shown) — so a tool that hardcodes the
+ * visible answers is caught. Curated separately from any proposer.
+ *
+ * @module agent/self-improvement/tool-benchmark
+ */
+export const SEED_TOOL_SCENARIOS = [
+    {
+        id: 'slugify',
+        capability: 'Slugify the string field `text`: lowercase it, replace runs of spaces with single hyphens, and print the slug.',
+        description: 'authored__slugify converts text to a url slug',
+        visibleCases: [
+            { input: { text: 'Hello World' }, expectIncludes: ['hello-world'] },
+            { input: { text: 'Foo Bar Baz' }, expectIncludes: ['foo-bar-baz'] },
+        ],
+        heldOutCases: [
+            { input: { text: 'The Quick Brown' }, expectIncludes: ['the-quick-brown'] },
+            { input: { text: 'A B C' }, expectIncludes: ['a-b-c'] },
+        ],
+    },
+    {
+        id: 'word-count',
+        capability: 'Count the whitespace-separated words in the string field `text` and print the integer count.',
+        description: 'authored__word_count counts words',
+        visibleCases: [
+            { input: { text: 'one two three' }, expectIncludes: ['3'] },
+            { input: { text: 'hello' }, expectIncludes: ['1'] },
+        ],
+        heldOutCases: [
+            { input: { text: 'a b c d e' }, expectIncludes: ['5'] },
+            { input: { text: 'foo bar' }, expectIncludes: ['2'] },
+        ],
+    },
+];
+//# sourceMappingURL=tool-benchmark.js.map

package/dist/agent/self-improvement/tool-engine.d.ts

@@ -0,0 +1,54 @@
+/**
+ * ToolImprovementEngine — the tool sibling of SelfImprovementEngine. One cycle:
+ *   pick an uncovered tool scenario → propose (redacted view) → tool gate
+ *   (static scan → visible → held-out) → keep+archive (auto-apply) or report.
+ *
+ * Autonomy is the same fail-safe toggle: 'propose-only' (default) validates and
+ * reports; 'auto-apply' (CODEBUDDY_SELF_IMPROVE=true) keeps only tools that pass
+ * the behavioural held-out gate, and archives them (reversible — un-registerable).
+ *
+ * @module agent/self-improvement/tool-engine
+ */
+import { EvolutionaryArchive } from './evolutionary-archive.js';
+import { type Autonomy } from './engine.js';
+import { type ToolMutatorPort } from './tool-skill-mutator.js';
+import { type ToolProposer } from './tool-proposer.js';
+import type { ToolBenchmarkScenario, ToolGateOutcome } from './tool-types.js';
+export interface ToolCycleResult {
+    kind: 'tool_improvement_cycle';
+    startedAt: string;
+    autonomy: Autonomy;
+    selectedScenarioId: string | null;
+    proposalId: string | null;
+    gate: ToolGateOutcome | null;
+    applied: boolean;
+    notes: string[];
+}
+export interface ToolImprovementEngineOptions {
+    scenarios: ToolBenchmarkScenario[];
+    proposer: ToolProposer;
+    mutator?: ToolMutatorPort;
+    archive?: EvolutionaryArchive;
+    autonomy?: Autonomy;
+    now?: () => Date;
+}
+export declare class ToolImprovementEngine {
+    private readonly scenarios;
+    private readonly proposer;
+    private readonly mutator;
+    private readonly archive;
+    private readonly autonomy;
+    private readonly now;
+    /** Scenario ids already satisfied this run (coverage is per-scenario, not per tool name). */
+    private readonly covered;
+    constructor(options: ToolImprovementEngineOptions);
+    /** Run exactly one tool-improvement cycle. */
+    runCycle(): Promise<ToolCycleResult>;
+    /** Run cycles until nothing new is applied (or maxCycles). */
+    runLoop(maxCycles?: number): Promise<ToolCycleResult[]>;
+    status(): {
+        autonomy: Autonomy;
+        scenarios: number;
+        archive: ReturnType<EvolutionaryArchive['summary']>;
+    };
+}