@hmharness/evolution 0.14.0 → 0.14.4

package/dist/bench.d.ts

@@ -24,6 +24,12 @@ export interface BenchResult {
     detail: string;
 }
 export declare function matchExpect(output: string, expect: string[]): boolean;
+/** Fence convention: when the reply is a fenced block, assertions test the
+ *  fence INNER content (day-55 finding: models preserve literals verbatim
+ *  inside code fences while normalizing them in prose - the fence is the
+ *  reply convention that makes exactness attainable for habit-prone models).
+ *  Tolerates a trailing space after the opening fence markers. */
+export declare function fenceInner(output: string): string;
 /** Full structured assertion: every declared mode must hold. */
 export declare function matchCase(output: string, c: Pick<BenchCase, 'expect' | 'expectExact' | 'expectRegex' | 'expectNone' | 'expectAny'>): {
     pass: boolean;

package/dist/bench.js

@@ -24,27 +24,37 @@ export function matchExpect(output, expect) {
     const lower = output.toLowerCase();
     return expect.every((e) => lower.includes(e.toLowerCase()));
 }
+/** Fence convention: when the reply is a fenced block, assertions test the
+ *  fence INNER content (day-55 finding: models preserve literals verbatim
+ *  inside code fences while normalizing them in prose - the fence is the
+ *  reply convention that makes exactness attainable for habit-prone models).
+ *  Tolerates a trailing space after the opening fence markers. */
+export function fenceInner(output) {
+    const m = output.match(/```[a-zA-Z]*[ \t]*\r?\n([\s\S]*?)(?:\r?\n)?```/);
+    return m ? m[1] : output;
+}
 /** Full structured assertion: every declared mode must hold. */
 export function matchCase(output, c) {
-    if (c.expectExact !== undefined && output.trim() !== c.expectExact.trim()) {
-        return { pass: false, detail: `exact mismatch: got "${output.trim().slice(0, 80)}"` };
+    const body = fenceInner(output);
+    if (c.expectExact !== undefined && body.trim() !== c.expectExact.trim()) {
+        return { pass: false, detail: `exact mismatch: got "${body.trim().slice(0, 80)}"` };
     }
     if (c.expectRegex !== undefined) {
         try {
-            if (!new RegExp(c.expectRegex).test(output))
+            if (!new RegExp(c.expectRegex).test(body))
                 return { pass: false, detail: `regex mismatch: /${c.expectRegex.slice(0, 60)}/` };
         }
         catch {
             return { pass: false, detail: `invalid regex in case: ${c.expectRegex.slice(0, 40)}` };
         }
     }
-    if (c.expectNone && c.expectNone.some((e) => output.toLowerCase().includes(e.toLowerCase()))) {
+    if (c.expectNone && c.expectNone.some((e) => body.toLowerCase().includes(e.toLowerCase()))) {
         return { pass: false, detail: `forbidden marker present: ${c.expectNone.join(' && ')}` };
     }
-    if (c.expectAny && !c.expectAny.some((e) => output.toLowerCase().includes(e.toLowerCase()))) {
+    if (c.expectAny && !c.expectAny.some((e) => body.toLowerCase().includes(e.toLowerCase()))) {
         return { pass: false, detail: `none of the allowed markers found: ${c.expectAny.join(' || ')}` };
     }
-    if (!matchExpect(output, c.expect)) {
+    if (!matchExpect(body, c.expect)) {
         return { pass: false, detail: `missing "${c.expect.join('" && "')}" in output` };
     }
     return { pass: true, detail: 'ok' };

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from './memory.ts';
 export * from './ranker.ts';
 export * from './candidates.ts';
+export * from './skillpayload.ts';
 export * from './dataset.ts';
 export * from './readiness.ts';
 export * from './labels.ts';

package/dist/index.js

@@ -1,6 +1,7 @@
 export * from "./memory.js";
 export * from "./ranker.js";
 export * from "./candidates.js";
+export * from "./skillpayload.js";
 export * from "./dataset.js";
 export * from "./readiness.js";
 export * from "./labels.js";

package/dist/skillpayload.d.ts

@@ -0,0 +1 @@
+export declare function loadSkillPayload(home: string, payload: string): Promise<string>;

package/dist/skillpayload.js

@@ -0,0 +1,28 @@
+/**
+ * Resolve a treatment-arm skills prompt for a skill-target candidate: the
+ * payload names the skill; the arm must inject the skill's CONTENT (draft
+ * first, promoted second), never the bare name string. (Day-49 SELFFEED:
+ * the first real experiment injected "+34 tokens" of name - it measured the
+ * instrument, not the skill.)
+ */
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export async function loadSkillPayload(home, payload) {
+    const name = payload.trim();
+    if (!name)
+        return '';
+    const candidates = [
+        join(home, 'skills', 'drafts', `${name}.md`),
+        join(home, 'skills', `${name}.md`),
+    ];
+    for (const f of candidates) {
+        try {
+            const md = await readFile(f, 'utf8');
+            if (md.trim())
+                return md.trim().slice(0, 4000);
+        }
+        catch { /* next */ }
+    }
+    // no file found: fall back to the raw string so the arm still runs
+    return name;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hmharness/evolution",
-  "version": "0.14.0",
+  "version": "0.14.4",
   "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",