dsh-continual-evolve 0.10.6 → 0.12.0

package/lib/score.js

@@ -1,191 +0,0 @@
-export const DEFAULT_AGGREGATE = {
-    passThreshold: 60,
-    regressionTolerance: 0,
-    maxFailedCells: 0,
-};
-/**
- * Aggregate raw cells into code-owned per-case means + overall mean.
- * Failure-cell protocol (gap A2): failed cells are EXCLUDED from means and
- * counted separately — a crashed unit can never silently drag the mean down
- * like a zero. A case whose cells all failed reports null (no mean).
- */
-export function aggregate(cells) {
-    const byCase = new Map();
-    let failed = 0;
-    for (const cell of cells) {
-        if (cell.status === "failed") {
-            failed += 1;
-            continue;
-        }
-        const list = byCase.get(cell.caseId) ?? [];
-        list.push(clampScore(cell.score));
-        byCase.set(cell.caseId, list);
-    }
-    const perCase = {};
-    for (const [caseId, scores] of byCase) {
-        perCase[caseId] = mean(scores);
-    }
-    const all = [...byCase.values()].flat();
-    let totalDurationMs = 0;
-    for (const cell of cells) {
-        if (cell.durationMs !== undefined && cell.durationMs >= 0) {
-            totalDurationMs += cell.durationMs;
-        }
-    }
-    return {
-        ...perCase,
-        overall: all.length > 0 ? mean(all) : null,
-        failed,
-        total: cells.length,
-        totalDurationMs,
-    };
-}
-export function entryFromCells(label, cells, refinementId) {
-    const aggr = aggregate(cells);
-    return {
-        label,
-        ...(refinementId ? { refinementId } : {}),
-        createdAt: new Date().toISOString(),
-        cells: [...cells],
-        aggregate: aggr,
-        overall: aggr.overall,
-    };
-}
-/** Human-readable decision report with per-case before → after deltas. */
-export function decisionReport(reference, candidate, decision) {
-    const lines = [`overall: ${reference.overall ?? "?"} → ${candidate.overall ?? "?"}`];
-    // Per-case deltas over the actual evaluated cases only (aggregate() mixes
-    // case means with metadata keys like totalDurationMs — never render those
-    // as cases).
-    for (const caseId of new Set(reference.cells.map((cell) => cell.caseId))) {
-        const refScore = reference.aggregate[caseId];
-        if (refScore === null || refScore === undefined)
-            continue;
-        const candScore = candidate.aggregate[caseId];
-        const failedMark = isCaseFailed(reference, caseId) || isCaseFailed(candidate, caseId) ? " (failed)" : "";
-        lines.push(`  ${caseId}: ${refScore} → ${candScore ?? "?"}${failedMark}`);
-    }
-    const refFailed = reference.aggregate.failed ?? 0;
-    const candFailed = candidate.aggregate.failed ?? 0;
-    if (refFailed > 0 || candFailed > 0) {
-        lines.push(`failed cells: reference ${refFailed}/${reference.aggregate.total ?? 0} · candidate ${candFailed}/${candidate.aggregate.total ?? 0}`);
-    }
-    // Gap C3: show duration summary when available.
-    const refDuration = reference.aggregate.totalDurationMs ?? 0;
-    const candDuration = candidate.aggregate.totalDurationMs ?? 0;
-    if (refDuration > 0 || candDuration > 0) {
-        lines.push(`duration: ${formatDuration(refDuration)} → ${formatDuration(candDuration)}`);
-    }
-    lines.push(decision.accepted
-        ? "DECISION: ACCEPTED — overall improved, no regression"
-        : `DECISION: REJECTED — ${decision.reasons.join("; ")}`);
-    return lines;
-}
-/**
- * Gap A3 (version_changed semantics): detect cells whose case material
- * changed between the reference and candidate evaluation runs. A candidate
- * cell whose `caseHash` differs from the reference cell of the SAME case
- * means the statement/rubric was edited between the two runs — its score is
- * not comparable to the baseline and must not count toward the decision.
- *
- * The check is conservative: cells without a hash on either side (pre-A3
- * data) and cells already failed are left untouched. Mismatched cells are
- * returned re-marked as `failed` with a reason in notes, so aggregation
- * excludes them and the acceptance rule can reject the round.
- */
-export function flagMaterialDrift(reference, candidateCells) {
-    const referenceHashes = new Map();
-    for (const cell of reference.cells) {
-        if (cell.status !== "failed" && cell.caseHash !== undefined && !referenceHashes.has(cell.caseId)) {
-            referenceHashes.set(cell.caseId, cell.caseHash);
-        }
-    }
-    if (referenceHashes.size === 0) {
-        return [...candidateCells];
-    }
-    return candidateCells.map((cell) => {
-        if (cell.status === "failed" || cell.caseHash === undefined) {
-            return cell;
-        }
-        const refHash = referenceHashes.get(cell.caseId);
-        if (refHash !== undefined && refHash !== cell.caseHash) {
-            return {
-                ...cell,
-                status: "failed",
-                passed: false,
-                notes: `materials changed: case ${cell.caseId} hash ${cell.caseHash} ≠ reference ${refHash} (re-run the reference or fix the material)`,
-            };
-        }
-        return cell;
-    });
-}
-function isCaseFailed(entry, caseId) {
-    return entry.cells.some((cell) => cell.caseId === caseId && cell.status === "failed");
-}
-/**
- * Non-regressive acceptance rule (Self-Harness style):
- * the candidate is accepted iff its overall mean is STRICTLY higher than the
- * reference, no case regresses by more than `regressionTolerance` points,
- * and neither side has more failed cells than `maxFailedCells` (failure-cell
- * protocol, gap A2 — a partial/invalid round is never accepted).
- */
-export function decide(reference, candidate, opts) {
-    const reasons = [];
-    if (reference.overall === null || candidate.overall === null) {
-        return { accepted: false, reasons: ["reference or candidate evaluation is incomplete"] };
-    }
-    const refFailed = reference.aggregate.failed ?? 0;
-    const candFailed = candidate.aggregate.failed ?? 0;
-    if (refFailed > opts.maxFailedCells) {
-        reasons.push(`reference has ${refFailed} failed cells (max ${opts.maxFailedCells})`);
-    }
-    if (candFailed > opts.maxFailedCells) {
-        reasons.push(`candidate has ${candFailed} failed cells (max ${opts.maxFailedCells})`);
-    }
-    if (reasons.length > 0) {
-        return { accepted: false, reasons };
-    }
-    if (candidate.overall <= reference.overall) {
-        reasons.push(`overall not improved: ${candidate.overall} <= ${reference.overall}`);
-    }
-    // Per-case regression is judged ONLY over the cases that actually exist in
-    // the evaluation — aggregate() mixes per-case means with metadata keys
-    // (failed/total/totalDurationMs), and iterating raw keys would (and did)
-    // treat totalDurationMs as a case score, rejecting a candidate whose run
-    // merely took longer. Derived from reference.cells, never from the
-    // aggregate key set.
-    for (const caseId of new Set(reference.cells.map((cell) => cell.caseId))) {
-        const refScore = reference.aggregate[caseId];
-        if (refScore === null || refScore === undefined) {
-            continue; // case had no comparable mean (all cells failed) — nothing to regress
-        }
-        const candScore = candidate.aggregate[caseId];
-        if (candScore === null || candScore === undefined) {
-            reasons.push(`candidate missing case ${caseId}`);
-            continue;
-        }
-        if (candScore < refScore - opts.regressionTolerance) {
-            reasons.push(`case ${caseId} regressed: ${candScore} < ${refScore} - ${opts.regressionTolerance}`);
-        }
-    }
-    return { accepted: reasons.length === 0, reasons };
-}
-function mean(values) {
-    const sum = values.reduce((acc, value) => acc + value, 0);
-    return round2(sum / values.length);
-}
-function clampScore(score) {
-    if (!Number.isFinite(score))
-        return 0;
-    return Math.min(100, Math.max(0, score));
-}
-function round2(value) {
-    return Math.round(value * 100) / 100;
-}
-/** Gap C3: human-readable duration (ms → "1.2s" or "340ms"). */
-function formatDuration(ms) {
-    if (ms < 1000)
-        return `${Math.round(ms)}ms`;
-    return `${(ms / 1000).toFixed(1)}s`;
-}
-//# sourceMappingURL=score.js.map

