@phuetz/code-buddy 2.0.0 → 2.2.0

package/dist/agent/self-improvement/evolution/code-variant-store.d.ts

@@ -6,10 +6,13 @@
  *
  * @module agent/self-improvement/evolution/code-variant-store
  */
+import type { FitnessReport } from './variant-fitness.js';
 export interface VariantRecord {
     id: string;
     branch: string;
     sha: string;
+    baselineSha?: string;
+    fitness?: FitnessReport;
     /** Aggregate fitness in [0,1]. */
     score: number;
     passedAll: boolean;

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

@@ -366,6 +366,8 @@ export async function runEvolutionCycle(opts) {
         id: variantId,
         branch,
         sha,
+        baselineSha: git(['rev-parse', '--verify', `${opts.baselineRef}^{commit}`], basePath).trim(),
+        fitness: report,
         score: report.score,
         passedAll: report.passedAll,
         regressions: report.regressions,

package/dist/agent/self-improvement/evolution/protected-paths.js

@@ -29,8 +29,14 @@ export const PROTECTED_GLOBS = [
     'src/agent/self-improvement/paired-runner.ts',
     'src/agent/self-improvement/tool-proposer.ts',
     'src/agent/self-improvement/self-knowledge.ts',
+    // Application receipts and replay must not be rewritten by a scored candidate.
+    'src/agent/self-improvement/skill-apply-journal.ts',
+    'src/agent/self-improvement/skill-engine.ts',
+    'src/agent/self-improvement/evolutionary-archive.ts',
     // Security scanners the skill firewall relies on
     'src/security/skill-scanner.ts',
+    'src/security/compute-confinement.ts',
+    'src/agent/self-improvement/authored-tool-runtime.ts',
     'src/security/dangerous-patterns.ts',
     // Tests that verify the gates / self-improvement (used by the fitness unit-tests component)
     'tests/agent/self-improvement/**',

package/dist/agent/self-improvement/evolution/variant-fitness.d.ts

@@ -19,6 +19,8 @@ export interface FitnessContext {
     checkoutDir: string;
     /** Per-process timeout for a component's subprocess. */
     timeoutMs?: number;
+    /** Cancel the subprocess and its process group. */
+    signal?: AbortSignal;
     /** Env for subprocesses. Callers may pass a SCRUBBED env (no host secrets) for untrusted variants. */
     env?: NodeJS.ProcessEnv;
 }
@@ -46,7 +48,14 @@ export interface FitnessReport {
     /** Component names that regressed vs a baseline (score dropped or pass→fail). */
     regressions: string[];
 }
-/** Run a subprocess in the checkout, capped output + timeout. Never throws (resolves with code). */
+/** Execute checkout-owned JavaScript CLIs directly, preserving argv on every OS. */
+export declare function runCheckoutCli(modulePath: string, args: string[], ctx: FitnessContext): Promise<{
+    code: number;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+}>;
+/** Run a bounded subprocess; terminate its process group on timeout. */
 export declare function runProc(cmd: string, args: string[], ctx: FitnessContext): Promise<{
     code: number;
     stdout: string;
@@ -79,8 +88,10 @@ export declare function unitTestsComponent(patterns: string[], weight?: number):
  * STOCHASTIC (LLM calls) — opt-in. Requires the checkout to be built (dist/index.js).
  */
 export declare function evalTasksComponent(tasks?: string[], weight?: number): FitnessComponent;
+/** Protected, offline task objective. Guard checks can be green while task success improves. */
+export declare function harnessTasksComponent(weight?: number): FitnessComponent;
 /** Default deterministic set → a fast, reproducible baseline (no LLM, no build). */
-export declare function defaultDeterministicComponents(): FitnessComponent[];
+export declare function defaultDeterministicComponents(guardsOnly?: boolean): FitnessComponent[];
 export declare function detectRegressions(baseline: FitnessReport, current: ComponentResult[], eps?: number): string[];
 /** Run components, aggregate to a weighted [0,1] fitness, flag regressions vs an optional baseline. */
 export declare function computeFitness(ctx: FitnessContext, components: FitnessComponent[], baseline?: FitnessReport): Promise<FitnessReport>;

package/dist/agent/self-improvement/evolution/variant-fitness.js

@@ -14,60 +14,131 @@
  *
  * @module agent/self-improvement/evolution/variant-fitness
  */
-import { spawn } from 'child_process';
-import { existsSync, readdirSync, statSync } from 'fs';
+import { spawn, execFile } from 'child_process';
+import { existsSync, readdirSync, statSync, mkdtempSync, readFileSync, rmSync } from 'fs';
 import { join } from 'path';
+import { tmpdir } from 'node:os';
+import { stripVTControlCharacters } from 'node:util';
+import { createRequire } from 'node:module';
+import { dirname, resolve } from 'node:path';
 const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
 function msg(e) {
     return e instanceof Error ? e.message : String(e);
 }
-/** Run a subprocess in the checkout, capped output + timeout. Never throws (resolves with code). */
+/** Execute checkout-owned JavaScript CLIs directly, preserving argv on every OS. */
+export function runCheckoutCli(modulePath, args, ctx) {
+    try {
+        const require = createRequire(resolve(ctx.checkoutDir, 'package.json'));
+        // Vitest exports its manifest but deliberately does not export its CLI subpath.
+        const cli = modulePath === 'vitest/vitest.mjs'
+            ? join(dirname(require.resolve('vitest/package.json')), 'vitest.mjs')
+            : require.resolve(modulePath);
+        return runProc(process.execPath, [cli, ...args], ctx);
+    }
+    catch (error) {
+        return Promise.resolve({ code: 1, stdout: '', stderr: msg(error), timedOut: false });
+    }
+}
+/** Run a bounded subprocess; terminate its process group on timeout. */
 export function runProc(cmd, args, ctx) {
     return new Promise((resolve) => {
+        const MAX = 1_000_000;
+        const windows = process.platform === 'win32';
         let stdout = '';
         let stderr = '';
         let timedOut = false;
-        const MAX = 1_000_000;
+        let settled = false;
+        let stopping = false;
         let child;
+        let timer;
+        let escalation;
+        const stopTree = (signal) => {
+            const pid = child?.pid;
+            if (!pid)
+                return Promise.resolve();
+            if (windows) {
+                return new Promise(done => {
+                    execFile('taskkill', ['/F', '/T', '/PID', String(pid)], { windowsHide: true, timeout: 2000 }, error => {
+                        if (error) {
+                            try {
+                                child?.kill(signal);
+                            }
+                            catch { /* already gone */ }
+                        }
+                        done();
+                    });
+                });
+            }
+            try {
+                process.kill(-pid, signal);
+            }
+            catch { /* group already gone */ }
+            return Promise.resolve();
+        };
+        const settle = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            clearTimeout(escalation);
+            ctx.signal?.removeEventListener('abort', abort);
+            child?.stdout?.destroy();
+            child?.stderr?.destroy();
+            child?.unref();
+            resolve({ code, stdout, stderr, timedOut });
+        };
+        const stop = (code, timeout) => {
+            if (settled || stopping)
+                return;
+            stopping = true;
+            timedOut = timeout;
+            clearTimeout(timer);
+            void stopTree('SIGTERM');
+            escalation = setTimeout(() => {
+                void stopTree('SIGKILL').finally(() => settle(code));
+            }, 250);
+        };
+        const abort = () => {
+            stderr = (stderr + 'Operation cancelled').slice(0, MAX);
+            stop(130, false);
+        };
+        if (ctx.signal?.aborted) {
+            stderr = 'Operation cancelled before spawn';
+            settle(130);
+            return;
+        }
         try {
-            child = spawn(cmd, args, { cwd: ctx.checkoutDir, env: ctx.env ?? process.env });
+            child = spawn(cmd, args, {
+                cwd: ctx.checkoutDir, env: ctx.env ?? process.env,
+                detached: !windows,
+                windowsHide: true,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
         }
-        catch (err) {
-            resolve({ code: 1, stdout: '', stderr: msg(err), timedOut: false });
+        catch (error) {
+            stderr = msg(error).slice(0, MAX);
+            settle(1);
             return;
         }
-        const timer = setTimeout(() => {
-            timedOut = true;
-            try {
-                child.kill('SIGTERM');
-                setTimeout(() => {
-                    try {
-                        child.kill('SIGKILL');
-                    }
-                    catch {
-                        /* already gone */
-                    }
-                }, 1000);
-            }
-            catch {
-                /* ignore */
-            }
-        }, ctx.timeoutMs ?? DEFAULT_TIMEOUT_MS);
-        child.stdout?.on('data', (d) => {
-            if (stdout.length < MAX)
-                stdout += d.toString();
+        ctx.signal?.addEventListener('abort', abort, { once: true });
+        timer = setTimeout(() => stop(1, true), ctx.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+        if (ctx.signal?.aborted)
+            abort();
+        child.stdout?.on('data', chunk => { stdout += chunk.toString().slice(0, Math.max(0, MAX - stdout.length)); });
+        child.stderr?.on('data', chunk => { stderr += chunk.toString().slice(0, Math.max(0, MAX - stderr.length)); });
+        child.once('error', error => {
+            if (settled)
+                return;
+            stderr = (stderr + msg(error)).slice(0, MAX);
+            if (!stopping)
+                void stopTree('SIGKILL').finally(() => settle(1));
         });
-        child.stderr?.on('data', (d) => {
-            if (stderr.length < MAX)
-                stderr += d.toString();
-        });
-        child.on('error', (err) => {
+        child.once('close', code => {
+            if (settled || stopping)
+                return;
             clearTimeout(timer);
-            resolve({ code: 1, stdout, stderr: stderr + msg(err), timedOut });
-        });
-        child.on('close', (code) => {
-            clearTimeout(timer);
-            resolve({ code: code ?? 1, stdout, stderr, timedOut });
+            // A completed evaluation must not leave background work in its checkout.
+            void stopTree('SIGKILL').finally(() => settle(code ?? 1));
         });
     });
 }
@@ -76,8 +147,17 @@ function lastLines(s, n = 8) {
 }
 /** Parse vitest summary lines: "Tests  3 passed (3)" / "Tests  2 failed | 5 passed (7)". */
 export function parseVitestCounts(out) {
-    const passed = /(\d+)\s+passed/.exec(out);
-    const failed = /(\d+)\s+failed/.exec(out);
+    try {
+        const report = JSON.parse(out);
+        const passed = report.numPassedTests;
+        const failed = report.numFailedTests;
+        if (typeof passed === 'number' && Number.isSafeInteger(passed) && passed >= 0 && typeof failed === 'number' && Number.isSafeInteger(failed) && failed >= 0)
+            return { passed, failed };
+    }
+    catch { /* Compatibility for recorded human-readable summaries. */ }
+    const summary = stripVTControlCharacters(out).split('\n').find(line => /^\s*Tests\s/.test(line)) ?? '';
+    const passed = /(\d+)\s+passed/.exec(summary);
+    const failed = /(\d+)\s+failed/.exec(summary);
     return { passed: passed ? Number(passed[1]) : 0, failed: failed ? Number(failed[1]) : 0 };
 }
 export function listEvalTasks(checkoutDir) {
@@ -101,7 +181,7 @@ export function typecheckComponent(weight = 3) {
         weight,
         deterministic: true,
         async run(ctx) {
-            const r = await runProc('npx', ['tsc', '--noEmit'], ctx);
+            const r = await runCheckoutCli('typescript/bin/tsc', ['--noEmit'], ctx);
             const passed = r.code === 0 && !r.timedOut;
             return {
                 name: 'typecheck',
@@ -134,18 +214,27 @@ export function unitTestsComponent(patterns, weight = 4) {
         weight,
         deterministic: true,
         async run(ctx) {
-            const r = await runProc('npx', ['vitest', 'run', ...patterns], ctx);
-            const { passed, failed } = parseVitestCounts(r.stdout + r.stderr);
-            const total = passed + failed;
-            const { score, passed: passedFlag } = scoreVitestRun(passed, failed, r.code, r.timedOut);
-            return {
-                name: 'unit-tests',
-                weight,
-                score,
-                passed: passedFlag,
-                detail: total > 0 ? `${passed} passed / ${failed} failed` : `no tests collected — ${lastLines(r.stdout + r.stderr, 4)}`,
-                metrics: { passed, failed },
-            };
+            const dir = mkdtempSync(join(tmpdir(), 'cb-fitness-'));
+            try {
+                const file = join(dir, 'vitest.json');
+                const r = await runCheckoutCli('vitest/vitest.mjs', ['run', ...patterns, '--reporter=json', `--outputFile=${file}`], ctx);
+                // A separate report avoids mixing tool/subprocess stdout with the machine-readable results.
+                if (statSync(file).size > 16 * 1024 * 1024)
+                    throw new Error('Test report exceeds 16 MiB');
+                const raw = readFileSync(file, 'utf8');
+                const parsed = JSON.parse(raw);
+                if (!Number.isSafeInteger(parsed.numPassedTests) || !Number.isSafeInteger(parsed.numFailedTests) || Number(parsed.numPassedTests) < 0 || Number(parsed.numFailedTests) < 0)
+                    throw new Error('Invalid test report counts');
+                const { passed, failed } = parseVitestCounts(raw);
+                const { score, passed: passedFlag } = scoreVitestRun(passed, failed, r.code, r.timedOut);
+                return { name: 'unit-tests', weight, score, passed: passedFlag, detail: `${passed} passed / ${failed} failed`, metrics: { passed, failed } };
+            }
+            catch (error) {
+                return { name: 'unit-tests', weight, score: 0, passed: false, detail: `Missing or invalid Vitest report: ${msg(error)}` };
+            }
+            finally {
+                rmSync(dir, { recursive: true, force: true });
+            }
         },
     };
 }
@@ -163,26 +252,60 @@ export function evalTasksComponent(tasks, weight = 5) {
             if (all.length === 0) {
                 return { name: 'eval-tasks', weight, score: 0, passed: false, detail: 'no eval tasks found' };
             }
+            const build = await runCheckoutCli('typescript/bin/tsc', [], ctx);
+            if (build.code !== 0 || build.timedOut)
+                return { name: 'eval-tasks', weight, score: 0, passed: false, detail: 'candidate build failed' };
             let pass = 0;
+            let completed = true;
+            const outcomes = {};
             for (const t of all) {
                 const r = await runProc(process.execPath, ['eval/run-task.mjs', t], ctx);
-                if (r.code === 0 && !r.timedOut)
+                const ok = r.code === 0 && !r.timedOut;
+                if (ok)
                     pass++;
+                if (r.timedOut)
+                    completed = false;
+                outcomes[`task:${t}`] = ok ? 1 : 0;
             }
             return {
                 name: 'eval-tasks',
                 weight,
                 score: pass / all.length,
-                passed: pass === all.length,
+                // Completion is the gate; task success is a graded optimization signal.
+                passed: completed,
                 detail: `${pass}/${all.length} eval tasks passed`,
-                metrics: { passed: pass, total: all.length },
+                metrics: { passed: pass, total: all.length, ...outcomes },
             };
         },
     };
 }
+/** Protected, offline task objective. Guard checks can be green while task success improves. */
+export function harnessTasksComponent(weight = 5) {
+    return {
+        name: 'harness-tasks', weight, deterministic: true,
+        async run(ctx) {
+            const build = await runCheckoutCli('typescript/bin/tsc', [], ctx);
+            if (build.code !== 0 || build.timedOut)
+                return { name: 'harness-tasks', weight, score: 0, passed: false, detail: 'candidate build failed' };
+            const result = await runProc(process.execPath, ['eval/harness-benchmark.mjs'], ctx);
+            try {
+                const lines = result.stdout.trim().split('\n');
+                const report = JSON.parse(lines[lines.length - 1] ?? '');
+                const entries = Object.entries(report.results ?? {});
+                if (result.code !== 0 || result.timedOut || report.kind !== 'harness_benchmark' || !entries.length || entries.some(([, value]) => typeof value !== 'boolean'))
+                    throw new Error('Invalid harness benchmark report');
+                const pass = entries.filter(([, value]) => value).length;
+                return { name: 'harness-tasks', weight, passed: true, score: pass / entries.length, detail: `${pass}/${entries.length} harness tasks passed`, metrics: Object.fromEntries(entries.map(([id, value]) => [`task:${id}`, value ? 1 : 0])) };
+            }
+            catch {
+                return { name: 'harness-tasks', weight, score: 0, passed: false, detail: 'harness benchmark failed or emitted an invalid report' };
+            }
+        },
+    };
+}
 /** Default deterministic set → a fast, reproducible baseline (no LLM, no build). */
-export function defaultDeterministicComponents() {
-    return [typecheckComponent(), unitTestsComponent(['tests/agent/self-improvement'])];
+export function defaultDeterministicComponents(guardsOnly = false) {
+    return [typecheckComponent(guardsOnly ? 0 : 3), unitTestsComponent(['tests/agent/self-improvement'], guardsOnly ? 0 : 4)];
 }
 // ---- Aggregation (pure, unit-tested) ------------------------------------------------------
 export function detectRegressions(baseline, current, eps = 1e-9) {
@@ -192,9 +315,12 @@ export function detectRegressions(baseline, current, eps = 1e-9) {
         const b = byName.get(r.name);
         if (!b)
             continue;
-        if (r.score < b.score - eps || (b.passed && !r.passed))
+        if (r.score < b.score - eps || (b.passed && !r.passed) || Object.entries(b.metrics ?? {}).some(([key, value]) => key.startsWith('task:') && (r.metrics?.[key] ?? -1) < value))
             out.push(r.name);
     }
+    for (const b of baseline.components)
+        if (!current.some(c => c.name === b.name))
+            out.push(b.name);
     return out;
 }
 /** Run components, aggregate to a weighted [0,1] fitness, flag regressions vs an optional baseline. */

package/dist/agent/self-improvement/evolution/worktree-scorer.d.ts

@@ -42,3 +42,5 @@ export interface ScoreBranchResult {
  * cleanup; throws only if the worktree cannot be created.
  */
 export declare function scoreBranchInWorktree(branch: string, opts?: ScoreBranchOptions): Promise<ScoreBranchResult>;
+/** Score exactly a pinned commit, including when that commit is already checked out elsewhere. */
+export declare function scoreReferenceInWorktree(ref: string, opts?: ScoreBranchOptions): Promise<ScoreBranchResult>;

package/dist/agent/self-improvement/evolution/worktree-scorer.js

@@ -10,6 +10,8 @@
  *
  * @module agent/self-improvement/evolution/worktree-scorer
  */
+import { execFileSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import { existsSync, symlinkSync } from 'fs';
 import { join } from 'path';
 import { logger } from '../../../utils/logger.js';
@@ -96,4 +98,17 @@ function linkNodeModules(basePath, worktreePath) {
         logger.warn(`[evolve] node_modules symlink failed: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
+/** Score exactly a pinned commit, including when that commit is already checked out elsewhere. */
+export async function scoreReferenceInWorktree(ref, opts = {}) {
+    const cwd = opts.basePath ?? process.cwd();
+    const sha = execFileSync('git', ['rev-parse', '--verify', `${ref}^{commit}`], { cwd, encoding: 'utf8' }).trim();
+    const branch = `codebuddy/evaluate/${randomUUID()}`;
+    execFileSync('git', ['branch', branch, sha], { cwd });
+    try {
+        return await scoreBranchInWorktree(branch, { ...opts, baselineRef: sha });
+    }
+    finally {
+        execFileSync('git', ['branch', '-D', branch], { cwd, stdio: 'ignore' });
+    }
+}
 //# sourceMappingURL=worktree-scorer.js.map

package/dist/agent/self-improvement/evolutionary-archive.d.ts

@@ -13,6 +13,7 @@ export interface EvolutionaryArchiveOptions {
     now?: () => Date;
 }
 export declare class EvolutionaryArchive {
+    readonly workDir: string;
     private readonly filePath;
     private readonly now;
     constructor(options?: EvolutionaryArchiveOptions);
@@ -20,7 +21,7 @@ export declare class EvolutionaryArchive {
     private read;
     private write;
     list(): ArchiveEntry[];
-    /** Append a validated improvement. Returns the stored entry. */
+    /** Append a validated improvement. Idempotent on kind+proposalId+targetScenarioId. */
     append(entry: Omit<ArchiveEntry, 'createdAt' | 'reviewedBy'> & {
         reviewedBy?: string;
     }): ArchiveEntry;

package/dist/agent/self-improvement/evolutionary-archive.js

@@ -11,17 +11,35 @@ import path from 'path';
 import { readJsonAtomicSync, writeJsonAtomicSync } from '../../utils/atomic-write.js';
 export const SELF_IMPROVEMENT_ARCHIVE_SCHEMA_VERSION = 1;
 export class EvolutionaryArchive {
+    workDir;
     filePath;
     now;
     constructor(options = {}) {
-        const root = options.workDir ?? process.cwd();
-        this.filePath = path.join(root, '.codebuddy', 'self-improvement', 'archive.json');
+        this.workDir = options.workDir ?? process.cwd();
+        this.filePath = path.join(this.workDir, '.codebuddy', 'self-improvement', 'archive.json');
         this.now = options.now ?? (() => new Date());
     }
     get path() {
         return this.filePath;
     }
-    read() {
+    read(strict = false) {
+        if (strict) {
+            let raw;
+            try {
+                raw = fs.readFileSync(this.filePath, 'utf8');
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    return { schemaVersion: SELF_IMPROVEMENT_ARCHIVE_SCHEMA_VERSION, entries: [] };
+                }
+                throw error;
+            }
+            const parsed = JSON.parse(raw);
+            if (!parsed || parsed.schemaVersion !== SELF_IMPROVEMENT_ARCHIVE_SCHEMA_VERSION || !Array.isArray(parsed.entries)) {
+                throw new Error('Invalid evolution archive; refusing to overwrite evidence');
+            }
+            return parsed;
+        }
         try {
             const parsed = readJsonAtomicSync(this.filePath, {}, { mode: 0o600 });
             if (Array.isArray(parsed.entries)) {
@@ -40,9 +58,20 @@ export class EvolutionaryArchive {
     list() {
         return this.read().entries;
     }
-    /** Append a validated improvement. Returns the stored entry. */
+    /** Append a validated improvement. Idempotent on kind+proposalId+targetScenarioId. */
     append(entry) {
-        const file = this.read();
+        const file = this.read(true);
+        const existing = file.entries.find((stored) => stored.proposalId === entry.proposalId &&
+            stored.kind === entry.kind &&
+            stored.targetScenarioId === entry.targetScenarioId);
+        if (existing) {
+            const previousSha = existing.evidence?.artifactSha256;
+            const nextSha = entry.evidence?.artifactSha256;
+            if (typeof previousSha === 'string' && typeof nextSha === 'string' && previousSha !== nextSha) {
+                throw new Error(`archive fingerprint conflict for ${entry.kind}:${entry.proposalId}:${entry.targetScenarioId}`);
+            }
+            return existing;
+        }
         const stored = {
             ...entry,
             createdAt: this.now().toISOString(),

package/dist/agent/self-improvement/proposal-store.d.ts

@@ -36,6 +36,7 @@ export declare class PendingProposalStore {
     readonly dir: string;
     constructor(options?: PendingProposalStoreOptions);
     pathFor(kind: PendingProposalKind, scenarioId: string): string;
+    legacyPathFor(kind: PendingProposalKind, scenarioId: string): string;
     saveTool(record: Omit<PendingToolProposalRecord, 'schemaVersion' | 'kind'>): PendingToolProposalRecord;
     saveSkill(record: Omit<PendingSkillProposalRecord, 'schemaVersion' | 'kind'>): PendingSkillProposalRecord;
     loadTool(scenarioId: string): PendingToolProposalRecord | null;

package/dist/agent/self-improvement/proposal-store.js

@@ -10,11 +10,15 @@
  */
 import fs from 'fs';
 import path from 'path';
+import { createHash } from 'crypto';
 import { readJsonAtomicSync, writeJsonAtomicSync } from '../../utils/atomic-write.js';
 export const PENDING_PROPOSAL_SCHEMA_VERSION = 1;
 function safeSegment(id) {
     const cleaned = id.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
-    return cleaned || 'proposal';
+    return cleaned.slice(0, 80) || 'proposal';
+}
+function scenarioHash(id) {
+    return createHash('sha256').update(id).digest('hex').slice(0, 16);
 }
 export class PendingProposalStore {
     dir;
@@ -23,6 +27,9 @@ export class PendingProposalStore {
         this.dir = path.join(root, '.codebuddy', 'self-improvement', 'proposals');
     }
     pathFor(kind, scenarioId) {
+        return path.join(this.dir, `${kind}-${safeSegment(scenarioId)}-${scenarioHash(scenarioId)}.json`);
+    }
+    legacyPathFor(kind, scenarioId) {
         return path.join(this.dir, `${kind}-${safeSegment(scenarioId)}.json`);
     }
     saveTool(record) {
@@ -44,38 +51,93 @@ export class PendingProposalStore {
         return stored;
     }
     loadTool(scenarioId) {
-        const parsed = this.read(this.pathFor('tool', scenarioId));
-        if (!parsed || parsed.kind !== 'tool')
-            return null;
-        return parsed;
+        const parsed = this.read(this.pathFor('tool', scenarioId), 'tool', scenarioId);
+        if (parsed && parsed.kind === 'tool')
+            return parsed;
+        const legacyParsed = this.read(this.legacyPathFor('tool', scenarioId), 'tool', scenarioId);
+        if (legacyParsed && legacyParsed.kind === 'tool')
+            return legacyParsed;
+        return null;
     }
     loadSkill(scenarioId) {
-        const parsed = this.read(this.pathFor('skill', scenarioId));
-        if (!parsed || parsed.kind !== 'skill')
-            return null;
-        return parsed;
+        const parsed = this.read(this.pathFor('skill', scenarioId), 'skill', scenarioId);
+        if (parsed && parsed.kind === 'skill')
+            return parsed;
+        const legacyParsed = this.read(this.legacyPathFor('skill', scenarioId), 'skill', scenarioId);
+        if (legacyParsed && legacyParsed.kind === 'skill')
+            return legacyParsed;
+        return null;
     }
     remove(kind, scenarioId) {
-        const filePath = this.pathFor(kind, scenarioId);
-        if (!fs.existsSync(filePath))
-            return false;
-        fs.unlinkSync(filePath);
-        return true;
+        let removed = false;
+        const canonicalPath = this.pathFor(kind, scenarioId);
+        if (fs.existsSync(canonicalPath)) {
+            const parsed = this.read(canonicalPath, kind, scenarioId);
+            if (parsed) {
+                fs.unlinkSync(canonicalPath);
+                removed = true;
+            }
+        }
+        const legacyPath = this.legacyPathFor(kind, scenarioId);
+        if (fs.existsSync(legacyPath)) {
+            const parsed = this.read(legacyPath, kind, scenarioId);
+            if (parsed && parsed.scenarioId === scenarioId) {
+                fs.unlinkSync(legacyPath);
+                removed = true;
+            }
+        }
+        return removed;
     }
     write(filePath, record) {
         fs.mkdirSync(path.dirname(filePath), { recursive: true });
         writeJsonAtomicSync(filePath, record, { mode: 0o600 });
     }
-    read(filePath) {
+    read(filePath, expectedKind, expectedScenarioId) {
         try {
+            if (!fs.existsSync(filePath))
+                return null;
             const parsed = readJsonAtomicSync(filePath, null, { mode: 0o600 });
-            if (!parsed)
+            if (!parsed || typeof parsed !== 'object')
                 return null;
             if (parsed.schemaVersion !== PENDING_PROPOSAL_SCHEMA_VERSION)
                 return null;
             if (parsed.kind !== 'tool' && parsed.kind !== 'skill')
                 return null;
-            if (typeof parsed.scenarioId !== 'string' || !parsed.proposal || !parsed.gate)
+            if (expectedKind && parsed.kind !== expectedKind)
+                return null;
+            if (typeof parsed.scenarioId !== 'string' || !parsed.scenarioId.trim())
+                return null;
+            if (expectedScenarioId !== undefined && parsed.scenarioId !== expectedScenarioId)
+                return null;
+            // Validate proposal
+            const proposal = parsed.proposal;
+            if (!proposal || typeof proposal !== 'object')
+                return null;
+            if (typeof proposal.id !== 'string' || !proposal.id.trim())
+                return null;
+            if (proposal.targetScenarioId !== parsed.scenarioId)
+                return null;
+            // Validate usable spec fields
+            const spec = proposal.spec;
+            if (!spec || typeof spec !== 'object')
+                return null;
+            if (typeof spec.name !== 'string' || !spec.name.trim())
+                return null;
+            if (parsed.kind === 'tool') {
+                if (typeof spec.code !== 'string')
+                    return null;
+            }
+            else if (parsed.kind === 'skill') {
+                if (typeof spec.content !== 'string')
+                    return null;
+            }
+            // Validate gate identities
+            const gate = parsed.gate;
+            if (!gate || typeof gate !== 'object')
+                return null;
+            if (typeof gate.accepted !== 'boolean')
+                return null;
+            if (gate.scenarioId !== parsed.scenarioId || gate.proposalId !== proposal.id)
                 return null;
             return parsed;
         }