@phuetz/code-buddy 1.1.0 → 1.3.0

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']>;
+    };
+}

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

@@ -0,0 +1,101 @@
+/**
+ * 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 { resolveAutonomy } from './engine.js';
+import { validateToolProposal } from './tool-gate.js';
+import { LiveToolMutator } from './tool-skill-mutator.js';
+import { toProposerView } from './tool-proposer.js';
+export class ToolImprovementEngine {
+    scenarios;
+    proposer;
+    mutator;
+    archive;
+    autonomy;
+    now;
+    /** Scenario ids already satisfied this run (coverage is per-scenario, not per tool name). */
+    covered = new Set();
+    constructor(options) {
+        this.scenarios = options.scenarios;
+        this.proposer = options.proposer;
+        this.mutator = options.mutator ?? new LiveToolMutator();
+        this.archive = options.archive ?? new EvolutionaryArchive();
+        this.autonomy = options.autonomy ?? resolveAutonomy();
+        this.now = options.now ?? (() => new Date());
+    }
+    /** Run exactly one tool-improvement cycle. */
+    async runCycle() {
+        const startedAt = this.now().toISOString();
+        const base = { kind: 'tool_improvement_cycle', startedAt, autonomy: this.autonomy };
+        for (const scenario of this.scenarios) {
+            // Coverage is per-scenario: once a tool has satisfied this scenario's gate,
+            // don't re-author it (even if the model would pick a different name).
+            if (this.covered.has(scenario.id))
+                continue;
+            const proposal = await this.proposer.propose(toProposerView(scenario));
+            if (!proposal)
+                continue;
+            // A tool with this exact name already exists — skip (avoid dup-register).
+            if (this.mutator.has(proposal.spec.name)) {
+                this.covered.add(scenario.id);
+                continue;
+            }
+            const gate = await validateToolProposal(proposal, scenario, this.mutator, {
+                keepOnAccept: this.autonomy === 'auto-apply',
+            });
+            const applied = gate.accepted && !!gate.appliedRef;
+            if (applied) {
+                this.covered.add(scenario.id);
+                this.archive.append({
+                    proposalId: proposal.id,
+                    kind: 'tool',
+                    targetScenarioId: scenario.id,
+                    experienceId: proposal.experienceId,
+                    delta: 1,
+                    scoreAfter: gate.visiblePassed + gate.heldOutPassed,
+                    appliedRef: gate.appliedRef,
+                });
+            }
+            return {
+                ...base,
+                selectedScenarioId: scenario.id,
+                proposalId: proposal.id,
+                gate,
+                applied,
+                notes: gate.reasons,
+            };
+        }
+        return {
+            ...base,
+            selectedScenarioId: null,
+            proposalId: null,
+            gate: null,
+            applied: false,
+            notes: ['no uncovered tool scenario with an available proposal'],
+        };
+    }
+    /** Run cycles until nothing new is applied (or maxCycles). */
+    async runLoop(maxCycles) {
+        const cap = Math.max(1, maxCycles ?? this.scenarios.length + 1);
+        const results = [];
+        for (let i = 0; i < cap; i++) {
+            const r = await this.runCycle();
+            results.push(r);
+            if (!r.applied)
+                break;
+        }
+        return results;
+    }
+    status() {
+        return { autonomy: this.autonomy, scenarios: this.scenarios.length, archive: this.archive.summary() };
+    }
+}
+//# sourceMappingURL=tool-engine.js.map

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