package/lib/search.d.ts

@@ -1,83 +0,0 @@
-/**
- * Retrieval primitives for injection ranking: CJK-aware tokenization plus a
- * dependency-free, field-weighted BM25 scorer (ADR
- * `implemented/feature/2026-08-24-cjk-bigram-bm25-retrieval.md`).
- *
- * Why this shape:
- * - the old scorer tokenized whole CJK runs as single tokens compared for
- *   exact equality, so any rewording of a Chinese query missed every entry
- *   (「检索升级」 never matched 「全文检索方案」); overlapping character
- *   bigrams — the standard cjk_bigram analyzer shape (Elasticsearch/
- *   OpenSearch) — fix recall while keeping English behavior identical;
- * - raw hit counts weighted common words and distinctive terms alike; BM25's
- *   IDF separates them. We use Lucene's non-negative variant
- *   `ln(1 + (N - df + 0.5) / (df + 0.5))` so EVERY matched token scores > 0
- *   and unmatched documents score exactly 0, preserving rankEntries'
- *   "relevant outranks recent-but-irrelevant" ordering invariant;
- * - the index lifetime is one ranking call. Stores hold tens~hundreds of
- *   entries (measured full rebuild + score: single-digit milliseconds), the
- *   JSON state files stay the single source of truth, and npm installers
- *   carry zero native/WASM baggage — better-sqlite3 FTS5, sql.js, MiniSearch,
- *   FlexSearch were all evaluated and rejected (see the ADR's alternatives).
- */
-import type { HarnessEntry } from "./types.js";
-/** BM25 term-saturation constant (Okapi k1). */
-export declare const BM25_K1 = 1.5;
-/** BM25 document-length normalization constant (Okapi b). */
-export declare const BM25_B = 0.75;
-/** Multiplier for title-field matches (title hits outweigh body hits 2:1). */
-export declare const TITLE_FIELD_WEIGHT = 2;
-/**
- * Tokenize text for relevance scoring: lowercase ASCII runs become word
- * tokens; CJK runs become overlapping character bigrams (a single-character
- * run stays a unigram). Deterministic and allocation-light — safe to call per
- * injection build.
- *
- * @param text Arbitrary entry or query text.
- * @returns Tokens in occurrence order (duplicates kept; consumers dedupe when
- *          order-independent weighting is wanted).
- */
-export declare function tokenize(text: string): string[];
-/** Per-field corpus statistics for one ranking pass. */
-interface FieldStats {
-    /** Term-frequency map per document, positioned like {@link RelevanceIndex.positions}. */
-    readonly tfs: ReadonlyArray<ReadonlyMap<string, number>>;
-    /** Token count per document (this field's dl for BM25 length normalization). */
-    readonly lengths: ReadonlyArray<number>;
-    /** Document frequency per distinct term across the corpus. */
-    readonly df: ReadonlyMap<string, number>;
-    /** Average token count across the corpus (0 when empty). */
-    readonly averageLength: number;
-}
-/** Precomputed corpus statistics backing {@link relevanceScore}. */
-export interface RelevanceIndex {
-    /** Number of documents in the corpus. */
-    readonly size: number;
-    /** Identity positions: the exact entry objects the index was built from. */
-    readonly positions: ReadonlyMap<object, number>;
-    readonly titles: FieldStats;
-    readonly bodies: FieldStats;
-}
-/**
- * Build the corpus statistics (per-field tf, df, average length) for one
- * ranking call. Pure: the index reads its input snapshot and never mutates
- * the entries.
- *
- * @param entries The candidate entries being ranked this call.
- * @returns An index that answers {@link relevanceScore} for exactly these
- *          entries (identity-keyed).
- */
-export declare function buildRelevanceIndex(entries: readonly HarnessEntry[]): RelevanceIndex;
-/**
- * Field-weighted BM25 score of `entry` against `query` within `index`:
- * `TITLE_FIELD_WEIGHT × bm25(title) + bm25(body)`. Query tokens are deduped,
- * so repeating a word adds no weight.
- *
- * @returns A score > 0 when at least one query token occurs in the entry
- *          (either field), and exactly 0 otherwise — the property rankEntries'
- *          relevance-first ordering relies on. Never throws; an entry outside
- *          the index simply scores 0.
- */
-export declare function relevanceScore(index: RelevanceIndex, entry: HarnessEntry, query: string): number;
-export {};
-//# sourceMappingURL=search.d.ts.map

