@hmharness/evolution 0.13.3 → 0.14.1

package/dist/evolve.js

@@ -13,7 +13,7 @@
  *    config, security settings, or code
  *  - memory is append-only (ACE: rewriting is how context gets lost)
  */
-import { appendFile, mkdir, readFile } from 'node:fs/promises';
+import { appendFile, mkdir, readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { chat, loadConfig } from '@hmharness/kernel';
 import { listCases, matchCase, seedCases } from "./bench.js";
@@ -337,6 +337,24 @@ export async function runEvolution(opts) {
                 lineage: { parentInsights: insightIds, scores: { train: candRate, holdout: holdout.length ? holdoutRate : undefined }, metaModel: provider.model, decidedAt: new Date().toISOString() },
             });
             say(`  promoted to canary${holdout.length ? ` (holdout ${(holdoutRate * 100).toFixed(0)}%)` : ' [weak gate: no holdout]'}`);
+            // AWM workflows are versioned artifacts: a promoted *-workflow skill is
+            // ALSO recorded under evolution/workflows/<name>.json - the readiness
+            // "version-provenance" condition scans that dir (it was permanently
+            // empty before this, making condition 5 structurally unmeetable).
+            if (/workflow$/.test(p.name)) {
+                try {
+                    const wfDir = join(home, 'evolution', 'workflows');
+                    await mkdir(wfDir, { recursive: true });
+                    await writeFile(join(wfDir, `${p.name}.json`), JSON.stringify({
+                        name: p.name,
+                        version: candRate.toFixed(2),
+                        skillMd: p.skill_md,
+                        promotedAt: new Date().toISOString(),
+                        trainPassRate: candRate,
+                    }, null, 2) + '\n', 'utf8');
+                }
+                catch { /* versioning is best-effort bookkeeping */ }
+            }
         }
         catch (err) {
             report.outcomes.push({ name: p.name, action: 'error', reason: String(err).slice(0, 200) });

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 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';
 export * from './insights.ts';
 export * from './skills.ts';
 export * from './bench.ts';

package/dist/index.js

@@ -1,8 +1,10 @@
 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";
 export * from "./insights.js";
 export * from "./skills.js";
 export * from "./bench.js";

package/dist/labels.d.ts

@@ -0,0 +1,20 @@
+export interface HumanLabel {
+    session: string;
+    score: number;
+    note?: string;
+    time: string;
+}
+/** Append one human score (dedupe: a session keeps its FIRST label). */
+export declare function labelSession(home: string, session: string, score: number, note?: string): Promise<{
+    ok: boolean;
+    reason?: string;
+    count: number;
+}>;
+export declare function readLabels(home: string): Promise<HumanLabel[]>;
+/** Recent sessions from the insight feed, each with its label (if any) -
+ *  the pick list for `hmh label`. */
+export declare function labelableSessions(home: string, limit?: number): Promise<Array<{
+    session: string;
+    task: string;
+    label?: HumanLabel;
+}>>;

package/dist/labels.js

@@ -0,0 +1,57 @@
+/**
+ * @hmharness/evolution - labels (SELFFEED month-2 foundation)
+ * Human reward-label channel: the M11 readiness condition
+ * 'reward-human-correlation' needs >=100 human-scored samples; this is the
+ * write path for them (evolution/reward-human-labels.jsonl, one line per
+ * sample, deduplicated by session). `hmh label <session-id> <1-5> [note]`.
+ */
+import { appendFile, mkdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+const labelsFile = (home) => join(home, 'evolution', 'reward-human-labels.jsonl');
+/** Append one human score (dedupe: a session keeps its FIRST label). */
+export async function labelSession(home, session, score, note) {
+    if (!session || !/^\d{4}-\d{2}-\d{2}T/.test(session))
+        return { ok: false, reason: 'session id looks wrong (expected YYYY-MM-DDThh-mm-ss-xxxxxx)', count: (await readLabels(home)).length };
+    if (!Number.isInteger(score) || score < 1 || score > 5)
+        return { ok: false, reason: 'score must be an integer 1..5', count: (await readLabels(home)).length };
+    const dir = join(home, 'evolution');
+    await mkdir(dir, { recursive: true });
+    const existing = await readLabels(home);
+    if (existing.some((l) => l.session === session))
+        return { ok: false, reason: `session ${session} already labeled (first label wins)`, count: existing.length };
+    const label = { session, score, ...(note ? { note: note.slice(0, 120) } : {}), time: new Date().toISOString() };
+    await appendFile(labelsFile(home), JSON.stringify(label) + '\n', 'utf8');
+    return { ok: true, count: existing.length + 1 };
+}
+export async function readLabels(home) {
+    try {
+        const text = await readFile(labelsFile(home), 'utf8');
+        return text.split('\n').filter(Boolean).map((l) => JSON.parse(l));
+    }
+    catch {
+        return [];
+    }
+}
+/** Recent sessions from the insight feed, each with its label (if any) -
+ *  the pick list for `hmh label`. */
+export async function labelableSessions(home, limit = 12) {
+    const { readInsights } = await import("./insights.js");
+    const labels = await readLabels(home);
+    const bySession = new Map(labels.map((l) => [l.session, l]));
+    const insights = await readInsights(home, 200);
+    const seen = new Set();
+    const out = [];
+    for (const i of insights) {
+        if (seen.has(i.session) || bySession.has(i.session))
+            continue;
+        seen.add(i.session);
+        out.push({ session: i.session, task: i.task.slice(0, 90), label: bySession.get(i.session) });
+        if (out.length >= limit)
+            break;
+    }
+    // labeled ones first for re-inspection, then unlabeled
+    return [
+        ...labels.slice(-limit).reverse().map((l) => ({ session: l.session, task: '(labeled)', label: l })),
+        ...out,
+    ];
+}

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.13.3",
+  "version": "0.14.1",
   "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",