@hmharness/evolution 0.14.9 → 0.14.11

package/dist/memory.js.v2bak.v2bak

@@ -1,233 +0,0 @@
-/**
- * @hmharness/evolution - memory
- * Cross-session persistent memory. Notes are append-only lines in
- * memory/memory.md (ACE lesson: append beats rewrite - rewriting is where
- * hard-won context gets lost). Injection is retrieval-based and layered:
- *
- *   1. lexical scoring (ASCII words + CJK bigrams, no deps) - the baseline
- *   2. workspace scoping - notes tagged [ws:<name>] are boosted 2.5x when
- *      the current task runs inside that workspace and dampened to 0.3x in
- *      others. Isolation WITHOUT walls: project-local facts rank first at
- *      home, but global lessons stay reachable everywhere. Untagged notes
- *      (the entire pre-existing memory) behave exactly as before.
- *   3. optional embedding hybrid - when an embedding provider is passed in,
- *      notes are vectorised once (cache: memory/embeddings.json, keyed by
- *      content hash) and ranked by cosine similarity blended with the
- *      lexical score. Any failure falls back to pure lexical - embeddings
- *      are an upgrade, never a dependency.
- */
-import { appendFile, mkdir, readFile, writeFile } from 'node:fs/promises';
-import { createHash } from 'node:crypto';
-import { join } from 'node:path';
-import { rankContext } from "./ranker.js";
-export async function readNotes(home) {
-    let raw;
-    try {
-        raw = await readFile(join(home, 'memory', 'memory.md'), 'utf8');
-    }
-    catch {
-        return [];
-    }
-    const notes = [];
-    for (const line of raw.split('\n')) {
-        const m = line.match(/^\s*-\s*\[([^\]]*)\]\s*(.+)$/);
-        if (m)
-            notes.push({ time: m[1].trim(), text: m[2].trim() });
-    }
-    return notes;
-}
-/** Resolve the workspace a cwd belongs to (longest path prefix wins).
- *  Returns null outside every workspace - those notes stay global. */
-export async function workspaceForCwd(home, cwd) {
-    let entries;
-    try {
-        const j = JSON.parse(await readFile(join(home, 'workspaces.json'), 'utf8'));
-        entries = Array.isArray(j) ? j : (j.workspaces ?? []);
-    }
-    catch {
-        return null;
-    }
-    const norm = (p) => p.replace(/[\\/]+/g, '\\').toLowerCase().replace(/\\$/, '');
-    const target = norm(cwd);
-    let best = null;
-    for (const w of entries) {
-        if (!w?.path || !w?.name)
-            continue;
-        const p = norm(w.path);
-        if ((target === p || target.startsWith(p + '\\')) && (!best || p.length > best.len)) {
-            best = { name: w.name, len: p.length };
-        }
-    }
-    return best?.name ?? null;
-}
-const WS_TAG = /\s*\[ws:([^\]]+)\]\s*$/;
-function noteWorkspace(text) {
-    const m = text.match(WS_TAG);
-    return m ? m[1] : null;
-}
-/** Tokenize for scoring: ASCII words as-is, CJK runs as bigrams. */
-function tokens(text) {
-    const out = new Set();
-    for (const w of text.match(/[a-zA-Z0-9_.\\/:+-]{2,}/g) ?? [])
-        out.add(w.toLowerCase());
-    for (const run of text.match(/[\u4e00-\u9fff]+/g) ?? []) {
-        for (let i = 0; i + 1 < run.length; i++)
-            out.add(run.slice(i, i + 2));
-    }
-    return out;
-}
-export function scoreNotes(notes, task, workspace) {
-    const taskTokens = tokens(task);
-    const ranked = notes.map((note, idx) => {
-        const n = tokens(note.text);
-        let overlap = 0;
-        for (const t of n)
-            if (taskTokens.has(t))
-                overlap++;
-        let score = overlap + idx / Math.max(notes.length, 1) * 0.01;
-        // workspace scoping: boost at home, dampen abroad, globals untouched
-        const ws = noteWorkspace(note.text);
-        if (workspace && ws === workspace)
-            score *= 2.5;
-        else if (workspace && ws && ws !== workspace)
-            score *= 0.3;
-        return { note, score };
-    });
-    return ranked.sort((a, b) => b.score - a.score);
-}
-function cosine(a, b) {
-    let dot = 0, na = 0, nb = 0;
-    for (let i = 0; i < a.length; i++) {
-        dot += a[i] * b[i];
-        na += a[i] * a[i];
-        nb += b[i] * b[i];
-    }
-    return na && nb ? dot / (Math.sqrt(na) * Math.sqrt(nb)) : 0;
-}
-async function embed(inputs, p, fetchImpl) {
-    const doFetch = fetchImpl ?? fetch;
-    try {
-        const res = await doFetch(p.baseUrl.replace(/\/+$/, '') + '/embeddings', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${p.apiKey}` },
-            body: JSON.stringify({ model: p.model, input: inputs }),
-            signal: AbortSignal.timeout(20_000),
-        });
-        if (!res.ok)
-            return null;
-        const j = await res.json();
-        const out = (j.data ?? []).map((d) => d.embedding ?? []);
-        return out.length === inputs.length ? out : null;
-    }
-    catch {
-        return null;
-    }
-}
-async function hybridRank(notes, task, workspace, home, embedding, fetchImpl) {
-    const lexical = scoreNotes(notes, task, workspace);
-    const maxLex = Math.max(...lexical.map((r) => r.score), 1e-9);
-    const cacheFile = join(home, 'memory', 'embeddings.json');
-    let cache = {};
-    try {
-        cache = JSON.parse(await readFile(cacheFile, 'utf8'));
-    }
-    catch { /* empty */ }
-    const hash = (s) => createHash('sha256').update(s).digest('hex').slice(0, 24);
-    const missing = [...new Set(notes.filter((n) => !cache[hash(n.text)]).map((n) => n.text))];
-    if (missing.length > 0) {
-        const vecs = await embed(missing, embedding, fetchImpl);
-        if (!vecs)
-            return null; // embedding endpoint down -> pure lexical
-        missing.forEach((text, i) => { cache[hash(text)] = vecs[i]; });
-        try {
-            await mkdir(join(home, 'memory'), { recursive: true });
-            await writeFile(cacheFile, JSON.stringify(cache), 'utf8');
-        }
-        catch { /* best effort */ }
-    }
-    const queryVec = await embed([task], embedding, fetchImpl);
-    if (!queryVec)
-        return null;
-    const q = queryVec[0];
-    const blended = lexical.map((r) => {
-        const v = cache[hash(r.note.text)];
-        const cos = v ? cosine(v, q) : 0;
-        return { note: r.note, score: 0.5 * (r.score / maxLex) + 0.5 * Math.max(cos, 0) };
-    });
-    return blended.sort((a, b) => b.score - a.score);
-}
-/**
- * Build the prompt block: top-k task-relevant notes plus the newest few
- * (deduplicated), bounded in chars. Empty string when memory is empty.
- */
-export async function retrieveMemory(home, task, opts = {}) {
-    const { topK = 12, newest = 3, maxChars = 4000 } = opts;
-    const notes = await readNotes(home);
-    if (notes.length === 0)
-        return '';
-    let ranked;
-    if (opts.embedding) {
-        ranked = (await hybridRank(notes, task, opts.workspace, home, opts.embedding, opts.fetchImpl)) ?? scoreNotes(notes, task, opts.workspace);
-    }
-    else {
-        ranked = scoreNotes(notes, task, opts.workspace);
-    }
-    // V2 M5: the blueprint-weighted ContextRanker governs the final pick.
-    // Existing scores become `relevance`; recency derives from the note time
-    // (distillations are curated -> more important); dependency/similarity stay
-    // neutral until richer signals exist. Cost = chars/4.
-    const maxScore = Math.max(1, ...ranked.map((r) => r.score));
-    const newestTime = Date.parse(notes[notes.length - 1]?.time ?? '') || Date.now();
-    const oldestTime = Date.parse(notes[0]?.time ?? '') || newestTime;
-    const span = Math.max(1, newestTime - oldestTime);
-    const reRanked = rankContext(ranked.map(({ note, score }) => ({
-        source: 'memory',
-        contentRef: note.text,
-        relevance: score / maxScore,
-        recency: span > 1 ? (Date.parse(note.time) - oldestTime) / span : 1,
-        importance: /^\(distilled\)/.test(note.text) ? 0.8 : 0.5,
-        dependency: 0.5,
-        similarity: 0.5,
-        tokenCost: Math.ceil(note.text.length / 4),
-    })));
-    const picked = [];
-    const seen = new Set();
-    for (const c of reRanked.slice(0, topK)) {
-        const hit = ranked.find((r) => r.note.text === c.contentRef);
-        if (!hit || seen.has(hit.note.text))
-            continue;
-        picked.push(hit.note);
-        seen.add(hit.note.text);
-    }
-    for (const note of (newest > 0 ? notes.slice(-newest) : [])) {
-        if (!seen.has(note.text))
-            picked.push(note);
-        seen.add(note.text);
-    }
-    // stable output: keep chronological order
-    picked.sort((a, b) => (a.time < b.time ? -1 : 1));
-    const lines = picked.map((n) => `- [${n.time}] ${n.text}`);
-    let text = lines.join('\n');
-    if (text.length > maxChars)
-        text = text.slice(0, maxChars) + '\n...[memory truncated]';
-    return text;
-}
-/** Legacy full load (tail-bounded) - kept for callers that want everything. */
-export async function loadMemory(home) {
-    try {
-        const text = (await readFile(join(home, 'memory', 'memory.md'), 'utf8')).trim();
-        if (!text)
-            return '';
-        return text.length > 8000 ? text.slice(-8000) : text;
-    }
-    catch {
-        return '';
-    }
-}
-export async function appendMemory(home, note, workspace) {
-    const dir = join(home, 'memory');
-    await mkdir(dir, { recursive: true });
-    const stamp = new Date().toISOString().slice(0, 16).replace('T', ' ');
-    const tag = workspace ? ` [ws:${workspace}]` : '';
-    await appendFile(join(dir, 'memory.md'), `\n- [${stamp}] ${note.replace(/\n+/g, ' ').trim()}${tag}\n`, 'utf8');
-}

package/dist/patches.d.ts.v2bak.v2bak

@@ -1,83 +0,0 @@
-/**
- * @hmharness/evolution - patches
- * CODE-LEVEL self-evolution: the evolution loop can now propose source-code
- * patches (not just prompt-level skills), test them on an isolated git
- * branch, and merge or revert based on the benchmark gate.
- *
- * The Darwin Gödel Machine insight: an agent that can only take notes
- * (skills/memory) learns WHAT to do; an agent that can patch its own code
- * learns WHAT IT CAN DO. This module is the bridge.
- *
- * Safety model (same shape as the skill gate, extended to code):
- *  1. patches may only modify files under packages/.../src/ (never config,
- *     never security code, never the kernel loop itself)
- *  2. every patch runs on a git branch (sandbox), never on main
- *  3. the bench gate must show no regression (same double-sample rule)
- *  4. revert = git checkout main + branch delete (zero residue)
- */
-import { readFile } from 'node:fs/promises';
-/** A proposed code change: find-and-replace in one source file. */
-export interface CodePatch {
-    name: string;
-    description: string;
-    /** relative path from repo root, must match packages/.../src/.../*.ts */
-    file: string;
-    /** exact string to find in the file (must be unique) */
-    find: string;
-    /** replacement string */
-    replace: string;
-    /** why this change helps (for the audit log) */
-    reason: string;
-}
-export interface PatchOutcome {
-    name: string;
-    action: 'merged' | 'reverted' | 'error';
-    reason: string;
-    branch?: string;
-}
-/** Guard: only source files inside packages, never kernel internals. */
-export declare function isPatchableFile(file: string): boolean;
-/** Validate + apply a patch to a file on disk. Returns error if find-string
- *  is not found or not unique. */
-export declare function applyPatch(repoRoot: string, patch: CodePatch): Promise<string>;
-/** Create a sandbox git branch for testing a patch.
- *  Precondition: the working tree is CLEAN (runPatchSandbox enforces this).
- *  The old version stashed uncommitted user work here and never popped it -
- *  a failed cycle silently swallowed the user's changes into a stash. Now a
- *  dirty tree refuses the cycle outright instead of hiding the work. */
-export declare function createSandbox(repoRoot: string, name: string): Promise<string>;
-/** Commit the patch on the sandbox branch so it is fully isolated from main. */
-export declare function commitOnSandbox(repoRoot: string, patchName: string): Promise<void>;
-/** Merge the sandbox branch back to main (patch promoted). */
-export declare function mergeSandbox(repoRoot: string, branch: string): Promise<void>;
-/** Run the bench gate on the current branch. Returns pass rate (0-1) or -1 on build failure. */
-export declare function sandboxBench(repoRoot: string, runCase: (c: import('./bench.ts').BenchCase, skillsPrompt: string) => Promise<string>, cases: import('./bench.ts').BenchCase[]): Promise<number>;
-/** Revert: go back to main, delete the sandbox branch (zero residue).
- *  No `reset --hard` anymore: the tree is guaranteed clean at entry (clean-
- *  tree precondition) and the patch is committed on the sandbox branch, so
- *  there is nothing to hard-reset - and a hard reset on main is exactly the
- *  operation that can destroy a user's uncommitted work. */
-export declare function revertSandbox(repoRoot: string, branch: string): Promise<void>;
-/**
- * Full sandbox cycle: apply patch on a branch, rebuild, bench, merge or revert.
- * This is the CODE-LEVEL equivalent of the skill A/B gate.
- */
-export declare function runPatchSandbox(opts: {
-    repoRoot: string;
-    patch: CodePatch;
-    baselineRate: number;
-    runCase: (c: import('./bench.ts').BenchCase, skillsPrompt: string) => Promise<string>;
-    benchCases: import('./bench.ts').BenchCase[];
-    log?: (line: string) => void;
-}): Promise<PatchOutcome>;
-/**
- * Meta-model call: propose code patches from session signals.
- * The model sees the signals + the target file's current source and
- * outputs find/replace pairs. Constrained to optimization prompts:
- * fix a bug, speed up a hot path, improve error messages.
- */
-export declare function proposePatches(provider: {
-    baseUrl: string;
-    apiKey: string;
-    model: string;
-}, signals: Record<string, unknown>, readFileFn: typeof readFile, repoRoot: string, say: (l: string) => void): Promise<CodePatch[]>;

package/dist/patches.js.v2bak.v2bak

@@ -1,253 +0,0 @@
-/**
- * @hmharness/evolution - patches
- * CODE-LEVEL self-evolution: the evolution loop can now propose source-code
- * patches (not just prompt-level skills), test them on an isolated git
- * branch, and merge or revert based on the benchmark gate.
- *
- * The Darwin Gödel Machine insight: an agent that can only take notes
- * (skills/memory) learns WHAT to do; an agent that can patch its own code
- * learns WHAT IT CAN DO. This module is the bridge.
- *
- * Safety model (same shape as the skill gate, extended to code):
- *  1. patches may only modify files under packages/.../src/ (never config,
- *     never security code, never the kernel loop itself)
- *  2. every patch runs on a git branch (sandbox), never on main
- *  3. the bench gate must show no regression (same double-sample rule)
- *  4. revert = git checkout main + branch delete (zero residue)
- */
-import { readFile, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-const execCb = promisify(execFile);
-/** git executable: PATH first, then known Windows locations (this repo's
- *  dev machine has git only outside the test-process PATH). */
-async function git(args, opts) {
-    const { homedir } = await import('node:os');
-    // .cmd shims can't execFile-spawn on modern Node (EINVAL) - real .exe only
-    const candidates = [
-        'git',
-        'C:\\Program Files\\Git\\cmd\\git.exe',
-        'C:\\Program Files (x86)\\Git\\cmd\\git.exe',
-        'C:\\Program Files\\Microsoft Visual Studio\\18\\Enterprise\\Common7\\IDE\\CommonExtensions\\Microsoft\\TeamFoundation\\Team Explorer\\Git\\cmd\\git.exe',
-    ];
-    let lastErr;
-    for (const exe of candidates) {
-        try {
-            return await execCb(exe, args, { ...opts, windowsHide: true });
-        }
-        catch (err) {
-            lastErr = err;
-            const msg = String(err);
-            if (!/ENOENT|not found|EINVAL/i.test(msg))
-                throw err; // real failure, not missing-exe
-        }
-    }
-    throw lastErr;
-}
-/** Guard: only source files inside packages, never kernel internals. */
-export function isPatchableFile(file) {
-    if (!/^packages\/[a-z-]+\/src\/[a-zA-Z0-9_/.-]+\.ts$/.test(file))
-        return false;
-    // never allow patching the kernel loop itself (bootstrapping paradox)
-    if (file.startsWith('packages/kernel/src/loop'))
-        return false;
-    if (file.startsWith('packages/kernel/src/provider'))
-        return false;
-    // never config or security
-    if (/config|security|mcp/.test(file))
-        return false;
-    return true;
-}
-/** Validate + apply a patch to a file on disk. Returns error if find-string
- *  is not found or not unique. */
-export async function applyPatch(repoRoot, patch) {
-    if (!isPatchableFile(patch.file)) {
-        return `refused: ${patch.file} is not a patchable source file (must be packages/*/src/*.ts, not kernel loop/provider/config)`;
-    }
-    const filePath = join(repoRoot, patch.file);
-    let content;
-    try {
-        content = await readFile(filePath, 'utf8');
-    }
-    catch {
-        return `file not found: ${patch.file}`;
-    }
-    const count = content.split(patch.find).length - 1;
-    if (count === 0)
-        return `find-string not found in ${patch.file}`;
-    if (count > 1)
-        return `find-string appears ${count}x in ${patch.file} (must be unique)`;
-    const patched = content.replace(patch.find, patch.replace);
-    await writeFile(filePath, patched, 'utf8');
-    return 'applied';
-}
-/** Create a sandbox git branch for testing a patch.
- *  Precondition: the working tree is CLEAN (runPatchSandbox enforces this).
- *  The old version stashed uncommitted user work here and never popped it -
- *  a failed cycle silently swallowed the user's changes into a stash. Now a
- *  dirty tree refuses the cycle outright instead of hiding the work. */
-export async function createSandbox(repoRoot, name) {
-    const branch = `evolve/${name}-${Date.now().toString(36)}`;
-    await git(['checkout', '-b', branch], { cwd: repoRoot, timeout: 10_000 });
-    return branch;
-}
-/** Commit the patch on the sandbox branch so it is fully isolated from main. */
-export async function commitOnSandbox(repoRoot, patchName) {
-    await git(['add', '-A'], { cwd: repoRoot, timeout: 10_000 });
-    await git(['commit', '-m', `evolve(code-patch): ${patchName}`, '--no-verify'], { cwd: repoRoot, timeout: 15_000 });
-}
-/** Merge the sandbox branch back to main (patch promoted). */
-export async function mergeSandbox(repoRoot, branch) {
-    await git(['checkout', 'main'], { cwd: repoRoot, timeout: 10_000 });
-    await git(['merge', '--no-edit', branch], { cwd: repoRoot, timeout: 15_000 });
-    await git(['branch', '-D', branch], { cwd: repoRoot, timeout: 5000 });
-}
-/** Run the bench gate on the current branch. Returns pass rate (0-1) or -1 on build failure. */
-export async function sandboxBench(repoRoot, runCase, cases) {
-    // rebuild all packages (the patch may affect any layer)
-    try {
-        await execCb('npm', ['run', 'build'], { cwd: repoRoot, timeout: 120_000, windowsHide: true });
-    }
-    catch {
-        return -1; // build failed = automatic reject
-    }
-    // double-sample rule: each case must pass BOTH runs
-    let pass = 0;
-    for (const c of cases) {
-        let ok = true;
-        for (let i = 0; i < 2 && ok; i++) {
-            try {
-                const out = await runCase(c, '');
-                ok = c.expect.every((e) => out.toLowerCase().includes(e.toLowerCase()));
-            }
-            catch {
-                ok = false;
-            }
-        }
-        if (ok)
-            pass++;
-    }
-    return cases.length > 0 ? pass / cases.length : -1;
-}
-/** Revert: go back to main, delete the sandbox branch (zero residue).
- *  No `reset --hard` anymore: the tree is guaranteed clean at entry (clean-
- *  tree precondition) and the patch is committed on the sandbox branch, so
- *  there is nothing to hard-reset - and a hard reset on main is exactly the
- *  operation that can destroy a user's uncommitted work. */
-export async function revertSandbox(repoRoot, branch) {
-    await git(['checkout', 'main'], { cwd: repoRoot, timeout: 10_000 });
-    await git(['branch', '-D', branch], { cwd: repoRoot, timeout: 5000 });
-}
-/**
- * Full sandbox cycle: apply patch on a branch, rebuild, bench, merge or revert.
- * This is the CODE-LEVEL equivalent of the skill A/B gate.
- */
-export async function runPatchSandbox(opts) {
-    const say = opts.log ?? (() => undefined);
-    const { patch } = opts;
-    // clean-tree precondition: a dirty working tree means a human is mid-work
-    // in this repo - refuse rather than stash/reset around their changes
-    try {
-        const { stdout } = await git(['status', '--porcelain'], { cwd: opts.repoRoot, timeout: 10_000 });
-        if (stdout.trim()) {
-            return { name: patch.name, action: 'error', reason: 'working tree not clean - refusing to run a patch cycle in a repo with uncommitted changes (commit or stash them first)', branch: '' };
-        }
-    }
-    catch (err) {
-        return { name: patch.name, action: 'error', reason: `git status failed: ${String(err).slice(0, 120)}`, branch: '' };
-    }
-    say(`  code-patch "${patch.name}": creating sandbox branch`);
-    let branch = '';
-    try {
-        branch = await createSandbox(opts.repoRoot, patch.name);
-        const applyResult = await applyPatch(opts.repoRoot, patch);
-        if (applyResult !== 'applied') {
-            await revertSandbox(opts.repoRoot, branch);
-            return { name: patch.name, action: 'error', reason: applyResult, branch };
-        }
-        // commit on the branch BEFORE benching: the patch must be fully isolated
-        // so a later checkout of main can never carry uncommitted patch changes
-        await commitOnSandbox(opts.repoRoot, patch.name);
-        say(`  code-patch "${patch.name}": applied + committed on branch, rebuilding + benching`);
-        const rate = await sandboxBench(opts.repoRoot, opts.runCase, opts.benchCases);
-        if (rate < 0) {
-            await revertSandbox(opts.repoRoot, branch);
-            return { name: patch.name, action: 'reverted', reason: 'build failed in sandbox', branch };
-        }
-        if (rate < opts.baselineRate) {
-            await revertSandbox(opts.repoRoot, branch);
-            return { name: patch.name, action: 'reverted', reason: `bench ${rate} < baseline ${opts.baselineRate}`, branch };
-        }
-        say(`  code-patch "${patch.name}": bench ${rate} >= baseline ${opts.baselineRate}, merging`);
-        await mergeSandbox(opts.repoRoot, branch);
-        return { name: patch.name, action: 'merged', reason: `bench ${rate} >= baseline (merged to main)`, branch };
-    }
-    catch (err) {
-        if (branch) {
-            try {
-                await revertSandbox(opts.repoRoot, branch);
-            }
-            catch { /* best effort */ }
-        }
-        return { name: patch.name, action: 'error', reason: String(err).slice(0, 200), branch };
-    }
-}
-/**
- * Meta-model call: propose code patches from session signals.
- * The model sees the signals + the target file's current source and
- * outputs find/replace pairs. Constrained to optimization prompts:
- * fix a bug, speed up a hot path, improve error messages.
- */
-export async function proposePatches(provider, signals, readFileFn, repoRoot, say) {
-    // pick candidate files: the most-used tools from insights
-    const toolFiles = {
-        run_command: 'packages/agent/src/tools.ts',
-        web_search: 'packages/agent/src/tools.ts',
-        web_fetch: 'packages/agent/src/tools.ts',
-        harmony_build: 'packages/domain-harmony/src/index.ts',
-        harmony_devices: 'packages/domain-harmony/src/index.ts',
-        // add more as insights reveal hot paths
-    };
-    const toolsUsed = (signals.toolUsage ?? {});
-    const hotTools = Object.entries(toolsUsed)
-        .filter(([t]) => toolFiles[t])
-        .sort((a, b) => b[1] - a[1])
-        .slice(0, 2)
-        .map(([t]) => t);
-    if (hotTools.length === 0)
-        return [];
-    const fileContents = {};
-    for (const t of hotTools) {
-        const f = toolFiles[t];
-        try {
-            fileContents[f] = (await readFileFn(join(repoRoot, f), 'utf8')).slice(0, 6000);
-        }
-        catch { /* skip */ }
-    }
-    const system = [
-        'You are the code-evolution module of hmharness. Given session signals and the CURRENT source of the most-used tool files, propose at most 1 code patch as a JSON object.',
-        'A patch is: {"name":"kebab-case","description":"one line","file":"packages/.../src/...ts","find":"exact string from the source (must be unique)","replace":"the improved code","reason":"why"}',
-        'Rules: ONLY optimize what the signals show is slow/broken/verbose. Keep patches SMALL (under 20 lines of change). Do NOT restructure. Do NOT touch security, config, or the agent loop. If nothing genuinely needs a code fix, return [].',
-        'Respond with ONLY a JSON array.',
-    ].join('\n');
-    const user = `Session signals:\n${JSON.stringify(signals, null, 2)}\n\nHot tool source files:\n${JSON.stringify(fileContents, null, 2)}\n\nPropose at most 1 patch (or []).`;
-    say('  code-evolution: asking meta-model for patch proposals');
-    try {
-        const { chat } = await import('@hmharness/kernel');
-        const r = await chat(provider, [
-            { role: 'system', content: system },
-            { role: 'user', content: user },
-        ]);
-        const text = r.message.content ?? '[]';
-        const start = text.indexOf('[');
-        const end = text.lastIndexOf(']');
-        if (start < 0 || end < 0)
-            return [];
-        const parsed = JSON.parse(text.slice(start, end + 1));
-        return parsed.filter((p) => p.file && p.find && p.replace && isPatchableFile(p.file));
-    }
-    catch {
-        return [];
-    }
-}

package/dist/radar.d.ts.v2bak.v2bak

@@ -1,3 +0,0 @@
-/** The newest radar brief, capped (the meta-model needs a headline, not
- *  the whole document; stale-brief protection via the filename date). */
-export declare function latestRadarBrief(home: string, maxChars?: number, maxAgeDays?: number): Promise<string | null>;

package/dist/radar.js.v2bak.v2bak

@@ -1,40 +0,0 @@
-/**
- * @hmharness/evolution - radar (ops-signal feed)
- * The ops keeper's ecosystem radar scans OpenHarmony release sources and
- * writes dated briefs (home/ops/briefs/YYYY-MM-DD.md). This module hands
- * the NEWEST brief text to the evolution loop as context: toolchain flags
- * and API surfaces move with releases, and a skill proposal that doesn't
- * know "ArkUI 5.1.2 shipped last week" proposes stale advice.
- *
- * Read-only and best-effort: evolution never triggers a scan (that's
- * `hmh ops scan`'s own budgeted job) - it reads what the keeper already
- * published, and an absent brief simply means no ecosystem signal.
- */
-import { readdir, readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-/** The newest radar brief, capped (the meta-model needs a headline, not
- *  the whole document; stale-brief protection via the filename date). */
-export async function latestRadarBrief(home, maxChars = 1200, maxAgeDays = 14) {
-    const dir = join(home, 'ops', 'briefs');
-    let files;
-    try {
-        files = (await readdir(dir)).filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f)).sort();
-    }
-    catch {
-        return null;
-    }
-    const latest = files[files.length - 1];
-    if (!latest)
-        return null;
-    const date = latest.replace(/\.md$/, '');
-    if (Date.now() - new Date(date + 'T00:00:00Z').getTime() > maxAgeDays * 86400_000) {
-        return null; // too old to be ecosystem "news"
-    }
-    try {
-        const text = (await readFile(join(dir, latest), 'utf8')).trim();
-        return text.length > 20 ? text.slice(0, maxChars) : null;
-    }
-    catch {
-        return null;
-    }
-}

package/dist/ranker.d.ts.v2bak.v2bak

@@ -1,44 +0,0 @@
-/**
- * @hmharness/evolution - context ranker (V2 blueprint M5).
- *
- * Scores retrieval candidates for the context pack. First version uses the
- * blueprint's fixed weights; Evolution is meant to optimize the weights
- * later (that is why they live in one exported constant, not inline math).
- * All inputs are normalized 0..1 by the caller; tokenCost is normalized
- * against the candidate budget by normalize().
- */
-export interface ContextCandidate {
-    /** where it came from: memory | skill | insight | agents-md | history */
-    source: string;
-    /** reference (text or id) - ranked, not necessarily injected verbatim */
-    contentRef: string;
-    relevance: number;
-    recency: number;
-    importance: number;
-    dependency: number;
-    similarity: number;
-    /** raw token estimate; normalized by the ranker */
-    tokenCost: number;
-}
-export declare const RANK_WEIGHTS: {
-    readonly relevance: 0.3;
-    readonly dependency: 0.2;
-    readonly recency: 0.15;
-    readonly importance: 0.15;
-    readonly similarity: 0.1;
-    readonly tokenCost: -0.1;
-};
-/** Rank candidates: fixed weights, token cost normalized to the batch max,
- *  ties broken by cheaper-first. Returns a NEW sorted array. */
-export declare function rankContext(candidates: ContextCandidate[]): Array<ContextCandidate & {
-    score: number;
-}>;
-/** Pick the top-K candidates under a token budget (greedy, ranked order). */
-export declare function packContext(candidates: ContextCandidate[], budgetTokens: number): Array<ContextCandidate & {
-    score: number;
-}>;
-/** The four memory classes (V2 M5). Entries classify by prefix today:
- *  [self-note]/tool lessons -> procedural; (distilled) -> semantic;
- *  session recaps -> episodic; design/decision notes -> project. */
-export type MemoryClass = 'episodic' | 'semantic' | 'procedural' | 'project';
-export declare function classifyMemory(entry: string): MemoryClass;