package/lib/search.js

@@ -1,136 +0,0 @@
-/** BM25 term-saturation constant (Okapi k1). */
-export const BM25_K1 = 1.5;
-/** BM25 document-length normalization constant (Okapi b). */
-export const BM25_B = 0.75;
-/** Multiplier for title-field matches (title hits outweigh body hits 2:1). */
-export const TITLE_FIELD_WEIGHT = 2;
-/**
- * One pass, two run shapes: ASCII alphanumeric words, or maximal CJK runs.
- * Runs never mix scripts because the alternation splits at the boundary, so
- * 「深色主题dark主题」 tokenizes as 深色/色主/主题, "dark", 主题.
- */
-const TOKEN_RUN_PATTERN = /[a-z0-9]+|[\u4e00-\u9fff]+/g;
-const ASCII_RUN_PATTERN = /^[a-z0-9]+$/;
-/**
- * Tokenize text for relevance scoring: lowercase ASCII runs become word
- * tokens; CJK runs become overlapping character bigrams (a single-character
- * run stays a unigram). Deterministic and allocation-light — safe to call per
- * injection build.
- *
- * @param text Arbitrary entry or query text.
- * @returns Tokens in occurrence order (duplicates kept; consumers dedupe when
- *          order-independent weighting is wanted).
- */
-export function tokenize(text) {
-    const tokens = [];
-    for (const match of text.toLowerCase().matchAll(TOKEN_RUN_PATTERN)) {
-        const run = match[0];
-        if (ASCII_RUN_PATTERN.test(run)) {
-            tokens.push(run);
-        }
-        else if (run.length === 1) {
-            tokens.push(run);
-        }
-        else {
-            for (let i = 0; i < run.length - 1; i += 1) {
-                tokens.push(run.slice(i, i + 2));
-            }
-        }
-    }
-    return tokens;
-}
-function buildFieldStats(fieldTokens) {
-    const tfs = fieldTokens.map((tokens) => {
-        const tf = new Map();
-        for (const token of tokens) {
-            tf.set(token, (tf.get(token) ?? 0) + 1);
-        }
-        return tf;
-    });
-    const df = new Map();
-    let totalLength = 0;
-    for (let position = 0; position < tfs.length; position += 1) {
-        const tf = tfs[position];
-        let length = 0;
-        for (const count of tf.values()) {
-            length += count;
-        }
-        totalLength += length;
-        for (const token of tf.keys()) {
-            df.set(token, (df.get(token) ?? 0) + 1);
-        }
-    }
-    return {
-        tfs,
-        lengths: fieldTokens.map((tokens) => tokens.length),
-        df,
-        averageLength: tfs.length === 0 ? 0 : totalLength / tfs.length,
-    };
-}
-/**
- * Build the corpus statistics (per-field tf, df, average length) for one
- * ranking call. Pure: the index reads its input snapshot and never mutates
- * the entries.
- *
- * @param entries The candidate entries being ranked this call.
- * @returns An index that answers {@link relevanceScore} for exactly these
- *          entries (identity-keyed).
- */
-export function buildRelevanceIndex(entries) {
-    const titles = [];
-    const bodies = [];
-    for (const entry of entries) {
-        titles.push(tokenize(entry.title));
-        bodies.push(tokenize(`${entry.content} ${entry.path}`));
-    }
-    return {
-        size: entries.length,
-        positions: new Map(entries.map((entry, position) => [entry, position])),
-        titles: buildFieldStats(titles),
-        bodies: buildFieldStats(bodies),
-    };
-}
-/** One field's BM25 contribution for a single term (0 when the term is absent). */
-function bm25Term(termFrequency, documentFrequency, corpusSize, docLength, averageLength) {
-    if (termFrequency <= 0 || documentFrequency <= 0) {
-        return 0;
-    }
-    const inverseDocumentFrequency = Math.log(1 + (corpusSize - documentFrequency + 0.5) / (documentFrequency + 0.5));
-    const normalization = averageLength > 0 ? 1 - BM25_B + BM25_B * (docLength / averageLength) : 1;
-    return inverseDocumentFrequency * ((termFrequency * (BM25_K1 + 1)) / (termFrequency + BM25_K1 * normalization));
-}
-/**
- * Field-weighted BM25 score of `entry` against `query` within `index`:
- * `TITLE_FIELD_WEIGHT × bm25(title) + bm25(body)`. Query tokens are deduped,
- * so repeating a word adds no weight.
- *
- * @returns A score > 0 when at least one query token occurs in the entry
- *          (either field), and exactly 0 otherwise — the property rankEntries'
- *          relevance-first ordering relies on. Never throws; an entry outside
- *          the index simply scores 0.
- */
-export function relevanceScore(index, entry, query) {
-    const position = index.positions.get(entry);
-    if (position === undefined || index.size === 0) {
-        return 0;
-    }
-    const seen = new Set();
-    let titleScore = 0;
-    let bodyScore = 0;
-    for (const token of tokenize(query)) {
-        if (seen.has(token)) {
-            continue;
-        }
-        seen.add(token);
-        const titleDf = index.titles.df.get(token) ?? 0;
-        if (titleDf > 0) {
-            titleScore += bm25Term(index.titles.tfs[position]?.get(token) ?? 0, titleDf, index.size, index.titles.lengths[position] ?? 0, index.titles.averageLength);
-        }
-        const bodyDf = index.bodies.df.get(token) ?? 0;
-        if (bodyDf > 0) {
-            bodyScore += bm25Term(index.bodies.tfs[position]?.get(token) ?? 0, bodyDf, index.size, index.bodies.lengths[position] ?? 0, index.bodies.averageLength);
-        }
-    }
-    return TITLE_FIELD_WEIGHT * titleScore + bodyScore;
-}
-//# sourceMappingURL=search.js.map

