@hmharness/evolution 0.14.5 → 0.14.9

package/dist/ranker.js.v2bak.v2bak

@@ -0,0 +1,55 @@
+export const RANK_WEIGHTS = {
+    relevance: 0.30,
+    dependency: 0.20,
+    recency: 0.15,
+    importance: 0.15,
+    similarity: 0.10,
+    tokenCost: -0.10,
+};
+const clamp01 = (n) => Number.isFinite(n) ? Math.max(0, Math.min(1, n)) : 0;
+/** Rank candidates: fixed weights, token cost normalized to the batch max,
+ *  ties broken by cheaper-first. Returns a NEW sorted array. */
+export function rankContext(candidates) {
+    const maxCost = Math.max(1, ...candidates.map((c) => c.tokenCost));
+    return candidates
+        .map((c) => {
+        const n = {
+            relevance: clamp01(c.relevance),
+            dependency: clamp01(c.dependency),
+            recency: clamp01(c.recency),
+            importance: clamp01(c.importance),
+            similarity: clamp01(c.similarity),
+            tokenCost: clamp01(c.tokenCost / maxCost),
+        };
+        const score = RANK_WEIGHTS.relevance * n.relevance +
+            RANK_WEIGHTS.dependency * n.dependency +
+            RANK_WEIGHTS.recency * n.recency +
+            RANK_WEIGHTS.importance * n.importance +
+            RANK_WEIGHTS.similarity * n.similarity +
+            RANK_WEIGHTS.tokenCost * n.tokenCost;
+        return { ...c, score: Math.round(score * 1000) / 1000 };
+    })
+        .sort((a, b) => b.score - a.score || a.tokenCost - b.tokenCost);
+}
+/** Pick the top-K candidates under a token budget (greedy, ranked order). */
+export function packContext(candidates, budgetTokens) {
+    const ranked = rankContext(candidates);
+    const out = [];
+    let used = 0;
+    for (const c of ranked) {
+        if (used + c.tokenCost > budgetTokens)
+            continue;
+        out.push(c);
+        used += c.tokenCost;
+    }
+    return out;
+}
+export function classifyMemory(entry) {
+    if (/^\(distilled\)/.test(entry) || /api|sdk|版本|参数/.test(entry.slice(0, 80)))
+        return 'semantic';
+    if (/design|架构|决策|why|adr/i.test(entry.slice(0, 80)))
+        return 'project';
+    if (/self-note|工具|失败|重试|how to|怎么/.test(entry.slice(0, 80)))
+        return 'procedural';
+    return 'episodic';
+}

package/dist/readiness.d.ts.v2bak.v2bak

@@ -0,0 +1,15 @@
+export interface ReadinessCondition {
+    id: string;
+    met: boolean;
+    current: number | string | boolean;
+    threshold: number | string;
+    evidence: string;
+}
+export interface ReadinessReport {
+    verdict: 'rl-eligible' | 'optimize-first';
+    conditions: ReadinessCondition[];
+    /** when optimize-first: which lever to pull first (weakest condition) */
+    recommendedLever?: 'data-collection' | 'bench-expansion' | 'reward-calibration' | 'eval-suite-stabilization' | 'version-provenance';
+    at: string;
+}
+export declare function rlReadiness(home: string): Promise<ReadinessReport>;

package/dist/readiness.js

