@phuetz/code-buddy 0.3.0 → 1.0.0-rc.8

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

@@ -0,0 +1,180 @@
+/**
+ * Paired live gate — the execution-grounded validator for GENERAL lessons.
+ *
+ * The retrieval benchmark proves a lesson is *findable*; this proves it *helps*.
+ * For each graded task we run the agent WITH the candidate lesson injected and
+ * WITHOUT it (the lesson is the only delta), grade both deterministically, and
+ * accept the lesson only if it wins on a paired-Bayesian sign test — the
+ * statistically-sound way to decide from FEW noisy paired evals (CLT error bars
+ * are unreliable at N<100; see docs/self-improvement-research-2026.md, Area 1).
+ *
+ * Guards:
+ *  - **Counterfactual ablation pre-filter**: if the lesson changes the agent's
+ *    behavior on NO task, it is inert → reject before spending the full budget.
+ *  - **Safety regression**: a safety task that passes WITHOUT but fails WITH the
+ *    lesson ⇒ immediate reject.
+ *  - **Anytime stopping**: Bayesian posteriors are valid under optional stopping,
+ *    so we evaluate until confident (or the budget is exhausted).
+ *
+ * The agent is injected (AgentRunner) so the math + orchestration are fully
+ * deterministic and unit-testable; production wires a real model.
+ *
+ * @module agent/self-improvement/paired-gate
+ */
+// ── Numerics: regularized incomplete beta I_x(a,b) ──────────────────────────
+/** Lanczos log-gamma. */
+function gammaln(x) {
+    /* eslint-disable no-loss-of-precision -- standard Lanczos series constants */
+    const cof = [
+        76.18009172947146, -86.50532032941677, 24.01409824083091,
+        -1.231739572450155, 0.1208650973866179e-2, -0.5395239384953e-5,
+    ];
+    let ser = 1.000000000190015;
+    /* eslint-enable no-loss-of-precision */
+    let y = x;
+    let tmp = x + 5.5;
+    tmp -= (x + 0.5) * Math.log(tmp);
+    for (let j = 0; j < 6; j++)
+        ser += cof[j] / ++y;
+    return -tmp + Math.log((Math.sqrt(2 * Math.PI) * ser) / x);
+}
+/** Continued fraction for the incomplete beta (Lentz). */
+function betacf(a, b, x) {
+    const MAXIT = 200;
+    const EPS = 3e-12;
+    const FPMIN = 1e-300;
+    const qab = a + b;
+    const qap = a + 1;
+    const qam = a - 1;
+    let c = 1;
+    let d = 1 - (qab * x) / qap;
+    if (Math.abs(d) < FPMIN)
+        d = FPMIN;
+    d = 1 / d;
+    let h = d;
+    for (let m = 1; m <= MAXIT; m++) {
+        const m2 = 2 * m;
+        let aa = (m * (b - m) * x) / ((qam + m2) * (a + m2));
+        d = 1 + aa * d;
+        if (Math.abs(d) < FPMIN)
+            d = FPMIN;
+        c = 1 + aa / c;
+        if (Math.abs(c) < FPMIN)
+            c = FPMIN;
+        d = 1 / d;
+        h *= d * c;
+        aa = (-(a + m) * (qab + m) * x) / ((a + m2) * (qap + m2));
+        d = 1 + aa * d;
+        if (Math.abs(d) < FPMIN)
+            d = FPMIN;
+        c = 1 + aa / c;
+        if (Math.abs(c) < FPMIN)
+            c = FPMIN;
+        d = 1 / d;
+        const del = d * c;
+        h *= del;
+        if (Math.abs(del - 1) < EPS)
+            break;
+    }
+    return h;
+}
+/** Regularized incomplete beta function I_x(a,b) = P(Beta(a,b) ≤ x). */
+export function regularizedBeta(a, b, x) {
+    if (x <= 0)
+        return 0;
+    if (x >= 1)
+        return 1;
+    const lbeta = gammaln(a + b) - gammaln(a) - gammaln(b) + a * Math.log(x) + b * Math.log(1 - x);
+    const bt = Math.exp(lbeta);
+    return x < (a + 1) / (a + b + 2) ? (bt * betacf(a, b, x)) / a : 1 - (bt * betacf(b, a, 1 - x)) / b;
+}
+/**
+ * Bayesian sign test on paired win/loss counts (ties ignored). Posterior on the
+ * win-probability is Beta(wins+1, losses+1); accept when P(rate>0.5) ≥ threshold,
+ * reject when P(rate<0.5) ≥ threshold, else undecided.
+ */
+export function pairedBayesianDecision(wins, losses, threshold = 0.95) {
+    const decisive = wins + losses;
+    const pImprove = decisive === 0 ? 0.5 : 1 - regularizedBeta(wins + 1, losses + 1, 0.5);
+    let decision = 'undecided';
+    if (pImprove >= threshold)
+        decision = 'accept';
+    else if (1 - pImprove >= threshold)
+        decision = 'reject';
+    return { wins, losses, decisive, pImprove, decision };
+}
+/**
+ * Run the paired live gate for a candidate lesson against the graded tasks.
+ * Behavior, not keywords: a lesson is accepted only if it makes the agent solve
+ * tasks it otherwise wouldn't, with statistical confidence and no safety regression.
+ */
+export async function runPairedGate(lessonText, tasks, runner, options = {}) {
+    const threshold = options.threshold ?? 0.95;
+    const earlyStop = options.earlyStop !== false;
+    const base = (options.baseLessons ?? []).join('\n');
+    const withText = [base, lessonText].filter(Boolean).join('\n');
+    const withoutText = base || null;
+    const results = [];
+    let wins = 0;
+    let losses = 0;
+    let changedAny = false;
+    for (const task of tasks) {
+        const resWith = await runner.run(task.prompt, withText);
+        const resWithout = await runner.run(task.prompt, withoutText);
+        const passWith = task.grade(resWith);
+        const passWithout = task.grade(resWithout);
+        const changed = passWith !== passWithout || resWith.text !== resWithout.text;
+        if (changed)
+            changedAny = true;
+        // Safety regression — hard stop.
+        if (task.safety && passWithout && !passWith) {
+            results.push({ taskId: task.id, outcome: 'loss', passWith, passWithout, changed });
+            return {
+                accepted: false,
+                decision: pairedBayesianDecision(wins, losses + 1, threshold),
+                results,
+                changedAny,
+                rejectionReason: 'safety-regression',
+                tasksRun: results.length,
+                notes: [`reverted: safety task "${task.id}" regressed (passed without, failed with)`],
+            };
+        }
+        const outcome = passWith && !passWithout ? 'win' : !passWith && passWithout ? 'loss' : 'tie';
+        if (outcome === 'win')
+            wins++;
+        else if (outcome === 'loss')
+            losses++;
+        results.push({ taskId: task.id, outcome, passWith, passWithout, changed });
+        if (earlyStop) {
+            const d = pairedBayesianDecision(wins, losses, threshold);
+            if (d.decision !== 'undecided')
+                break;
+        }
+    }
+    // Counterfactual ablation: a lesson that changed nothing is inert.
+    if (!changedAny) {
+        return {
+            accepted: false,
+            decision: pairedBayesianDecision(wins, losses, threshold),
+            results,
+            changedAny,
+            rejectionReason: 'inert',
+            tasksRun: results.length,
+            notes: ['lesson changed the agent behavior on no task — inert'],
+        };
+    }
+    const decision = pairedBayesianDecision(wins, losses, threshold);
+    const accepted = decision.decision === 'accept';
+    return {
+        accepted,
+        decision,
+        results,
+        changedAny,
+        ...(accepted ? {} : { rejectionReason: 'not-confident' }),
+        tasksRun: results.length,
+        notes: [
+            `paired sign test: ${wins} win / ${losses} loss → P(improve)=${decision.pImprove.toFixed(3)} (threshold ${threshold})`,
+        ],
+    };
+}
+//# sourceMappingURL=paired-gate.js.map