package/lib/service.d.ts

@@ -1,49 +0,0 @@
-/**
- * The evolution engine: the only entry point that mutates harness state.
- * Every mutation path goes through here so snapshot-before-write, apply
- * accounting, persistence, and result history are enforced in one place.
- */
-import type { EntrySource, HarnessScope, RefinementProposal, RefinementResult } from "./types.js";
-import { applyRefinementProposal } from "./apply.js";
-import type { HistoryRetention } from "./store.js";
-/** A post-commit apply failure that still carries the durable applied result. */
-export declare class EvolutionApplyPostCommitError extends Error {
-    readonly result: RefinementResult;
-    readonly scope: HarnessScope;
-    readonly storeId: string | undefined;
-    readonly cause: unknown;
-    constructor(message: string, result: RefinementResult, scope: HarnessScope, storeId: string | undefined, cause: unknown);
-}
-export interface ApplyContext {
-    scope: HarnessScope;
-    sessionId?: string;
-    /** When set, optimistic-concurrency checks reject edits whose entries changed since this baseline. */
-    baselineState?: Parameters<typeof applyRefinementProposal>[0];
-    /** Trajectory citation stamped into newly created entries (see apply.ts). */
-    source?: EntrySource | undefined;
-    /** Marks the resulting refinement as the deterministic rollback of another (audit chain). */
-    rollbackOf?: string | undefined;
-}
-export interface EvolutionHooks {
-    /** Called after every applied refinement (side-effect boundary: skills sync, etc.). */
-    onApplied?: (result: RefinementResult) => void;
-}
-export interface EvolutionEngineOptions {
-    /**
-     * Storage-hygiene retention (#20): how many snapshots / JSONL tail
-     * lines each apply keeps. Resolved with generous defaults — rollback
-     * only needs recent snapshots and readers need a working window.
-     */
-    historyRetain?: Partial<HistoryRetention>;
-}
-export declare function createEvolutionEngine(baseDir: string, hooks?: EvolutionHooks, opts?: EvolutionEngineOptions): {
-    load: (scope: HarnessScope, sessionId: string | undefined) => import("./types.js").HarnessState;
-    apply: (scope: HarnessScope, sessionId: string | undefined, proposal: RefinementProposal, context?: ApplyContext) => RefinementResult;
-    rollback: (scope: HarnessScope, sessionId: string | undefined, refinementId: string) => RefinementResult;
-    rollbackResult: (scope: HarnessScope, sessionId: string | undefined, target: RefinementResult) => RefinementResult;
-    history: (scope: HarnessScope, sessionId: string | undefined) => RefinementResult[];
-    baseDir: string;
-    retention: HistoryRetention;
-};
-export type EvolutionEngine = ReturnType<typeof createEvolutionEngine>;
-//# sourceMappingURL=service.d.ts.map