@@ -0,0 +1,20 @@
+/**
+ * Tool gate — the empirical, anti-gaming validator for an authored-tool proposal.
+ * Ordered, blocking, fail-closed:
+ *   G1 static scan (authored-artifact-gate, no execution)
+ *   G3 VISIBLE behavioural cases must all pass (the tool actually works)
+ *   G4 HELD-OUT behavioural cases must all pass (fresh inputs the proposer never
+ *      saw — a tool that hardcodes the visible outputs fails here → rejected).
+ * A scenario with no held-out cases is rejected (anti-gaming is then undefined).
+ *
+ * Scoring never registers the tool; registration happens only on accept+keep.
+ *
+ * @module agent/self-improvement/tool-gate
+ */
+import type { ToolMutatorPort } from './tool-skill-mutator.js';
+import type { ToolBenchmarkScenario, ToolGateOutcome, ToolProposal } from './tool-types.js';
+export interface ValidateToolOptions {
+    /** auto-apply: keep (register) an accepted tool. propose-only: report only. */
+    keepOnAccept: boolean;
+}
+export declare function validateToolProposal(proposal: ToolProposal, scenario: ToolBenchmarkScenario, mutator: ToolMutatorPort, options: ValidateToolOptions): Promise<ToolGateOutcome>;

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

@@ -0,0 +1,78 @@
+/**
+ * Tool gate — the empirical, anti-gaming validator for an authored-tool proposal.
+ * Ordered, blocking, fail-closed:
+ *   G1 static scan (authored-artifact-gate, no execution)
+ *   G3 VISIBLE behavioural cases must all pass (the tool actually works)
+ *   G4 HELD-OUT behavioural cases must all pass (fresh inputs the proposer never
+ *      saw — a tool that hardcodes the visible outputs fails here → rejected).
+ * A scenario with no held-out cases is rejected (anti-gaming is then undefined).
+ *
+ * Scoring never registers the tool; registration happens only on accept+keep.
+ *
+ * @module agent/self-improvement/tool-gate
+ */
+import { inspectAuthoredCode } from './authored-artifact-gate.js';
+import { scoreToolCases } from './sandbox-scorer.js';
+export async function validateToolProposal(proposal, scenario, mutator, options) {
+    const zero = {
+        proposalId: proposal.id,
+        scenarioId: scenario.id,
+        visiblePassed: 0,
+        visibleTotal: scenario.visibleCases.length,
+        heldOutPassed: 0,
+        heldOutTotal: scenario.heldOutCases.length,
+    };
+    // G1 — static scan (no execution).
+    const scan = inspectAuthoredCode(proposal.spec.code, 'code');
+    if (!scan.ok) {
+        return { ...zero, accepted: false, rejectionReason: 'static-scan', reasons: scan.reasons };
+    }
+    // Fail-closed: a scenario with no held-out cases can't defend against gaming.
+    if (scenario.heldOutCases.length === 0) {
+        return {
+            ...zero,
+            accepted: false,
+            rejectionReason: 'heldout-fail',
+            reasons: ['scenario has no held-out cases — anti-gaming is undefined, refusing'],
+        };
+    }
+    // G3 — visible behavioural cases (the tool must actually work).
+    const visible = await scoreToolCases(proposal.spec, scenario.visibleCases);
+    if (visible.passed < visible.total) {
+        return {
+            ...zero,
+            accepted: false,
+            visiblePassed: visible.passed,
+            rejectionReason: 'visible-fail',
+            reasons: visible.failures,
+        };
+    }
+    // G4 — held-out cases on FRESH inputs (catches hardcoded-output gaming).
+    const heldOut = await scoreToolCases(proposal.spec, scenario.heldOutCases);
+    if (heldOut.passed < heldOut.total) {
+        return {
+            ...zero,
+            accepted: false,
+            visiblePassed: visible.passed,
+            heldOutPassed: heldOut.passed,
+            rejectionReason: 'heldout-fail',
+            reasons: ['held-out cases failed — likely gamed/overfit visible outputs', ...heldOut.failures],
+        };
+    }
+    // Accepted. Keep (auto-apply) or just report (propose-only).
+    let appliedRef;
+    if (options.keepOnAccept) {
+        appliedRef = mutator.register(proposal.spec).name;
+    }
+    return {
+        ...zero,
+        accepted: true,
+        visiblePassed: visible.passed,
+        heldOutPassed: heldOut.passed,
+        reasons: options.keepOnAccept
+            ? ['accepted and kept (auto-apply): passed visible + held-out, statically clean']
+            : ['accepted (propose-only): passed visible + held-out, not persisted'],
+        ...(appliedRef ? { appliedRef } : {}),
+    };
+}
+//# sourceMappingURL=tool-gate.js.map

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

