@phuetz/code-buddy 1.2.0 → 1.3.0

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 {};

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

@@ -0,0 +1,137 @@
+/**
+ * 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 { coversScenario } from './skill-gate.js';
+import { safetyGateSkill, toAuthoredSkillName } from './skill-mutator.js';
+/** Build a cluster from installed authored skills that map to a known scenario. */
+export function buildClusterFromInstalled(mutator, scenarios) {
+    const installed = new Set(mutator.listAuthored());
+    const siblings = [];
+    for (const scenario of scenarios) {
+        const name = toAuthoredSkillName(scenario.id);
+        if (installed.has(name))
+            siblings.push({ name, scenario });
+    }
+    return { siblings };
+}
+export async function consolidateCluster(cluster, proposer, mutator, archive, options) {
+    const skippedPinned = cluster.siblings.filter((s) => mutator.isPinned(s.name)).map((s) => s.name);
+    const mergeable = cluster.siblings.filter((s) => !mutator.isPinned(s.name));
+    if (mergeable.length < 2) {
+        return { accepted: false, absorbed: [], skippedPinned, rejectionReason: 'cluster-too-small', reasons: ['need ≥2 non-pinned authored skills to consolidate'] };
+    }
+    const proposal = await proposer.propose({ siblings: mergeable });
+    if (!proposal || !proposal.content.trim()) {
+        return { accepted: false, absorbed: [], skippedPinned, rejectionReason: 'no-proposal', reasons: ['no umbrella proposal'] };
+    }
+    // Gate 1 — the umbrella content must be safe.
+    const gate = safetyGateSkill(proposal.content);
+    if (!gate.ok) {
+        return { accepted: false, absorbed: [], skippedPinned, rejectionReason: 'firewall', reasons: gate.reasons };
+    }
+    // Gate 2 (the distinctive one) — the umbrella must still cover EVERY merged
+    // sibling's scenario. A consolidation that loses coverage is rejected.
+    const lost = mergeable.filter((s) => !coversScenario(proposal.content, s.scenario)).map((s) => s.scenario.id);
+    if (lost.length > 0) {
+        return { accepted: false, absorbed: [], skippedPinned, rejectionReason: 'coverage-loss', reasons: [`umbrella drops coverage for: ${lost.join(', ')}`] };
+    }
+    const umbrellaName = toAuthoredSkillName(proposal.name);
+    if (!options.keepOnAccept) {
+        return { accepted: true, umbrellaName, absorbed: [], skippedPinned, reasons: ['accepted (propose-only): umbrella safe + covers all merged scenarios, not installed'] };
+    }
+    // Install the umbrella, archive the merged siblings (recoverable), audit each.
+    mutator.create({ name: umbrellaName, description: `Umbrella skill consolidating ${mergeable.length} authored skills`, content: proposal.content });
+    const absorbed = [];
+    for (const s of mergeable) {
+        if (s.name === umbrellaName)
+            continue; // never archive the umbrella itself
+        if (mutator.archive(s.name)) {
+            absorbed.push(s.name);
+            archive.append({
+                proposalId: `consolidate:${umbrellaName}`,
+                kind: 'skill',
+                targetScenarioId: s.scenario.id,
+                delta: 0,
+                scoreAfter: 1,
+                appliedRef: umbrellaName,
+                absorbedInto: umbrellaName,
+            });
+        }
+    }
+    return { accepted: true, umbrellaName, absorbed, skippedPinned, reasons: [`consolidated ${absorbed.length} skill(s) into ${umbrellaName}`] };
+}
+// ── proposers ────────────────────────────────────────────────────────────────
+/** Deterministic umbrella proposer (fixture for tests). */
+export class StaticUmbrellaProposer {
+    umbrella;
+    constructor(umbrella) {
+        this.umbrella = umbrella;
+    }
+    async propose() {
+        return this.umbrella;
+    }
+}
+export class LlmUmbrellaProposer {
+    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(cluster) {
+        const client = await this.getClient();
+        if (!client)
+            return null;
+        const terms = cluster.siblings.flatMap((s) => s.scenario.expectIncludes);
+        const topics = cluster.siblings.map((s) => `- ${s.scenario.query}`).join('\n');
+        const prompt = [
+            'Merge these related guidance topics into ONE broader "umbrella" SKILL.md with',
+            'labeled subsections — one per topic. Keep ALL the practical guidance; do not drop',
+            `any topic. The umbrella MUST still mention every one of these terms: ${JSON.stringify(terms)}.`,
+            '',
+            'Topics:',
+            topics,
+            '',
+            'Return ONLY the umbrella SKILL.md markdown (a title, then a subsection per topic).',
+            'Do NOT include any instruction to ignore safety, reveal/exfiltrate secrets, or run',
+            'destructive commands.',
+        ].join('\n');
+        try {
+            const response = await client.chat([{ role: 'user', content: prompt }], []);
+            const content = response?.choices?.[0]?.message?.content?.trim();
+            if (!content)
+                return null;
+            return { name: 'consolidated-skills', content };
+        }
+        catch {
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=skill-consolidator.js.map

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

@@ -0,0 +1,42 @@
+/**
+ * SkillImprovementEngine — the skill sibling of the tool engine. One cycle:
+ *   pick an uncovered skill scenario → propose a SKILL.md → skill gate
+ *   (static scan → firewall → coverage) → install+archive (auto-apply) or report.
+ *
+ * @module agent/self-improvement/skill-engine
+ */
+import { EvolutionaryArchive } from './evolutionary-archive.js';
+import { type Autonomy } from './engine.js';
+import { type SkillMutatorPort } from './skill-mutator.js';
+import type { SkillProposer } from './skill-proposer.js';
+import type { SkillBenchmarkScenario, SkillGateOutcome } from './skill-types.js';
+export interface SkillCycleResult {
+    kind: 'skill_improvement_cycle';
+    startedAt: string;
+    autonomy: Autonomy;
+    selectedScenarioId: string | null;
+    proposalId: string | null;
+    gate: SkillGateOutcome | null;
+    applied: boolean;
+    notes: string[];
+}
+export interface SkillImprovementEngineOptions {
+    scenarios: SkillBenchmarkScenario[];
+    proposer: SkillProposer;
+    mutator?: SkillMutatorPort;
+    archive?: EvolutionaryArchive;
+    autonomy?: Autonomy;
+    now?: () => Date;
+}
+export declare class SkillImprovementEngine {
+    private readonly scenarios;
+    private readonly proposer;
+    private readonly mutator;
+    private readonly archive;
+    private readonly autonomy;
+    private readonly now;
+    private readonly covered;
+    constructor(options: SkillImprovementEngineOptions);
+    runCycle(): Promise<SkillCycleResult>;
+    runLoop(maxCycles?: number): Promise<SkillCycleResult[]>;
+}

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

@@ -0,0 +1,87 @@
+/**
+ * SkillImprovementEngine — the skill sibling of the tool engine. One cycle:
+ *   pick an uncovered skill scenario → propose a SKILL.md → skill gate
+ *   (static scan → firewall → coverage) → install+archive (auto-apply) or report.
+ *
+ * @module agent/self-improvement/skill-engine
+ */
+import { EvolutionaryArchive } from './evolutionary-archive.js';
+import { resolveAutonomy } from './engine.js';
+import { validateSkillProposal } from './skill-gate.js';
+import { LiveSkillMutator } from './skill-mutator.js';
+export class SkillImprovementEngine {
+    scenarios;
+    proposer;
+    mutator;
+    archive;
+    autonomy;
+    now;
+    covered = new Set();
+    constructor(options) {
+        this.scenarios = options.scenarios;
+        this.proposer = options.proposer;
+        this.mutator = options.mutator ?? new LiveSkillMutator();
+        this.archive = options.archive ?? new EvolutionaryArchive();
+        this.autonomy = options.autonomy ?? resolveAutonomy();
+        this.now = options.now ?? (() => new Date());
+    }
+    async runCycle() {
+        const startedAt = this.now().toISOString();
+        const base = { kind: 'skill_improvement_cycle', startedAt, autonomy: this.autonomy };
+        for (const scenario of this.scenarios) {
+            if (this.covered.has(scenario.id))
+                continue;
+            const proposal = await this.proposer.propose(scenario);
+            if (!proposal)
+                continue;
+            if (this.mutator.has(proposal.spec.name)) {
+                this.covered.add(scenario.id);
+                continue;
+            }
+            const gate = validateSkillProposal(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: 'skill',
+                    targetScenarioId: scenario.id,
+                    experienceId: proposal.experienceId,
+                    delta: 1,
+                    scoreAfter: 1,
+                    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 skill scenario with an available proposal'],
+        };
+    }
+    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;
+    }
+}
+//# sourceMappingURL=skill-engine.js.map

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

@@ -0,0 +1,19 @@
+/**
+ * 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 { type SkillMutatorPort } from './skill-mutator.js';
+import type { SkillBenchmarkScenario, SkillGateOutcome, SkillProposal } from './skill-types.js';
+export interface ValidateSkillOptions {
+    keepOnAccept: boolean;
+}
+/** Deterministic coverage check: the skill content surfaces all expected guidance. */
+export declare function coversScenario(content: string, scenario: SkillBenchmarkScenario): boolean;
+export declare function validateSkillProposal(proposal: SkillProposal, scenario: SkillBenchmarkScenario, mutator: SkillMutatorPort, options: ValidateSkillOptions): SkillGateOutcome;