package/dist/agent/self-improvement/paired-gate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paired-gate.js","sourceRoot":"","sources":["../../../src/agent/self-improvement/paired-gate.ts"],"names":[],"mappings":"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"}

package/dist/agent/self-improvement/paired-runner.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Real-model runner + seed graded tasks for the paired live gate.
+ *
+ * The runner makes ONE model call per condition (lesson injected vs not) and
+ * returns the response text the task grader checks. This is a behavioral signal
+ * — does the lesson change what the model DOES on a task — a real step above
+ * retrievability, while staying cheap (no full agentic loop). It grades the
+ * model's RESPONSE; grading full tool-using execution is the further horizon.
+ *
+ * Lazy + graceful: with no provider configured the runner returns empty text, so
+ * the gate finds the lesson inert rather than crashing.
+ *
+ * @module agent/self-improvement/paired-runner
+ */
+import type { AgentRunner, GradedTask } from './paired-gate.js';
+export declare function createHeadlessRunner(): AgentRunner;
+export declare const SEED_GRADED_TASKS: GradedTask[];

package/dist/agent/self-improvement/paired-runner.js

@@ -0,0 +1,71 @@
+/**
+ * Real-model runner + seed graded tasks for the paired live gate.
+ *
+ * The runner makes ONE model call per condition (lesson injected vs not) and
+ * returns the response text the task grader checks. This is a behavioral signal
+ * — does the lesson change what the model DOES on a task — a real step above
+ * retrievability, while staying cheap (no full agentic loop). It grades the
+ * model's RESPONSE; grading full tool-using execution is the further horizon.
+ *
+ * Lazy + graceful: with no provider configured the runner returns empty text, so
+ * the gate finds the lesson inert rather than crashing.
+ *
+ * @module agent/self-improvement/paired-runner
+ */
+export function createHeadlessRunner() {
+    let clientPromise = null;
+    const getClient = () => {
+        if (!clientPromise) {
+            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 clientPromise;
+    };
+    return {
+        async run(prompt, lessonText) {
+            const client = await getClient();
+            if (!client)
+                return { text: '' };
+            try {
+                const messages = [];
+                if (lessonText)
+                    messages.push({ role: 'system', content: `Relevant lessons to apply:\n${lessonText}` });
+                messages.push({ role: 'user', content: prompt });
+                const response = await client.chat(messages, []);
+                return { text: (response?.choices?.[0]?.message?.content ?? '').trim() };
+            }
+            catch {
+                return { text: '' };
+            }
+        },
+    };
+}
+/**
+ * Seed graded tasks — five paraphrased instances of ONE capability (running a
+ * large test suite efficiently), so a genuinely good lesson can win on enough
+ * paired tasks to reach statistical confidence. A topic-diverse set can never
+ * reach 95% for a single lesson (a lesson only helps its own domain), so the
+ * paired gate must be run against tasks IN the lesson's domain. This seed set
+ * is a demo for test-efficiency lessons; operators curate their own per-capability
+ * task sets the same way they curate the rule corpus (eval curation stays human-gated).
+ */
+const TEST_EFFICIENCY_GRADER = (r) => /path filter|path\/to|test\s+--|-- [\w./*]+test|specific test|single (file|test)/i.test(r.text);
+export const SEED_GRADED_TASKS = [
+    { id: 'test-speed-1', prompt: 'The test suite takes 5 minutes and I only changed one file. In ONE short sentence, the fastest way to run just the relevant tests?', grade: TEST_EFFICIENCY_GRADER },
+    { id: 'test-speed-2', prompt: 'A teammate runs the whole suite every iteration and it is too slow. In ONE short sentence, what should they do instead?', grade: TEST_EFFICIENCY_GRADER },
+    { id: 'test-speed-3', prompt: 'How do I run only the tests in tests/agent/foo.test.ts without running everything? Answer in ONE short sentence.', grade: TEST_EFFICIENCY_GRADER },
+    { id: 'test-speed-4', prompt: 'CI is fine but locally the full test run wastes my time during TDD. In ONE short sentence, the fix?', grade: TEST_EFFICIENCY_GRADER },
+    { id: 'test-speed-5', prompt: 'I keep waiting for ~27000 tests to finish just to check one change. In ONE short sentence, what is the practical fix?', grade: TEST_EFFICIENCY_GRADER },
+];
+//# sourceMappingURL=paired-runner.js.map

package/dist/agent/self-improvement/paired-runner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paired-runner.js","sourceRoot":"","sources":["../../../src/agent/self-improvement/paired-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAWH,MAAM,UAAU,oBAAoB;IAClC,IAAI,aAAa,GAAyC,IAAI,CAAC;IAC/D,MAAM,SAAS,GAAG,GAAkC,EAAE;QACpD,IAAI,CAAC,aAAa,EAAE,CAAC;YACnB,aAAa,GAAG,CAAC,KAAK,IAAI,EAAE;gBAC1B,IAAI,CAAC;oBACH,MAAM,EAAE,qBAAqB,EAAE,GAAG,MAAM,MAAM,CAAC,kCAAkC,CAAC,CAAC;oBACnF,MAAM,EAAE,eAAe,EAAE,GAAG,MAAM,MAAM,CAAC,2BAA2B,CAAC,CAAC;oBACtE,MAAM,QAAQ,GAAG,qBAAqB,EAAE,CAAC;oBACzC,IAAI,CAAC,QAAQ;wBAAE,OAAO,IAAI,CAAC;oBAC3B,OAAO,IAAI,eAAe,CAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,OAAO,CAA6B,CAAC;gBACnH,CAAC;gBAAC,MAAM,CAAC;oBACP,OAAO,IAAI,CAAC;gBACd,CAAC;YACH,CAAC,CAAC,EAAE,CAAC;QACP,CAAC;QACD,OAAO,aAAa,CAAC;IACvB,CAAC,CAAC;IAEF,OAAO;QACL,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU;YAC1B,MAAM,MAAM,GAAG,MAAM,SAAS,EAAE,CAAC;YACjC,IAAI,CAAC,MAAM;gBAAE,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;YACjC,IAAI,CAAC;gBACH,MAAM,QAAQ,GAA6C,EAAE,CAAC;gBAC9D,IAAI,UAAU;oBAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,+BAA+B,UAAU,EAAE,EAAE,CAAC,CAAC;gBACxG,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;gBACjD,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;gBACjD,OAAO,EAAE,IAAI,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;YAC3E,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;YACtB,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,sBAAsB,GAAG,CAAC,CAAmB,EAAW,EAAE,CAC9D,kFAAkF,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AAElG,MAAM,CAAC,MAAM,iBAAiB,GAAiB;IAC7C,EAAE,EAAE,EAAE,cAAc,EAAE,MAAM,EAAE,oIAAoI,EAAE,KAAK,EAAE,sBAAsB,EAAE;IACnM,EAAE,EAAE,EAAE,cAAc,EAAE,MAAM,EAAE,yHAAyH,EAAE,KAAK,EAAE,sBAAsB,EAAE;IACxL,EAAE,EAAE,EAAE,cAAc,EAAE,MAAM,EAAE,kHAAkH,EAAE,KAAK,EAAE,sBAAsB,EAAE;IACjL,EAAE,EAAE,EAAE,cAAc,EAAE,MAAM,EAAE,qGAAqG,EAAE,KAAK,EAAE,sBAAsB,EAAE;IACpK,EAAE,EAAE,EAAE,cAAc,EAAE,MAAM,EAAE,uHAAuH,EAAE,KAAK,EAAE,sBAAsB,EAAE;CACvL,CAAC"}

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

@@ -0,0 +1,59 @@
+/**
+ * Improvement proposers — turn a curriculum target (+ experiences) into a
+ * candidate improvement. The interface is the injection seam: the production
+ * path is an LLM-backed proposer that drafts a lesson from real run friction,
+ * but V1 ships a DETERMINISTIC static proposer so the engine and its empirical
+ * gate stay fully reproducible and testable. Crucially, proposers are kept
+ * structurally separate from the benchmark scenarios (the evals) — the engine
+ * must never author the checks that bless its own changes.
+ *
+ * @module agent/self-improvement/proposer
+ */
+import type { BenchmarkScenario, Experience, ImprovementProposal } from './types.js';
+export interface ImprovementProposer {
+    /** Async so an LLM-backed proposer can draft novel improvements. */
+    propose(scenario: BenchmarkScenario, experiences: Experience[]): Promise<ImprovementProposal | null>;
+}
+export interface LessonDraft {
+    category: 'PATTERN' | 'RULE' | 'CONTEXT' | 'INSIGHT';
+    content: string;
+    context?: string;
+}
+/** Deterministic proposer backed by a fixed scenarioId → draft map. */
+export declare class StaticProposer implements ImprovementProposer {
+    private readonly drafts;
+    constructor(drafts: Map<string, LessonDraft>);
+    propose(scenario: BenchmarkScenario, experiences: Experience[]): Promise<ImprovementProposal | null>;
+}
+/**
+ * Draft a lesson with an LLM. Injected so the proposer stays testable and
+ * provider-agnostic. Returns null to decline (e.g. the model can't help).
+ */
+export type LessonDrafter = (scenario: BenchmarkScenario, experiences: Experience[]) => Promise<LessonDraft | null>;
+/**
+ * LLM-backed proposer — the autonomy leap: it DISCOVERS novel improvements from
+ * real run friction rather than replaying a fixed pack. Generation is creative
+ * (non-deterministic); the empirical gate downstream is deterministic and
+ * rigorous, so a bad draft is simply rejected and rolled back. This is the
+ * Voyager "iterative prompting + self-verification" idea grounded by the DGM
+ * empirical gate.
+ */
+export declare class LlmProposer implements ImprovementProposer {
+    private readonly draft;
+    constructor(draft: LessonDrafter);
+    propose(scenario: BenchmarkScenario, experiences: Experience[]): Promise<ImprovementProposal | null>;
+}
+/**
+ * Build the strict prompt that asks a model to draft ONE durable lesson which
+ * would make the agent handle `scenario` correctly next time, grounded in the
+ * observed `experiences`. Kept here (not in the proposer) so the wiring layer
+ * can pass it to whatever LLM client is available.
+ */
+export declare function buildLessonDraftPrompt(scenario: BenchmarkScenario, experiences: Experience[]): string;
+/**
+ * A curated knowledge pack the static proposer can use to BOOTSTRAP the agent's
+ * lesson library — each draft is then empirically validated by the gate before
+ * it is kept. This is deliberately SEPARATE from SEED_BENCHMARK_SCENARIOS so the
+ * proposer never co-authors its own evals.
+ */
+export declare const SEED_LESSON_DRAFTS: Map<string, LessonDraft>;

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

@@ -0,0 +1,111 @@
+/**
+ * Improvement proposers — turn a curriculum target (+ experiences) into a
+ * candidate improvement. The interface is the injection seam: the production
+ * path is an LLM-backed proposer that drafts a lesson from real run friction,
+ * but V1 ships a DETERMINISTIC static proposer so the engine and its empirical
+ * gate stay fully reproducible and testable. Crucially, proposers are kept
+ * structurally separate from the benchmark scenarios (the evals) — the engine
+ * must never author the checks that bless its own changes.
+ *
+ * @module agent/self-improvement/proposer
+ */
+/** Deterministic proposer backed by a fixed scenarioId → draft map. */
+export class StaticProposer {
+    drafts;
+    constructor(drafts) {
+        this.drafts = drafts;
+    }
+    async propose(scenario, experiences) {
+        const draft = this.drafts.get(scenario.id);
+        if (!draft)
+            return null;
+        return {
+            id: `prop-${scenario.id}`,
+            kind: 'lesson',
+            targetScenarioId: scenario.id,
+            experienceId: experiences[0]?.id,
+            lesson: { category: draft.category, content: draft.content, context: draft.context },
+        };
+    }
+}
+/**
+ * LLM-backed proposer — the autonomy leap: it DISCOVERS novel improvements from
+ * real run friction rather than replaying a fixed pack. Generation is creative
+ * (non-deterministic); the empirical gate downstream is deterministic and
+ * rigorous, so a bad draft is simply rejected and rolled back. This is the
+ * Voyager "iterative prompting + self-verification" idea grounded by the DGM
+ * empirical gate.
+ */
+export class LlmProposer {
+    draft;
+    constructor(draft) {
+        this.draft = draft;
+    }
+    async propose(scenario, experiences) {
+        const draft = await this.draft(scenario, experiences);
+        if (!draft || !draft.content?.trim())
+            return null;
+        return {
+            id: `prop-llm-${scenario.id}`,
+            kind: 'lesson',
+            targetScenarioId: scenario.id,
+            experienceId: experiences[0]?.id,
+            lesson: { category: draft.category, content: draft.content.trim(), context: draft.context },
+        };
+    }
+}
+/**
+ * Build the strict prompt that asks a model to draft ONE durable lesson which
+ * would make the agent handle `scenario` correctly next time, grounded in the
+ * observed `experiences`. Kept here (not in the proposer) so the wiring layer
+ * can pass it to whatever LLM client is available.
+ */
+export function buildLessonDraftPrompt(scenario, experiences) {
+    const evidence = experiences
+        .slice(0, 5)
+        .map((e) => `- [${e.kind}] ${e.detail} (${e.context})`)
+        .join('\n');
+    return [
+        'You maintain an AI coding agent\'s lesson library.',
+        'Write ONE durable, reusable lesson (1-2 sentences) that would make the agent',
+        `handle this recurring situation correctly next time. Situation: ${scenario.description}`,
+        scenario.expectIncludes.length
+            ? `The lesson MUST mention: ${scenario.expectIncludes.join(', ')}.`
+            : '',
+        `It should be retrievable when searching for: "${scenario.query}".`,
+        evidence ? `Observed friction:\n${evidence}` : '',
+        'Reply with ONLY the lesson text — no preamble, no markdown, no secrets.',
+    ]
+        .filter(Boolean)
+        .join('\n');
+}
+/**
+ * A curated knowledge pack the static proposer can use to BOOTSTRAP the agent's
+ * lesson library — each draft is then empirically validated by the gate before
+ * it is kept. This is deliberately SEPARATE from SEED_BENCHMARK_SCENARIOS so the
+ * proposer never co-authors its own evals.
+ */
+export const SEED_LESSON_DRAFTS = new Map([
+    [
+        'npm-test-path-filter',
+        {
+            category: 'RULE',
+            content: 'When running npm test, always pass a path filter (e.g. `npm test -- path/to/file.test.ts`); the full suite is slow.',
+        },
+    ],
+    [
+        'esm-js-extension-imports',
+        {
+            category: 'RULE',
+            content: 'This is an ESM project: relative import statements need a .js extension even when importing a .ts source file.',
+        },
+    ],
+    [
+        'logger-not-console',
+        {
+            category: 'RULE',
+            content: 'Use the logger (src/utils/logger) in production code, not console.log — tests spy on logger and console output is not captured.',
+        },
+    ],
+]);
+//# sourceMappingURL=proposer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"proposer.js","sourceRoot":"","sources":["../../../src/agent/self-improvement/proposer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAkBH,uEAAuE;AACvE,MAAM,OAAO,cAAc;IACI;IAA7B,YAA6B,MAAgC;QAAhC,WAAM,GAAN,MAAM,CAA0B;IAAG,CAAC;IAEjE,KAAK,CAAC,OAAO,CACX,QAA2B,EAC3B,WAAyB;QAEzB,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAC3C,IAAI,CAAC,KAAK;YAAE,OAAO,IAAI,CAAC;QACxB,OAAO;YACL,EAAE,EAAE,QAAQ,QAAQ,CAAC,EAAE,EAAE;YACzB,IAAI,EAAE,QAAQ;YACd,gBAAgB,EAAE,QAAQ,CAAC,EAAE;YAC7B,YAAY,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE;YAChC,MAAM,EAAE,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE;SACrF,CAAC;IACJ,CAAC;CACF;AAWD;;;;;;;GAOG;AACH,MAAM,OAAO,WAAW;IACO;IAA7B,YAA6B,KAAoB;QAApB,UAAK,GAAL,KAAK,CAAe;IAAG,CAAC;IAErD,KAAK,CAAC,OAAO,CACX,QAA2B,EAC3B,WAAyB;QAEzB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QACtD,IAAI,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE;YAAE,OAAO,IAAI,CAAC;QAClD,OAAO;YACL,EAAE,EAAE,YAAY,QAAQ,CAAC,EAAE,EAAE;YAC7B,IAAI,EAAE,QAAQ;YACd,gBAAgB,EAAE,QAAQ,CAAC,EAAE;YAC7B,YAAY,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE;YAChC,MAAM,EAAE,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE;SAC5F,CAAC;IACJ,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAM,UAAU,sBAAsB,CACpC,QAA2B,EAC3B,WAAyB;IAEzB,MAAM,QAAQ,GAAG,WAAW;SACzB,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;SACX,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,OAAO,GAAG,CAAC;SACtD,IAAI,CAAC,IAAI,CAAC,CAAC;IACd,OAAO;QACL,oDAAoD;QACpD,8EAA8E;QAC9E,mEAAmE,QAAQ,CAAC,WAAW,EAAE;QACzF,QAAQ,CAAC,cAAc,CAAC,MAAM;YAC5B,CAAC,CAAC,4BAA4B,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG;YACnE,CAAC,CAAC,EAAE;QACN,iDAAiD,QAAQ,CAAC,KAAK,IAAI;QACnE,QAAQ,CAAC,CAAC,CAAC,uBAAuB,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE;QACjD,yEAAyE;KAC1E;SACE,MAAM,CAAC,OAAO,CAAC;SACf,IAAI,CAAC,IAAI,CAAC,CAAC;AAChB,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAsB;IAC7D;QACE,sBAAsB;QACtB;YACE,QAAQ,EAAE,MAAM;YAChB,OAAO,EACL,qHAAqH;SACxH;KACF;IACD;QACE,0BAA0B;QAC1B;YACE,QAAQ,EAAE,MAAM;YAChB,OAAO,EACL,gHAAgH;SACnH;KACF;IACD;QACE,oBAAoB;QACpB;YACE,QAAQ,EAAE,MAAM;YAChB,OAAO,EACL,iIAAiI;SACpI;KACF;CACF,CAAC,CAAC"}

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

@@ -0,0 +1,66 @@
+/**
+ * RuleLearningEngine — wires the execution-grounded validator into a learning
+ * loop. It learns behavioral RULES whose correctness is measured against real
+ * recorded trajectories (does the rule flag the bad runs and pass the good ones),
+ * not keyword retrievability. Accepted rules persist (structured + as a retrievable
+ * RULE lesson) and are git-reversible like the rest of the learnable state.
+ *
+ * @module agent/self-improvement/rule-engine
+ */
+import { scoreCorpus, type BehavioralCheck, type BehavioralRuleProposal, type LabeledTrajectory, type ExecutionGateOutcome } from './execution-gate.js';
+import type { RuleStore } from './rule-store.js';
+import type { EvolutionaryArchive } from './evolutionary-archive.js';
+import { type Autonomy } from './engine.js';
+export interface RuleProposer {
+    propose(target: LabeledTrajectory, corpus: LabeledTrajectory[], currentRules: BehavioralCheck[]): BehavioralRuleProposal | null;
+}
+/**
+ * Deterministic proposer: for a bad run that currently slips through (should be
+ * flagged but passes), forbid a tool it used that NO compliant run uses — and
+ * that is not inherently read-only. A sound, minimal rule grounded in the
+ * recorded behavior.
+ */
+export declare class HeuristicRuleProposer implements RuleProposer {
+    propose(target: LabeledTrajectory, corpus: LabeledTrajectory[], currentRules: BehavioralCheck[]): BehavioralRuleProposal | null;
+}
+export interface RuleLearningResult {
+    kind: 'rule_learning_cycle';
+    startedAt: string;
+    autonomy: Autonomy;
+    targetId: string | null;
+    proposalId: string | null;
+    gate: ExecutionGateOutcome | null;
+    accuracyBefore: number;
+    accuracyAfter: number;
+    applied: boolean;
+    notes: string[];
+}
+export interface RuleLearningEngineOptions {
+    corpus: LabeledTrajectory[];
+    proposer: RuleProposer;
+    ruleStore: RuleStore;
+    archive?: EvolutionaryArchive;
+    autonomy?: Autonomy;
+    /** Side-effect on accept (e.g. also add a retrievable RULE lesson). */
+    onAccept?: (proposal: BehavioralRuleProposal) => void;
+    now?: () => Date;
+}
+export declare class RuleLearningEngine {
+    private readonly corpus;
+    private readonly proposer;
+    private readonly ruleStore;
+    private readonly archive?;
+    private readonly autonomy;
+    private readonly onAccept?;
+    private readonly now;
+    constructor(options: RuleLearningEngineOptions);
+    /** First trajectory the rule set classifies wrong, preferring fixable should-fail runs. */
+    private selectTarget;
+    runCycle(): RuleLearningResult;
+    runLoop(maxCycles?: number): RuleLearningResult[];
+    status(): {
+        autonomy: Autonomy;
+        score: ReturnType<typeof scoreCorpus>;
+        rules: number;
+    };
+}

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

@@ -0,0 +1,131 @@
+/**
+ * RuleLearningEngine — wires the execution-grounded validator into a learning
+ * loop. It learns behavioral RULES whose correctness is measured against real
+ * recorded trajectories (does the rule flag the bad runs and pass the good ones),
+ * not keyword retrievability. Accepted rules persist (structured + as a retrievable
+ * RULE lesson) and are git-reversible like the rest of the learnable state.
+ *
+ * @module agent/self-improvement/rule-engine
+ */
+import { scoreCorpus, validateBehavioralRule, verdict, } from './execution-gate.js';
+import { resolveAutonomy } from './engine.js';
+/**
+ * Tools that are inherently read-only — a rule about a read-only/safe run must
+ * never forbid these (forbidding `view_file` in a "must stay read-only" rule is
+ * self-evidently wrong). Guards against a degenerate corpus (e.g. a single bad
+ * example with no good runs) producing an over-broad rule.
+ */
+const KNOWN_READ_ONLY_TOOLS = new Set([
+    'view_file', 'read_file', 'list_directory', 'search', 'grep', 'glob', 'tool_search',
+]);
+/**
+ * Deterministic proposer: for a bad run that currently slips through (should be
+ * flagged but passes), forbid a tool it used that NO compliant run uses — and
+ * that is not inherently read-only. A sound, minimal rule grounded in the
+ * recorded behavior.
+ */
+export class HeuristicRuleProposer {
+    propose(target, corpus, currentRules) {
+        // Only act on a should-fail run that currently passes the rule set.
+        if (target.shouldPass || !verdict(currentRules, target.trajectory))
+            return null;
+        const goodTools = new Set(corpus.filter((c) => c.shouldPass).flatMap((c) => c.trajectory.toolNames));
+        const offending = target.trajectory.toolNames.find((tool) => !goodTools.has(tool) && !KNOWN_READ_ONLY_TOOLS.has(tool));
+        if (!offending)
+            return null;
+        const profile = target.trajectory.profile ? `${target.trajectory.profile}-profile` : 'read-only';
+        return {
+            id: `rule-forbid-${offending}`,
+            statement: `A ${profile} run must not call ${offending}.`,
+            check: { kind: 'forbid_tool', pattern: `^${escapeRe(offending)}$` },
+        };
+    }
+}
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+export class RuleLearningEngine {
+    corpus;
+    proposer;
+    ruleStore;
+    archive;
+    autonomy;
+    onAccept;
+    now;
+    constructor(options) {
+        this.corpus = options.corpus;
+        this.proposer = options.proposer;
+        this.ruleStore = options.ruleStore;
+        this.archive = options.archive;
+        this.autonomy = options.autonomy ?? resolveAutonomy();
+        this.onAccept = options.onAccept;
+        this.now = options.now ?? (() => new Date());
+    }
+    /** First trajectory the rule set classifies wrong, preferring fixable should-fail runs. */
+    selectTarget(rules) {
+        const misclassified = this.corpus.filter((c) => verdict(rules, c.trajectory) !== c.shouldPass);
+        // A should-fail run that currently passes is fixable by adding a forbid rule.
+        return misclassified.find((c) => !c.shouldPass) ?? misclassified[0] ?? null;
+    }
+    runCycle() {
+        const startedAt = this.now().toISOString();
+        const rules = this.ruleStore.checks();
+        const before = scoreCorpus(rules, this.corpus);
+        const base = {
+            kind: 'rule_learning_cycle',
+            startedAt,
+            autonomy: this.autonomy,
+            accuracyBefore: before.accuracy,
+        };
+        const target = this.selectTarget(rules);
+        if (!target) {
+            return { ...base, targetId: null, proposalId: null, gate: null, accuracyAfter: before.accuracy, applied: false, notes: ['corpus fully classified — nothing to learn'] };
+        }
+        const proposal = this.proposer.propose(target, this.corpus, rules);
+        if (!proposal) {
+            return { ...base, targetId: target.id, proposalId: null, gate: null, accuracyAfter: before.accuracy, applied: false, notes: [`no rule proposal for "${target.id}"`] };
+        }
+        const gate = validateBehavioralRule(proposal, rules, this.corpus);
+        const applied = gate.accepted && this.autonomy === 'auto-apply';
+        if (applied) {
+            this.ruleStore.add(proposal.check, proposal.statement);
+            this.onAccept?.(proposal);
+            this.archive?.append({
+                proposalId: proposal.id,
+                kind: 'lesson',
+                targetScenarioId: target.id,
+                delta: gate.delta,
+                scoreAfter: gate.accuracyAfter,
+                reviewedBy: 'auto:self-improve:rule',
+            });
+        }
+        const after = scoreCorpus(this.ruleStore.checks(), this.corpus);
+        return {
+            ...base,
+            targetId: target.id,
+            proposalId: proposal.id,
+            gate,
+            accuracyAfter: after.accuracy,
+            applied,
+            notes: gate.notes,
+        };
+    }
+    runLoop(maxCycles = this.corpus.length + 1) {
+        const results = [];
+        for (let i = 0; i < Math.max(1, maxCycles); i++) {
+            const r = this.runCycle();
+            results.push(r);
+            if (!r.applied)
+                break;
+        }
+        return results;
+    }
+    status() {
+        return {
+            autonomy: this.autonomy,
+            score: scoreCorpus(this.ruleStore.checks(), this.corpus),
+            rules: this.ruleStore.list().length,
+        };
+    }
+}
+//# sourceMappingURL=rule-engine.js.map