@@ -0,0 +1,31 @@
+/**
+ * Tool proposer — authors a candidate tool for a scenario. It receives a REDACTED
+ * view of the scenario (capability + visible cases only); the held-out cases are
+ * never exposed, so a proposer (static or LLM) cannot overfit to them. This is the
+ * structural half of the anti-gaming defence (the gate is the empirical half).
+ *
+ * @module agent/self-improvement/tool-proposer
+ */
+import type { AuthoredToolSpec } from './authored-tool-runtime.js';
+import type { ToolBenchmarkScenario, ToolCase, ToolProposal } from './tool-types.js';
+/** What a proposer is allowed to see — NO held-out cases. */
+export interface ProposerScenarioView {
+    id: string;
+    capability: string;
+    description: string;
+    visibleCases: ToolCase[];
+}
+/** Redact a scenario down to what a proposer may see. */
+export declare function toProposerView(scenario: ToolBenchmarkScenario): ProposerScenarioView;
+export interface ToolProposer {
+    propose(view: ProposerScenarioView): Promise<ToolProposal | null>;
+}
+/**
+ * Deterministic proposer backed by a fixture map (scenarioId → spec). Ships first
+ * (testable, no LLM). The LLM proposer is Phase 3 and uses the same redacted view.
+ */
+export declare class StaticToolProposer implements ToolProposer {
+    private readonly specs;
+    constructor(specs: Map<string, AuthoredToolSpec>);
+    propose(view: ProposerScenarioView): Promise<ToolProposal | null>;
+}

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

@@ -0,0 +1,34 @@
+/**
+ * Tool proposer — authors a candidate tool for a scenario. It receives a REDACTED
+ * view of the scenario (capability + visible cases only); the held-out cases are
+ * never exposed, so a proposer (static or LLM) cannot overfit to them. This is the
+ * structural half of the anti-gaming defence (the gate is the empirical half).
+ *
+ * @module agent/self-improvement/tool-proposer
+ */
+/** Redact a scenario down to what a proposer may see. */
+export function toProposerView(scenario) {
+    return {
+        id: scenario.id,
+        capability: scenario.capability,
+        description: scenario.description,
+        visibleCases: scenario.visibleCases,
+    };
+}
+/**
+ * Deterministic proposer backed by a fixture map (scenarioId → spec). Ships first
+ * (testable, no LLM). The LLM proposer is Phase 3 and uses the same redacted view.
+ */
+export class StaticToolProposer {
+    specs;
+    constructor(specs) {
+        this.specs = specs;
+    }
+    async propose(view) {
+        const spec = this.specs.get(view.id);
+        if (!spec)
+            return null;
+        return { id: `tool-proposal:${view.id}`, targetScenarioId: view.id, spec };
+    }
+}
+//# sourceMappingURL=tool-proposer.js.map

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