package/lib/service.js

@@ -1,180 +0,0 @@
-import { CONFLICT_HINT_KEY } from "./types.js";
-import { applyRefinementProposal } from "./apply.js";
-import { randomUUID } from "node:crypto";
-import { rollbackProposal } from "./rollback.js";
-import { loadHarnessState, saveHarnessState } from "./state.js";
-import { appendResult, loadResults, pruneJsonlFile, pruneSnapshots, resolveHistoryRetention, snapshotBefore, storePaths } from "./store.js";
-import { materializeMemoryProjection } from "./projection.js";
-import { CONFLICT_BLOCK_SCORE, CONFLICT_WARN_SCORE, buildConflictNotice, mostSimilarEntry, secretLeakReason } from "./promotion.js";
-/** A post-commit apply failure that still carries the durable applied result. */
-export class EvolutionApplyPostCommitError extends Error {
-    result;
-    scope;
-    storeId;
-    cause;
-    constructor(message, result, scope, storeId, cause) {
-        super(message);
-        this.result = result;
-        this.scope = scope;
-        this.storeId = storeId;
-        this.cause = cause;
-    }
-}
-export function createEvolutionEngine(baseDir, hooks = {}, opts = {}) {
-    const retention = resolveHistoryRetention(opts.historyRetain);
-    /**
-     * Load a scope's state. For `project` the `sessionId` parameter carries
-     * the project key (see `resolveProjectKey` in project.ts); callers
-     * derive it with `projectKeyOf(agent)` and pass it through unchanged.
-     */
-    function load(scope, sessionId) {
-        return loadHarnessState(storePaths(baseDir, scope, sessionId).stateDir, scope);
-    }
-    function apply(scope, sessionId, proposal, context) {
-        const paths = storePaths(baseDir, scope, sessionId);
-        // Working state is ALWAYS the freshest on-disk snapshot: apply mutates
-        // and persists the state whole-file, so building on the caller's
-        // planning-time copy would silently overwrite concurrent writers
-        // (another gate run, another session writing global). The caller's
-        // baselineState is ONLY the optimistic-concurrency comparison baseline
-        // — "reject edits whose target changed since planning" (review audit
-        // 2026-08-28 B1: the two roles were previously folded into one object,
-        // which made the advertised guard unreachable).
-        const state = load(scope, sessionId);
-        // Write-time conflict guard (R2): persistent-scope creates are
-        // checked against the existing same-kind entries BEFORE any side
-        // effect — a near-duplicate is rejected with an actionable error
-        // (evolve_update instead), a moderate overlap proceeds stamped with
-        // CONFLICT_HINT_KEY. Rollbacks bypass the guard: re-creating an entry
-        // that resembles its successor is the point of rollback. Local scope
-        // is never blocked (scratch space); the wrapup/fate promotion path
-        // already enforces its own overlap policy there.
-        //
-        // Secret-leak guard (P0, same throat): every persistent-scope create
-        // and update is screened before any side effect. Project and global
-        // stores both outlive the current session, so approval never turns a
-        // credential-shaped literal into an allowed write. The screen covers
-        // every field the edit can plant: title, content, and the JSON forms
-        // of reference, arguments, and metadata. Fixed patterns, not policy-
-        // configurable.
-        const warnHits = new Map();
-        if ((scope === "project" || scope === "global") && !context?.rollbackOf) {
-            for (const [index, edit] of proposal.edits.entries()) {
-                if (edit.action === "create" || edit.action === "update") {
-                    const screenable = [
-                        typeof edit.id === "string" ? edit.id : "",
-                        typeof edit.path === "string" ? edit.path : "",
-                        typeof edit.title === "string" ? edit.title : "",
-                        typeof edit.content === "string" ? edit.content : "",
-                        edit.reference !== undefined ? JSON.stringify(edit.reference) : "",
-                        edit.arguments !== undefined ? JSON.stringify(edit.arguments) : "",
-                        edit.metadata !== undefined ? JSON.stringify(edit.metadata) : "",
-                    ];
-                    const secret = secretLeakReason(screenable.join("\n"));
-                    if (secret) {
-                        throw new Error(`${edit.action} blocked: ${secret}`);
-                    }
-                }
-                if (edit.action !== "create")
-                    continue;
-                // An unknown kind must fail per-edit in validateEdit, never
-                // crash the whole proposal here (review audit 2026-08-28 S1).
-                const corpus = state.entries[edit.kind];
-                if (!corpus)
-                    continue;
-                const hit = mostSimilarEntry(Object.values(corpus), edit.title ?? "", edit.content ?? "", CONFLICT_WARN_SCORE);
-                if (!hit)
-                    continue;
-                if (hit.score >= CONFLICT_BLOCK_SCORE) {
-                    throw new Error(`create blocked: ${buildConflictNotice(hit)} already lives in the global ${edit.kind} store — use evolve_update on it instead of adding a duplicate`);
-                }
-                warnHits.set(index, hit);
-            }
-        }
-        const id = `evolve_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
-        // Code-enforced snapshot: runs before any mutation, cannot be skipped by the model.
-        snapshotBefore(paths, id);
-        const result = applyRefinementProposal(state, proposal, {
-            id,
-            scope,
-            ...(context?.source ? { source: context.source } : {}),
-            ...(context?.baselineState ? { baselineState: context.baselineState } : {}),
-            ...(context?.rollbackOf ? { rollbackOf: context.rollbackOf } : {}),
-        });
-        // Stamp warn-tier conflicts onto the freshly created entries (both the
-        // live state and the result's after-snapshot stay coherent).
-        for (const [index, hit] of warnHits) {
-            const applied = result.appliedEdits[index];
-            if (!applied?.applied || applied.action !== "create" || !applied.id)
-                continue;
-            const hint = `${applied.kind}:${hit.id}:${hit.score.toFixed(2)}`;
-            const live = state.entries[applied.kind][applied.id];
-            if (live) {
-                live.metadata[CONFLICT_HINT_KEY] = hint;
-                if (applied.after) {
-                    applied.after.metadata[CONFLICT_HINT_KEY] = hint;
-                }
-            }
-        }
-        saveHarnessState(paths.stateDir, state);
-        try {
-            appendResult(paths, result);
-        }
-        catch (cause) {
-            throw new EvolutionApplyPostCommitError(`Refinement ${result.id} persisted state but failed to append history: ${cause instanceof Error ? cause.message : String(cause)}`, result, scope, sessionId, cause);
-        }
-        // Storage hygiene (#20): bound the append-only past at write time —
-        // snapshots keep the newest N, the per-store history keeps its tail.
-        // Best-effort (never throws): a prune failure must not fail the apply.
-        try {
-            pruneSnapshots(paths.snapshotsDir, retention.snapshots);
-        }
-        catch {
-            // ignored — the next apply retries
-        }
-        try {
-            pruneJsonlFile(paths.resultsPath, retention.refinements);
-        }
-        catch {
-            // ignored — the next apply retries
-        }
-        // Readable Markdown projection (P1): rewritten from the post-apply
-        // state whenever a memory edit landed, so rollback and archive stay
-        // in sync through this same apply path. The model has no writer for
-        // these files — only this engine entry point materializes them.
-        if (result.appliedEdits.some((edit) => edit.applied && edit.kind === "memory")) {
-            try {
-                materializeMemoryProjection(paths.stateDir, state);
-            }
-            catch {
-                // ignored — the projection is derived (JSON stays the source
-                // of truth) and the next memory apply retries
-            }
-        }
-        try {
-            hooks.onApplied?.(result);
-        }
-        catch (cause) {
-            throw new EvolutionApplyPostCommitError(`Refinement ${result.id} persisted state but a post-commit hook failed: ${cause instanceof Error ? cause.message : String(cause)}`, result, scope, sessionId, cause);
-        }
-        return result;
-    }
-    /** Roll back an already-observed result without consulting history. */
-    function rollbackResult(scope, sessionId, target) {
-        return apply(scope, sessionId, rollbackProposal(target), { scope, rollbackOf: target.id });
-    }
-    function rollback(scope, sessionId, refinementId) {
-        const paths = storePaths(baseDir, scope, sessionId);
-        const history = loadResults(paths);
-        const target = history.find((item) => item.id === refinementId);
-        if (!target) {
-            throw new Error(`Refinement ${refinementId} not found in ${scope} history`);
-        }
-        return rollbackResult(scope, sessionId, target);
-    }
-    function history(scope, sessionId) {
-        return loadResults(storePaths(baseDir, scope, sessionId));
-    }
-    return { load, apply, rollback, rollbackResult, history, baseDir, retention };
-}
-//# sourceMappingURL=service.js.map

package/lib/skill-render.d.ts

@@ -1,23 +0,0 @@
-/**
- * Skill rendering: pure functions that convert harness entries into
- * SKILL.md documents. Extracted from skill.ts to break the circular
- * dependency between skill.ts ↔ skillquality.ts.
- *
- * Both skill.ts (materializer) and skillquality.ts (validator) need
- * these rendering functions; importing from this shared leaf module
- * keeps the dependency graph acyclic.
- */
-import type { HarnessEntry } from "./types.js";
-/** Convert a harness entry id (underscore slug) to a kebab-case skill name. */
-export declare function skillNameOf(id: string): string;
-/**
- * Render a harness skill entry as a discoverable SKILL.md document.
- *
- * 2026-08-22: the frontmatter description now carries a ROUTING HINT —
- * title plus the first meaningful content line — instead of the bare title.
- * The skill catalog matches on description; a title-only description gave
- * loaders nothing to route on (observed: materialized skills were 7-line
- * stubs with a one-line description and no use-when signal).
- */
-export declare function renderSkillMarkdown(entry: HarnessEntry): string;
-//# sourceMappingURL=skill-render.d.ts.map