@hmharness/evolution 0.6.6 → 0.6.8

package/dist/evolve.d.ts

@@ -74,6 +74,9 @@ export interface EvolveReport {
         cyclesToday: number;
         maxCyclesPerDay?: number;
     };
+    /** chars/4 estimate of this cycle's meta-call traffic; feeds the daily
+     *  token budget gate (readBudget sums today's entries) */
+    estTokens?: number;
 }
 /** Runs one bench case with the given skills block injected. */
 export type CaseRunner = (c: BenchCase, skillsPrompt: string) => Promise<string>;

package/dist/evolve.js

@@ -15,7 +15,7 @@
  */
 import { appendFile, mkdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { chat } from '@hmharness/kernel';
+import { chat, loadConfig } from '@hmharness/kernel';
 import { listCases, matchCase, seedCases } from "./bench.js";
 import { deleteDraft, listCanary, listDrafts, listSkills, promoteSkill, rollbackSkill, skillsToPrompt, unpromoteSkill, writeDraft } from "./skills.js";
 import { appendMemory, readNotes } from "./memory.js";
@@ -52,14 +52,24 @@ export async function runEvolution(opts) {
         memoryDistilled: null,
     };
     // P0 evolution budget gate (AZR "safety alarms" + cost control): a day's
-    // cycle count and a per-cycle token ceiling live in config; overspending
-    // skips the cycle instead of burning money unattended.
+    // cycle count and a token ceiling live in config; overspending skips the
+    // cycle instead of burning money unattended. The token gate compares the
+    // summed estTokens of today's logged cycles against maxCyclesPerDay *
+    // maxTokensPerCycle (the old code read maxTokensPerCycle but never checked
+    // anything but cycles - the documented budget was decorative).
     const budget = await readBudget(home);
     const today = new Date().toISOString().slice(0, 10);
     if (budget.maxCyclesPerDay && budget.cyclesToday >= budget.maxCyclesPerDay) {
         report.outcomes.push({ name: '(budget)', action: 'error', reason: `daily cycle limit reached (${budget.cyclesToday}/${budget.maxCyclesPerDay} today) - skipped` });
         return report;
     }
+    if (budget.maxCyclesPerDay && budget.maxTokensPerCycle) {
+        const dailyCap = budget.maxCyclesPerDay * budget.maxTokensPerCycle;
+        if ((budget.tokensToday ?? 0) >= dailyCap) {
+            report.outcomes.push({ name: '(budget)', action: 'error', reason: `daily token limit reached (~${budget.tokensToday}/${dailyCap} est-tokens today) - skipped` });
+            return report;
+        }
+    }
     // 1. Seed bench cases on a fresh home so the gate always has a signal.
     report.seededCases = await seedCases(home);
     const cases = await listCases(home);
@@ -297,29 +307,42 @@ export async function runEvolution(opts) {
     // 6. CODE-LEVEL evolution: propose + sandbox-bench + merge/revert patches.
     // This is the DGM bridge - the agent can now modify its own tool code,
     // gated by the same bench discipline as skill promotion.
-    try {
-        const { proposePatches, runPatchSandbox } = await import("./patches.js");
-        const repoRoot = process.cwd();
-        const patches = await proposePatches(provider, signals, readFile, repoRoot, say);
-        if (patches.length > 0) {
-            report.codePatches = patches.map((p) => ({ name: p.name, file: p.file, reason: p.reason }));
-            for (const patch of patches.slice(0, 1)) { // at most 1 patch per cycle
-                const outcome = await runPatchSandbox({
-                    repoRoot,
-                    patch,
-                    baselineRate: baseRate,
-                    runCase: async (c) => runCase(c, skillsToPrompt(active)),
-                    benchCases: train,
-                    log: say,
-                });
-                report.patchOutcomes = report.patchOutcomes ?? [];
-                report.patchOutcomes.push(outcome);
-                say(`  code-patch ${outcome.action}: ${outcome.reason}`);
-            }
+    // OFF BY DEFAULT (DGM's own paper calls self-modifying systems "unsafe by
+    // default"; AlphaEvolve evolves external programs in isolation, never the
+    // live repo). Opt in with evolution.autoPatch=true in config.json - and
+    // even then it only ever touches the repo the evolution runs in, with
+    // human-reviewed sandbox benches before any merge.
+    const cfg = await loadConfig();
+    if (cfg.evolution?.autoPatch !== true) {
+        if (insights.length > 0 || notes.length > 0) {
+            say('  code-evolution: off (set evolution.autoPatch=true in config.json to enable)');
         }
     }
-    catch (err) {
-        say(`  code-evolution skipped: ${String(err).slice(0, 120)}`);
+    else {
+        try {
+            const { proposePatches, runPatchSandbox } = await import("./patches.js");
+            const repoRoot = process.cwd();
+            const patches = await proposePatches(provider, signals, readFile, repoRoot, say);
+            if (patches.length > 0) {
+                report.codePatches = patches.map((p) => ({ name: p.name, file: p.file, reason: p.reason }));
+                for (const patch of patches.slice(0, 1)) { // at most 1 patch per cycle
+                    const outcome = await runPatchSandbox({
+                        repoRoot,
+                        patch,
+                        baselineRate: baseRate,
+                        runCase: async (c) => runCase(c, skillsToPrompt(active)),
+                        benchCases: train,
+                        log: say,
+                    });
+                    report.patchOutcomes = report.patchOutcomes ?? [];
+                    report.patchOutcomes.push(outcome);
+                    say(`  code-patch ${outcome.action}: ${outcome.reason}`);
+                }
+            }
+        }
+        catch (err) {
+            say(`  code-evolution skipped: ${String(err).slice(0, 120)}`);
+        }
     }
     // 7. Append-only memory distillation.
     if (notes.length >= 4) {
@@ -356,7 +379,14 @@ export async function runEvolution(opts) {
     catch (err) {
         say(`  impact/decay skipped: ${String(err).slice(0, 100)}`);
     }
-    // 7. Durable evolution log.
+    // 7. Durable evolution log. estTokens feeds the daily token budget gate:
+    // a chars/4 estimate of this cycle's meta-call traffic (proposals + bench
+    // outputs + distilled notes) - coarse on purpose, the gate only needs an
+    // order of magnitude to stop unattended spend.
+    const estTokensSpent = (proposals ?? []).reduce((n, p) => n + estTokens(p.skill_md ?? '') + estTokens(p.description ?? ''), 0)
+        + (report.memoryDistilled ? estTokens(report.memoryDistilled) : 0)
+        + (report.patchOutcomes ?? []).length * 4_000;
+    report.estTokens = estTokensSpent;
     const logDir = join(home, 'evolution');
     await mkdir(logDir, { recursive: true });
     await appendFile(join(logDir, 'log.jsonl'), JSON.stringify(report) + '\n', 'utf8');

package/dist/impact.d.ts

@@ -1,8 +1,14 @@
 export interface EvolutionBudget {
     maxCyclesPerDay?: number;
     maxTokensPerCycle?: number;
+    /** summed estTokens of today's logged cycles (filled by readBudget) */
+    tokensToday?: number;
 }
-/** How many evolve cycles already ran today (counts the log.jsonl). */
+/** How many evolve cycles already ran today (counts the log.jsonl).
+ *  Accepts BOTH key spellings: the code's maxCyclesPerDay/maxTokensPerCycle
+ *  and the documented-in-SELFFEED.md cyclesPerDay/tokensPerCycle - the docs
+ *  shipped with the short names, so users who configured by the book were
+ *  silently unlimited. */
 export declare function readBudget(home: string): Promise<EvolutionBudget & {
     cyclesToday: number;
 }>;

package/dist/impact.js

@@ -20,26 +20,40 @@
  */
 import { appendFile, mkdir, readFile, rename } from 'node:fs/promises';
 import { join } from 'node:path';
-/** How many evolve cycles already ran today (counts the log.jsonl). */
+/** How many evolve cycles already ran today (counts the log.jsonl).
+ *  Accepts BOTH key spellings: the code's maxCyclesPerDay/maxTokensPerCycle
+ *  and the documented-in-SELFFEED.md cyclesPerDay/tokensPerCycle - the docs
+ *  shipped with the short names, so users who configured by the book were
+ *  silently unlimited. */
 export async function readBudget(home) {
     const budget = { cyclesToday: 0 };
     try {
         const cfg = JSON.parse(await readFile(join(home, 'config.json'), 'utf8'));
-        budget.maxCyclesPerDay = cfg.evolutionBudget?.maxCyclesPerDay;
-        budget.maxTokensPerCycle = cfg.evolutionBudget?.maxTokensPerCycle;
+        budget.maxCyclesPerDay = cfg.evolutionBudget?.maxCyclesPerDay ?? cfg.evolutionBudget?.cyclesPerDay;
+        budget.maxTokensPerCycle = cfg.evolutionBudget?.maxTokensPerCycle ?? cfg.evolutionBudget?.tokensPerCycle;
     }
     catch { /* no config / no budget - unlimited */ }
     const today = new Date().toISOString().slice(0, 10);
     try {
         const text = await readFile(join(home, 'evolution', 'log.jsonl'), 'utf8');
-        budget.cyclesToday = text.trim().split('\n')
+        const todays = text.trim().split('\n')
             .filter((l) => { try {
             return JSON.parse(l).time.startsWith(today);
         }
         catch {
             return false;
-        } })
-            .length;
+        } });
+        budget.cyclesToday = todays.length;
+        // token budget uses each cycle's logged estTokens (chars/4 estimate; the
+        // precise per-call usage is not threaded through the meta-call helpers)
+        budget.tokensToday = todays.reduce((n, l) => {
+            try {
+                return n + (JSON.parse(l).estTokens ?? 0);
+            }
+            catch {
+                return n;
+            }
+        }, 0);
     }
     catch { /* no log yet */ }
     return budget;

package/dist/patches.d.ts

@@ -40,7 +40,11 @@ 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. */
+/** 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>;
@@ -48,7 +52,11 @@ export declare function commitOnSandbox(repoRoot: string, patchName: string): Pr
 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). */
+/** 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.

package/dist/patches.js

@@ -82,11 +82,13 @@ export async function applyPatch(repoRoot, patch) {
     await writeFile(filePath, patched, 'utf8');
     return 'applied';
 }
-/** Create a sandbox git branch for testing a patch. */
+/** 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)}`;
-    // stash any stray working-tree changes first so the branch starts clean
-    await git(['stash', '--include-untracked'], { cwd: repoRoot, timeout: 10_000 }).catch(() => undefined);
     await git(['checkout', '-b', branch], { cwd: repoRoot, timeout: 10_000 });
     return branch;
 }
@@ -128,11 +130,13 @@ export async function sandboxBench(repoRoot, runCase, cases) {
     }
     return cases.length > 0 ? pass / cases.length : -1;
 }
-/** Revert: go back to main, delete the sandbox branch (zero residue). */
+/** 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 });
-    // discard any uncommitted changes on the sandbox branch
-    await git(['reset', '--hard', 'HEAD'], { cwd: repoRoot, timeout: 5000 });
     await git(['branch', '-D', branch], { cwd: repoRoot, timeout: 5000 });
 }
 /**
@@ -142,6 +146,17 @@ export async function revertSandbox(repoRoot, branch) {
 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 {
@@ -191,7 +206,7 @@ export async function proposePatches(provider, signals, readFileFn, repoRoot, sa
         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/devices.ts',
+        harmony_devices: 'packages/domain-harmony/src/index.ts',
         // add more as insights reveal hot paths
     };
     const toolsUsed = (signals.toolUsage ?? {});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hmharness/evolution",
-  "version": "0.6.6",
+  "version": "0.6.8",
   "description": "hmharness evolution subsystem: persistent memory, insight capture, skill library, and the bench that gives evolution its fitness signal. First-class kernel citizen, not a plugin.",
   "type": "module",
   "main": "dist/index.js",
@@ -15,7 +15,7 @@
     "build": "tsc -p tsconfig.build.json"
   },
   "dependencies": {
-    "@hmharness/kernel": "0.6.6"
+    "@hmharness/kernel": "0.6.8"
   },
   "files": [
     "dist"