@@ -107,8 +107,20 @@ export async function rlReadiness(home) {
         workflows: false,
     };
     try {
-        const skills = await readdir(join(home, 'skills'));
-        provenance.skills = skills.some((s) => s.endsWith('.md'));
+        // skills layout has BOTH shapes in the wild: legacy flat `skills/<name>.md`
+        // and current `skills/active/<name>/` directories (plus `skills/drafts/*.md`).
+        // A top-level-only .md check silently fails every modern install.
+        const entries = await readdir(join(home, 'skills'), { withFileTypes: true });
+        const activeDir = entries.find((e) => e.isDirectory() && e.name === 'active');
+        const draftsDir = entries.find((e) => e.isDirectory() && e.name === 'drafts');
+        const flatMd = entries.some((e) => e.isFile() && e.name.endsWith('.md'));
+        let active = 0;
+        if (activeDir)
+            active = (await readdir(join(home, 'skills', 'active'))).length;
+        let draftMd = 0;
+        if (draftsDir)
+            draftMd = (await readdir(join(home, 'skills', 'drafts'))).filter((f) => f.endsWith('.md')).length;
+        provenance.skills = flatMd || active > 0 || draftMd > 0;
     }
     catch { /* none */ }
     try {

package/dist/readiness.js.v2bak.v2bak

@@ -0,0 +1,167 @@
+/**
+ * @hmharness/evolution - readiness (V2 M11: RL 前置条件检查器)
+ * The blueprint's gate: RL is allowed ONLY when all six conditions hold.
+ * Every condition is measured from real on-disk evidence - nothing is
+ * estimated, nothing can be waved through. When the gate is closed the
+ * report says exactly which optimization to do instead. See ADR-0005.
+ */
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { listCases } from "./bench.js";
+const QUALITY_MIN_REWARD = 0.5;
+async function countRunTrajectories(home) {
+    const root = join(home, 'runs');
+    let ids = [];
+    try {
+        ids = (await readdir(root)).filter((d) => !d.startsWith('.'));
+    }
+    catch {
+        return { total: 0, highQuality: 0 };
+    }
+    let high = 0;
+    for (const id of ids) {
+        try {
+            const s = JSON.parse(await readFile(join(root, id, 'summary.json'), 'utf8'));
+            const outcome = typeof s.outcome === 'string' ? s.outcome : (s.outcome?.success ? 'ok' : String(s.outcome?.reason ?? ''));
+            const uses = Number(s.toolUses ?? s.metrics?.toolUses ?? 0);
+            const fails = Number(s.toolFailures ?? s.metrics?.toolFailures ?? 0);
+            const failRate = uses > 0 ? fails / uses : 0;
+            const reward = outcome === 'ok' ? 1 - Math.min(0.6, Math.round(failRate * 10) / 10) : 0.3;
+            if (outcome && (s.turns ?? s.metrics?.turns ?? 0) >= 1 && reward >= QUALITY_MIN_REWARD)
+                high++;
+        }
+        catch { /* torn */ }
+    }
+    return { total: ids.length, highQuality: high };
+}
+export async function rlReadiness(home) {
+    const conditions = [];
+    // 1. >= 1000 high-quality trajectories
+    const runs = await countRunTrajectories(home);
+    conditions.push({
+        id: 'high-quality-trajectories',
+        met: runs.highQuality >= 1000,
+        current: runs.highQuality,
+        threshold: 1000,
+        evidence: `runs/ scan: ${runs.total} trajectories, ${runs.highQuality} with outcome + turns>=1 + reward>=${QUALITY_MIN_REWARD}`,
+    });
+    // 2. >= 100 stable benchmark tasks
+    let cases = 0;
+    try {
+        cases = (await listCases(home)).length;
+    }
+    catch { /* none */ }
+    conditions.push({
+        id: 'stable-benchmark-tasks',
+        met: cases >= 100,
+        current: cases,
+        threshold: 100,
+        evidence: `bench/cases/ scan: ${cases} cases (holdout included; stability tracked by bench history)`,
+    });
+    // 3. reward vs human judgment correlation VERIFIED - no human-labeling
+    //    channel exists yet, so this is honestly not met (never a guess)
+    let humanLabels = 0;
+    try {
+        const f = await stat(join(home, 'evolution', 'reward-human-labels.jsonl'));
+        if (f.isFile())
+            humanLabels = (await readFile(join(home, 'evolution', 'reward-human-labels.jsonl'), 'utf8')).split('\n').filter(Boolean).length;
+    }
+    catch { /* absent */ }
+    conditions.push({
+        id: 'reward-human-correlation',
+        met: humanLabels >= 100,
+        current: humanLabels,
+        threshold: 100,
+        evidence: 'evolution/reward-human-labels.jsonl (human-scored samples; dataset label field reserves the slot)',
+    });
+    // 4. evaluation regression suite STABLE - last two bench records, no regression
+    let suiteStable = false;
+    let suiteEvidence = 'no bench history records (evolution/benches/ empty)';
+    try {
+        const dir = join(home, 'evolution', 'benches');
+        const files = (await readdir(dir)).filter((f) => f.endsWith('.json')).sort();
+        if (files.length >= 2) {
+            const last = JSON.parse(await readFile(join(dir, files[files.length - 1]), 'utf8'));
+            const prev = JSON.parse(await readFile(join(dir, files[files.length - 2]), 'utf8'));
+            if (typeof last.passRate === 'number' && typeof prev.passRate === 'number') {
+                suiteStable = last.passRate >= prev.passRate - 0.05;
+                suiteEvidence = `last two bench passRates: ${(prev.passRate * 100).toFixed(0)}% -> ${(last.passRate * 100).toFixed(0)}% (tolerance -5%)`;
+            }
+        }
+        else if (files.length === 1) {
+            suiteEvidence = 'only one bench record - stability needs at least two';
+        }
+    }
+    catch { /* absent */ }
+    conditions.push({
+        id: 'eval-regression-stable',
+        met: suiteStable,
+        current: suiteStable,
+        threshold: 'no >5% passRate regression across last two bench runs',
+        evidence: suiteEvidence,
+    });
+    // 5. model/skill/workflow version provenance
+    const provenance = {
+        model: true, // every run's summary carries model; rollout session_meta pins it
+        skills: false,
+        workflows: false,
+    };
+    try {
+        // skills layout has BOTH shapes in the wild: legacy flat `skills/<name>.md`
+        // and current `skills/active/<name>/` directories (plus `skills/drafts/*.md`).
+        // A top-level-only .md check silently fails every modern install.
+        const entries = await readdir(join(home, 'skills'), { withFileTypes: true });
+        const activeDir = entries.find((e) => e.isDirectory() && e.name === 'active');
+        const draftsDir = entries.find((e) => e.isDirectory() && e.name === 'drafts');
+        const flatMd = entries.some((e) => e.isFile() && e.name.endsWith('.md'));
+        let active = 0;
+        if (activeDir)
+            active = (await readdir(join(home, 'skills', 'active'))).length;
+        let draftMd = 0;
+        if (draftsDir)
+            draftMd = (await readdir(join(home, 'skills', 'drafts'))).filter((f) => f.endsWith('.md')).length;
+        provenance.skills = flatMd || active > 0 || draftMd > 0;
+    }
+    catch { /* none */ }
+    try {
+        const wf = await readdir(join(home, 'evolution', 'workflows'));
+        provenance.workflows = wf.length > 0;
+    }
+    catch { /* none */ }
+    conditions.push({
+        id: 'version-provenance',
+        met: provenance.skills && provenance.workflows,
+        current: provenance.skills && provenance.workflows,
+        threshold: 'skills + workflows under version control (model provenance ships with every run)',
+        evidence: `skills dir: ${provenance.skills ? 'versioned .md files' : 'empty'}; workflows dir: ${provenance.workflows ? 'present' : 'empty'}`,
+    });
+    // 6. offline evaluation + holdout set exist
+    let holdout = 0;
+    try {
+        holdout = (await listCases(home)).filter((c) => c.holdout).length;
+    }
+    catch { /* none */ }
+    conditions.push({
+        id: 'offline-eval-holdout',
+        met: holdout > 0 && cases > 0,
+        current: holdout,
+        threshold: '>0 holdout cases in a non-empty bench suite',
+        evidence: `bench/cases/: ${cases} total, ${holdout} holdout`,
+    });
+    const allMet = conditions.every((c) => c.met);
+    const weakest = conditions.find((c) => !c.met);
+    const leverMap = {
+        'high-quality-trajectories': 'data-collection',
+        'stable-benchmark-tasks': 'bench-expansion',
+        'reward-human-correlation': 'reward-calibration',
+        'eval-regression-stable': 'eval-suite-stabilization',
+        'version-provenance': 'version-provenance',
+        'offline-eval-holdout': 'bench-expansion',
+    };
+    return {
+        verdict: allMet ? 'rl-eligible' : 'optimize-first',
+        conditions,
+        ...(allMet ? {} : { recommendedLever: weakest ? leverMap[weakest.id] : undefined }),
+        at: new Date().toISOString(),
+    };
+}

package/dist/skillpayload.d.ts.v2bak.v2bak

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

package/dist/skillpayload.js.v2bak

@@ -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/dist/skillpayload.js.v2bak.v2bak.v2bak

@@ -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/dist/skills.d.ts.v2bak.v2bak

@@ -0,0 +1,54 @@
+export type SkillState = 'draft' | 'canary' | 'active' | 'archived';
+export interface SkillEntry {
+    name: string;
+    description: string;
+    file: string;
+    state: SkillState;
+}
+/** Skills the user pinned: evolution never moves, merges or decays them.
+ *  Marked by a .pin file next to SKILL.md (cheap, visible, git-friendly). */
+export declare function pinSkill(home: string, name: string): Promise<boolean>;
+export declare function unpinSkill(home: string, name: string): Promise<boolean>;
+export declare function isPinned(file: string): Promise<boolean>;
+/**
+ * Install skills from a git URL or a local directory (`hmh skills add <src>`).
+ * Handles the three common repo layouts: SKILL.md at the root (single skill),
+ * skills/<name>/SKILL.md (multi-skill pack, e.g. greensock/gsap-skills), and
+ * <name>/SKILL.md one level down. Existing skill names are never overwritten.
+ */
+export declare function installSkills(src: string, home: string): Promise<{
+    installed: string[];
+    skipped: string[];
+}>;
+export declare function listSkills(home: string): Promise<SkillEntry[]>;
+export declare function listDrafts(home: string): Promise<SkillEntry[]>;
+/** Canary-state skills: promoted through the bench gates but still under
+ *  impact evaluation - injected into a sample of sessions, watermarked. */
+export declare function listCanary(home: string): Promise<SkillEntry[]>;
+export declare function skillsToPrompt(entries: SkillEntry[]): string;
+/** Write (or overwrite) a draft; drafts are cheap and reversible by deletion. */
+export declare function writeDraft(home: string, name: string, skillMd: string): Promise<string>;
+/**
+ * Promote a draft. Default target is `canary` (P0: bench-passing skills
+ * earn a canary slot first; full activation happens through the impact
+ * loop, not on the gate alone). `{canary: false}` promotes straight to
+ * active (used by the impact loop once evidence clears, and by `hmh skills
+ * promote`). If a same-name skill exists at the destination it is archived
+ * first (timestamped snapshot) so promotion is always reversible.
+ */
+export declare function promoteSkill(home: string, name: string, opts?: {
+    canary?: boolean;
+}): Promise<{
+    file: string;
+    archivedPrevious: boolean;
+}>;
+/** Graduate a canary skill to full active (the impact loop's decision). */
+export declare function promoteCanary(home: string, name: string): Promise<boolean>;
+/** Retire a canary skill back to draft (impact loop's rejection path) -
+ *  nothing is ever deleted (append-only red line). */
+export declare function retireCanary(home: string, name: string): Promise<boolean>;
+/** Restore the most recent archived snapshot of a skill back to active. */
+export declare function rollbackSkill(home: string, name: string): Promise<boolean>;
+/** Demote an active skill back to draft without deleting anything. */
+export declare function unpromoteSkill(home: string, name: string): Promise<boolean>;
+export declare function deleteDraft(home: string, name: string): Promise<boolean>;