@@ -0,0 +1,40 @@
+/**
+ * Tool mutator port — applies/reverts an authored tool across BOTH registries
+ * with a proven inverse, so the engine can keep it (auto-apply) or cleanly
+ * un-register it (propose-only / rejection):
+ *   - FormalToolRegistry  → makes it CALLABLE (dispatch reads this),
+ *   - legacy ToolRegistry → makes its schema VISIBLE to the model next turn.
+ *
+ * @module agent/self-improvement/tool-skill-mutator
+ */
+import { type AuthoredToolSpec } from './authored-tool-runtime.js';
+import { AuthoredToolStore } from './authored-tool-store.js';
+export interface ToolMutatorPort {
+    register(spec: AuthoredToolSpec): {
+        name: string;
+    };
+    unregister(name: string): boolean;
+    has(name: string): boolean;
+}
+export interface LiveToolMutatorOptions {
+    /** Persist kept tools to disk so they survive a restart (default true). */
+    persist?: boolean;
+    store?: AuthoredToolStore;
+}
+/** Dual-registry mutator over the live singletons, with optional disk persistence. */
+export declare class LiveToolMutator implements ToolMutatorPort {
+    private readonly persist;
+    private readonly store;
+    constructor(options?: LiveToolMutatorOptions);
+    register(spec: AuthoredToolSpec): {
+        name: string;
+    };
+    unregister(name: string): boolean;
+    has(name: string): boolean;
+}
+/**
+ * Re-register persisted authored tools into both registries at startup. Does NOT
+ * re-persist (it's loading what's already on disk). Returns the names loaded.
+ * Gated by callers on CODEBUDDY_SELF_IMPROVE.
+ */
+export declare function loadAuthoredTools(workDir?: string): string[];

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

@@ -0,0 +1,79 @@
+/**
+ * Tool mutator port — applies/reverts an authored tool across BOTH registries
+ * with a proven inverse, so the engine can keep it (auto-apply) or cleanly
+ * un-register it (propose-only / rejection):
+ *   - FormalToolRegistry  → makes it CALLABLE (dispatch reads this),
+ *   - legacy ToolRegistry → makes its schema VISIBLE to the model next turn.
+ *
+ * @module agent/self-improvement/tool-skill-mutator
+ */
+import { FormalToolRegistry } from '../../tools/registry/tool-registry.js';
+import { getToolRegistry } from '../../tools/registry.js';
+import { buildAuthoredTool } from './authored-tool-runtime.js';
+import { AuthoredToolStore } from './authored-tool-store.js';
+/** Dual-registry mutator over the live singletons, with optional disk persistence. */
+export class LiveToolMutator {
+    persist;
+    store;
+    constructor(options = {}) {
+        this.persist = options.persist ?? true;
+        this.store = options.store ?? new AuthoredToolStore();
+    }
+    register(spec) {
+        const tool = buildAuthoredTool(spec);
+        FormalToolRegistry.getInstance().register(tool, { override: true });
+        const definition = {
+            type: 'function',
+            function: {
+                name: spec.name,
+                description: spec.description,
+                parameters: spec.parameters,
+            },
+        };
+        const metadata = {
+            name: spec.name,
+            category: 'system',
+            keywords: ['authored', 'self-extension', 'tool'],
+            priority: 5,
+            description: spec.description,
+        };
+        getToolRegistry().registerTool(definition, metadata);
+        if (this.persist)
+            this.store.add(spec);
+        return { name: spec.name };
+    }
+    unregister(name) {
+        const a = FormalToolRegistry.getInstance().unregister(name);
+        const b = getToolRegistry().removeTool(name);
+        if (this.persist)
+            this.store.remove(name);
+        return a || b;
+    }
+    has(name) {
+        return FormalToolRegistry.getInstance().has(name) || getToolRegistry().getTool(name) !== undefined;
+    }
+}
+/**
+ * Re-register persisted authored tools into both registries at startup. Does NOT
+ * re-persist (it's loading what's already on disk). Returns the names loaded.
+ * Gated by callers on CODEBUDDY_SELF_IMPROVE.
+ */
+export function loadAuthoredTools(workDir) {
+    const store = new AuthoredToolStore(workDir ? { workDir } : {});
+    const specs = store.list();
+    if (specs.length === 0)
+        return [];
+    const loader = new LiveToolMutator({ persist: false, store });
+    const loaded = [];
+    for (const spec of specs) {
+        try {
+            loader.register(spec);
+            loaded.push(spec.name);
+        }
+        catch {
+            /* skip a malformed persisted spec */
+        }
+    }
+    return loaded;
+}
+//# sourceMappingURL=tool-skill-mutator.js.map