dsh-continual-evolve 0.10.6 → 0.12.0

package/lib/review.js

@@ -1,145 +0,0 @@
-import { extractJsonObject } from "./plan.js";
-import { formatHarnessStateForPrompt, historyForPrompt } from "./render.js";
-import { sessionEventsOf } from "./inject.js";
-import { buildPrefixMessages, detectPlannerRoute, resolvePrefixCache } from "./prefix-cache.js";
-import { asLlmSessionId, streamText } from "./llm-text.js";
-import { createTokenUsageObserver } from "./token-usage.js";
-import { recordLanguageInstruction, resolveRecordLanguage } from "./record-language.js";
-export const AUTO_REVIEW_SYSTEM_PROMPT = `You are the automatic /evolve review gate.
-
-Decide whether this checkpoint should continue the non-memory /evolve path.
-A dedicated memory extraction agent has already processed the same snapshot
-with a frozen memory manifest, so do NOT approve solely to create, update,
-archive, or delete a memory entry. Decline with a rationale that the memory
-phase owns that evidence. For the remaining kinds, approve ONLY when the
-trajectory shows repeated evidence: the same failure, tactic, delegation
-role, or behavioral policy recurs at least twice across turns. A single
-one-off interaction defaults to decline no matter how useful it looks for
-future turns — one data point is never enough to generalize. When approving,
-cite the repeated spans in the instructions so the planner can ground its
-edits.
-
-The current harness state below includes GLOBAL entries (scope=global) plus
-this session's local entries (scope=local). When a topic is already covered
-by a global entry, do NOT approve a local duplicate of it — decline and say
-in the rationale that the topic is already covered globally.
-
-Reject one-off noise, unsupported hypotheses, transient tool outputs, and
-requests that carry no reusable content.
-
-Stale local entries (superseded, long-unused, obsolete facts) are a valid
-refine target: approve with instructions naming the entry ids, and tell the
-planner to archive them (archive hides from injection, data stays restorable)
-rather than delete.
-
-Skill-related trajectories (the evidence concerns creating or improving a
-skill entry) are judged against the DSH skill quality standard (skill-audit
-dimensions: frontmatter routing, the 7 structural features, paragraph
-skeleton, no duplication of the official 11 skills or covered skills).
-Approve only when the trajectory shows a REAL trigger scenario and the
-resulting skill would meet the standard; otherwise decline and say in the
-rationale what must improve — drafting follows skill-creator, and the
-planner receives the standard as its <skill_quality_standard> block.
-
-Repeated multi-step workflows (session start/end routines, recurring
-wrap-up or handoff procedures) are a valid refine target: approve with
-instructions telling the planner to propose a guidance skill (kind=skill,
-skill_kind=guidance — a SKILL.md document, no python reference). Only
-propose when the same workflow recurs in the trajectory — never for
-one-off flows. Auto-created skills are always offered to the user for a
-decision before they land; the gate never writes a skill silently.
-
-Return JSON only:
-{
-  "shouldRefine": true|false,
-  "rationale": "short reason",
-  "instructions": "optional concise instructions for /evolve if shouldRefine is true"
-}`;
-/** Parse the gate's JSON reply. */
-export function parseAutoRefineReview(text) {
-    const value = extractJsonObject(text);
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        throw new Error("auto-refine review JSON must be an object");
-    }
-    const record = value;
-    const review = {
-        shouldRefine: record["shouldRefine"] === true,
-        rationale: typeof record["rationale"] === "string" ? record["rationale"] : "No rationale provided.",
-    };
-    if (typeof record["instructions"] === "string" && record["instructions"].length > 0) {
-        review.instructions = record["instructions"];
-    }
-    return review;
-}
-/** Serialize surface events to bounded role-prefixed text. */
-export function serializeSurface(events, maxChars) {
-    const lines = [];
-    for (const raw of events) {
-        if (typeof raw !== "object" || raw === null)
-            continue;
-        const event = raw;
-        const role = event.type === "user/message" ? "user" : event.type === "assistant/message" ? "assistant" : null;
-        if (role === null)
-            continue;
-        const content = event.data?.content;
-        if (!Array.isArray(content))
-            continue;
-        const text = content
-            .filter((block) => typeof block === "object" && block !== null && block.type === "text")
-            .map((block) => block.text ?? "")
-            .filter(Boolean)
-            .join(" ");
-        if (text.length > 0) {
-            lines.push(`${role}: ${text}`);
-        }
-    }
-    const joined = lines.join("\n");
-    return joined.length <= maxChars ? joined : joined.slice(-maxChars);
-}
-export async function reviewAutoRefine(ctx, options) {
-    const { agent, state, history } = options;
-    const provider = options.overrideProvider ?? agent.options.provider;
-    const model = options.overrideModel ?? agent.options.model;
-    if (!provider || !model) {
-        throw new Error("evolve: no provider/model route for the review gate");
-    }
-    if (!options.trajectory || options.trajectory.length === 0) {
-        throw new Error("evolve: review gate has no trajectory to judge");
-    }
-    // Route A carries the judged conversation as a session-derived message
-    // prefix and drops the flat block; an empty prefix falls back to B.
-    const events = options.trajectoryEvents ?? sessionEventsOf(agent);
-    const routing = resolvePrefixCache(options.prefixCache);
-    const route = detectPlannerRoute(events, routing.mode);
-    let prefixMessages = [];
-    if (route === "A") {
-        prefixMessages = buildPrefixMessages(events, {
-            ...(provider ? { provider } : {}),
-            ...(model ? { model } : {}),
-            maxChars: routing.maxChars,
-        });
-    }
-    const conversationBlock = prefixMessages.length > 0 ? "" : `<conversation>\n${options.trajectory}\n</conversation>`;
-    const userPrompt = [
-        `<trigger>\n${options.context.reason}; ${options.context.turnsSinceLastReview} turns since the last review\n</trigger>`,
-        `<current_harness_state>\n${formatHarnessStateForPrompt(state)}\n</current_harness_state>`,
-        `<refinement_history>\n${historyForPrompt(history)}\n</refinement_history>`,
-        conversationBlock,
-        "Return shouldRefine=true only when the trajectory shows repeated evidence (>=2 occurrences) useful to this session's future turns. A single one-off interaction defaults to shouldRefine=false. Prefer local edits; do not ask for global refinement here.",
-    ]
-        .filter(Boolean)
-        .join("\n\n");
-    const text = await streamText(ctx, {
-        provider,
-        model,
-        sessionId: asLlmSessionId(agent.id),
-        system: `${AUTO_REVIEW_SYSTEM_PROMPT}\n\n${recordLanguageInstruction(options.language ?? resolveRecordLanguage({ ctx, trajectoryText: options.trajectory }))}`,
-        prompt: userPrompt,
-        maxTokens: options.budgetTokens ?? 8000,
-        signal: options.signal,
-        ...(prefixMessages.length > 0 ? { prefixMessages } : {}),
-        ...(options.tokenUsage ? { onUsage: createTokenUsageObserver(options.tokenUsage, "review", provider, model) } : {}),
-    });
-    return parseAutoRefineReview(text);
-}
-//# sourceMappingURL=review.js.map

package/lib/rollback.d.ts

@@ -1,9 +0,0 @@
-/**
- * Deterministic rollback: rebuild the inverse edit list from the applied
- * result, in reverse order. Rollback is pure data transformation — no LLM
- * is asked to "guess" the previous state.
- */
-import type { RefinementProposal, RefinementResult } from "./types.js";
-/** Build the inverse proposal for an applied refinement. */
-export declare function rollbackProposal(target: RefinementResult): RefinementProposal;
-//# sourceMappingURL=rollback.d.ts.map

package/lib/rollback.js

@@ -1,68 +0,0 @@
-/** Build the inverse proposal for an applied refinement. */
-export function rollbackProposal(target) {
-    const edits = [];
-    for (const edit of [...target.appliedEdits].reverse()) {
-        if (!edit.applied)
-            continue;
-        const inverse = inverseEdit(edit, target.id);
-        if (inverse) {
-            edits.push(inverse);
-        }
-    }
-    return {
-        summary: `Rollback refinement ${target.id}`,
-        rationale: `Restores harness state to the snapshot recorded before refinement ${target.id}.`,
-        expectedOutcome: "Faulty refinement edits are reverted.",
-        edits,
-    };
-}
-function inverseEdit(edit, refinementId) {
-    if (edit.before && edit.after) {
-        // Forward action was an update: restore the before snapshot.
-        // skill_kind rides along (review audit 2026-08-28 B4): without it a
-        // rollback could flip the skill form or fail validation on re-apply.
-        return {
-            action: "update",
-            kind: edit.kind,
-            id: edit.id,
-            title: edit.before.title,
-            content: edit.before.content,
-            path: edit.before.path,
-            reference: edit.before.reference,
-            arguments: edit.before.arguments,
-            ...(edit.before.skill_kind !== undefined ? { skill_kind: edit.before.skill_kind } : {}),
-            metadata: edit.before.metadata,
-            reason: `Rollback ${refinementId}`,
-        };
-    }
-    if (edit.before) {
-        // Forward action was a delete: re-create the entry from the snapshot.
-        // skill_kind is required for the re-created skill to pass the same
-        // contract validation as the original create (B4: a deleted guidance
-        // skill was previously unrecoverable via rollback).
-        return {
-            action: "create",
-            kind: edit.kind,
-            id: edit.id,
-            title: edit.before.title,
-            content: edit.before.content,
-            path: edit.before.path,
-            reference: edit.before.reference,
-            arguments: edit.before.arguments,
-            ...(edit.before.skill_kind !== undefined ? { skill_kind: edit.before.skill_kind } : {}),
-            metadata: edit.before.metadata,
-            reason: `Rollback ${refinementId}`,
-        };
-    }
-    if (edit.after) {
-        // Forward action was a create: delete the created entry.
-        return {
-            action: "delete",
-            kind: edit.kind,
-            id: edit.id,
-            reason: `Rollback ${refinementId}`,
-        };
-    }
-    return undefined;
-}
-//# sourceMappingURL=rollback.js.map

package/lib/rubric.d.ts

@@ -1,29 +0,0 @@
-/** The development fallback key — reachable only when the local key file is unusable. */
-export declare const DEV_RUBRIC_KEY = "dsh-continual-evolve-dev-key";
-/** Name of the per-installation key file under `<baseDir>/evolve/`. */
-export declare const RUBRIC_KEY_FILE_NAME = "rubric.key";
-/** Full path of the per-installation rubric key file. */
-export declare function rubricKeyFilePath(baseDir: string): string;
-export interface RubricCipher {
-    iv: string;
-    tag: string;
-    data: string;
-}
-export declare const RUBRIC_PREFIX = "v1:";
-/** Derive a 32-byte AES-256 key from any passphrase. */
-export declare function deriveKey(passphrase: string): Buffer;
-/** Resolve the effective rubric key with the documented precedence. */
-export declare function resolveRubricKey(baseDir: string, configKey: string | undefined, env?: NodeJS.ProcessEnv, warn?: (message: string) => void): Buffer;
-/** Encrypt rubric plaintext into the `v1:` envelope (never written raw). */
-export declare function encryptRubric(plaintext: string, key: Buffer): string;
-/**
- * Decrypt a `v1:` envelope. Legacy plaintext (no prefix) passes through
- * unchanged so pre-ACL benchmark files keep working. Throws on tampered
- * data, a wrong key, or a malformed envelope.
- */
-export declare function decryptRubric(payload: string, key: Buffer): string;
-/** True when a stored rubric is an encrypted envelope rather than legacy plaintext. */
-export declare function isEncryptedRubric(payload: string): boolean;
-/** Shape helper for tests and callers that inspect envelopes. */
-export declare function parseEnvelope(payload: string): RubricCipher | undefined;
-//# sourceMappingURL=rubric.d.ts.map

package/lib/rubric.js

@@ -1,119 +0,0 @@
-/**
- * Rubric ACL: rubric plaintext never touches the disk. The evaluation runner
- * is the ONLY consumer that decrypts — the optimizer (planner) and the model
- * (with its bash tools) can read benchmark files and see ciphertext only, so
- * rubric isolation is enforced by code, not by prompt construction.
- *
- * Format: `v1:<base64(iv) | base64(tag) | base64(ciphertext)>` — each part is
- * URL-safe base64 without padding, joined by `|`. A value without the `v1:`
- * prefix is treated as legacy plaintext (pre-ACL files) and passes through.
- *
- * Key resolution (first match wins):
- *   1. plugin config `rubricKey`
- *   2. environment `DSH_EVOLVE_RUBRIC_KEY`
- *   3. a per-installation local key file at `<baseDir>/evolve/rubric.key`
- *      (auto-generated with 0600 permissions on first use — every install
- *      gets its own random key, so no user setup is needed and no publicly
- *      known key protects anyone's rubrics)
- *   4. a fixed development key as a last-resort fallback when the key file
- *      can neither be read nor written (warns; only reachable in
- *      pathological environments, since the plugin's stores live under the
- *      same directory)
- * The key string is derived to 32 bytes with SHA-256, so any passphrase works.
- */
-import { createCipheriv, createDecipheriv, createHash, randomBytes } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-/** The development fallback key — reachable only when the local key file is unusable. */
-export const DEV_RUBRIC_KEY = "dsh-continual-evolve-dev-key";
-/** Name of the per-installation key file under `<baseDir>/evolve/`. */
-export const RUBRIC_KEY_FILE_NAME = "rubric.key";
-/** Full path of the per-installation rubric key file. */
-export function rubricKeyFilePath(baseDir) {
-    return join(baseDir, "evolve", RUBRIC_KEY_FILE_NAME);
-}
-export const RUBRIC_PREFIX = "v1:";
-/** Derive a 32-byte AES-256 key from any passphrase. */
-export function deriveKey(passphrase) {
-    return createHash("sha256").update(passphrase, "utf8").digest();
-}
-/** Resolve the effective rubric key with the documented precedence. */
-export function resolveRubricKey(baseDir, configKey, env = process.env, warn) {
-    if (configKey && configKey.length > 0) {
-        return deriveKey(configKey);
-    }
-    const envKey = env["DSH_EVOLVE_RUBRIC_KEY"];
-    if (envKey && envKey.length > 0) {
-        return deriveKey(envKey);
-    }
-    return loadOrCreateLocalKey(baseDir, warn);
-}
-/**
- * Load the per-installation key file, generating a fresh random key (0600)
- * on first use. Falls back to the development key with a warning when the
- * file can neither be read nor written.
- */
-function loadOrCreateLocalKey(baseDir, warn) {
-    const path = rubricKeyFilePath(baseDir);
-    try {
-        if (existsSync(path)) {
-            const content = readFileSync(path, "utf8").trim();
-            if (content.length > 0) {
-                return deriveKey(content);
-            }
-        }
-        const key = randomBytes(32).toString("hex");
-        mkdirSync(dirname(path), { recursive: true });
-        writeFileSync(path, `${key}\n`, { encoding: "utf8", mode: 0o600 });
-        return deriveKey(key);
-    }
-    catch (cause) {
-        warn?.(`rubric encryption: cannot read/write the local key file (${path}): ${cause instanceof Error ? cause.message : String(cause)} — using the development key`);
-        return deriveKey(DEV_RUBRIC_KEY);
-    }
-}
-/** Encrypt rubric plaintext into the `v1:` envelope (never written raw). */
-export function encryptRubric(plaintext, key) {
-    const iv = randomBytes(12);
-    const cipher = createCipheriv("aes-256-gcm", key, iv);
-    const data = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
-    const tag = cipher.getAuthTag();
-    return `${RUBRIC_PREFIX}${[iv, tag, data].map((part) => part.toString("base64url")).join("|")}`;
-}
-/**
- * Decrypt a `v1:` envelope. Legacy plaintext (no prefix) passes through
- * unchanged so pre-ACL benchmark files keep working. Throws on tampered
- * data, a wrong key, or a malformed envelope.
- */
-export function decryptRubric(payload, key) {
-    if (!payload.startsWith(RUBRIC_PREFIX)) {
-        return payload; // legacy plaintext file
-    }
-    const raw = payload.slice(RUBRIC_PREFIX.length);
-    const parts = raw.split("|");
-    if (parts.length !== 3) {
-        throw new Error("rubric: malformed encrypted envelope");
-    }
-    const [ivText, tagText, dataText] = parts;
-    const iv = Buffer.from(ivText, "base64url");
-    const tag = Buffer.from(tagText, "base64url");
-    const data = Buffer.from(dataText, "base64url");
-    const decipher = createDecipheriv("aes-256-gcm", key, iv);
-    decipher.setAuthTag(tag);
-    return Buffer.concat([decipher.update(data), decipher.final()]).toString("utf8");
-}
-/** True when a stored rubric is an encrypted envelope rather than legacy plaintext. */
-export function isEncryptedRubric(payload) {
-    return payload.startsWith(RUBRIC_PREFIX);
-}
-/** Shape helper for tests and callers that inspect envelopes. */
-export function parseEnvelope(payload) {
-    if (!isEncryptedRubric(payload))
-        return undefined;
-    const parts = payload.slice(RUBRIC_PREFIX.length).split("|");
-    if (parts.length !== 3)
-        return undefined;
-    const [iv, tag, data] = parts;
-    return { iv, tag, data };
-}
-//# sourceMappingURL=rubric.js.map

package/lib/runtime.d.ts

@@ -1,24 +0,0 @@
-/** On-disk runtime gate state. Version 2 adds an explicit enable bit. */
-export interface GateRuntime {
-    version: 2;
-    /** Whether the human has enabled automatic review. */
-    enabled: boolean;
-    /** Whether the human has explicitly paused automatic review. */
-    paused: boolean;
-    /** ISO timestamp of the last pause/resume write. */
-    updatedAt: string;
-}
-/** Full path of the runtime switch file. */
-export declare function runtimePath(baseDir: string): string;
-/**
- * Load the runtime switch. Missing, malformed, or legacy content uses the
- * supplied configured default and never throws; this is a trigger-path read.
- */
-export declare function loadGateRuntime(baseDir: string, defaultEnabled?: boolean): GateRuntime;
-/** Persist the runtime switch atomically (temp file + rename). */
-export declare function saveGateRuntime(baseDir: string, paused: boolean, enabled?: boolean): string;
-/** True while the human paused the automatic review gate. */
-export declare function isGatePaused(baseDir: string): boolean;
-/** Effective automatic-review state, including the explicit enable bit. */
-export declare function isGateEnabled(baseDir: string, defaultEnabled?: boolean): boolean;
-//# sourceMappingURL=runtime.d.ts.map

package/lib/runtime.js

@@ -1,87 +0,0 @@
-/**
- * Runtime gate switch: a small human-owned file that enables or pauses the
- * automatic review listener without editing the profile or restarting DSH.
- *
- * - file: `<baseDir>/evolve/runtime.json` (`{version: 2, enabled, paused, updatedAt}`)
- * - the file is consulted at every trigger and before scheduler execution;
- * - `/evolve pause` sets `paused`, `/evolve resume` sets `enabled=true` and
- *   clears the pause, while manual tools and commands remain independent;
- * - a missing or malformed file uses the caller's configured default. A
- *   legacy v1 `{paused}` file is readable and preserves its pause state.
- */
-import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
-import { randomUUID } from "node:crypto";
-import { join } from "node:path";
-import { EVOLVE_DIR } from "./store.js";
-const RUNTIME_FILE = "runtime.json";
-/** Full path of the runtime switch file. */
-export function runtimePath(baseDir) {
-    return join(baseDir, EVOLVE_DIR, RUNTIME_FILE);
-}
-function state(enabled, paused) {
-    return { version: 2, enabled, paused, updatedAt: new Date(0).toISOString() };
-}
-/**
- * Load the runtime switch. Missing, malformed, or legacy content uses the
- * supplied configured default and never throws; this is a trigger-path read.
- */
-export function loadGateRuntime(baseDir, defaultEnabled = false) {
-    const path = runtimePath(baseDir);
-    if (!existsSync(path))
-        return state(defaultEnabled, false);
-    try {
-        const raw = JSON.parse(readFileSync(path, "utf8"));
-        if (typeof raw !== "object" || raw === null || Array.isArray(raw))
-            return state(defaultEnabled, false);
-        const record = raw;
-        const paused = record["paused"] === true;
-        // v1 had no enable bit. Its only meaningful state was pause, so retain
-        // the configured default when it is not paused.
-        const enabled = typeof record["enabled"] === "boolean" ? record["enabled"] : defaultEnabled;
-        return {
-            version: 2,
-            enabled,
-            paused,
-            updatedAt: typeof record["updatedAt"] === "string" ? record["updatedAt"] : new Date(0).toISOString(),
-        };
-    }
-    catch {
-        return state(defaultEnabled, false);
-    }
-}
-/** Persist the runtime switch atomically (temp file + rename). */
-export function saveGateRuntime(baseDir, paused, enabled = true) {
-    const path = runtimePath(baseDir);
-    mkdirSync(join(baseDir, EVOLVE_DIR), { recursive: true });
-    const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
-    const payload = { version: 2, enabled, paused, updatedAt: new Date().toISOString() };
-    writeFileSync(tempPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
-    try {
-        renameSync(tempPath, path);
-    }
-    finally {
-        if (existsSync(tempPath))
-            unlinkSync(tempPath);
-    }
-    return path;
-}
-/** True while the human paused the automatic review gate. */
-export function isGatePaused(baseDir) {
-    try {
-        return loadGateRuntime(baseDir).paused;
-    }
-    catch {
-        return false;
-    }
-}
-/** Effective automatic-review state, including the explicit enable bit. */
-export function isGateEnabled(baseDir, defaultEnabled = false) {
-    try {
-        const current = loadGateRuntime(baseDir, defaultEnabled);
-        return current.enabled && !current.paused;
-    }
-    catch {
-        return defaultEnabled;
-    }
-}
-//# sourceMappingURL=runtime.js.map

package/lib/score.d.ts

@@ -1,64 +0,0 @@
-/**
- * Code-owned scoring: aggregation and acceptance decisions. The model only
- * produces per-cell raw scores; every average and every accept/reject call
- * happens here, in deterministic code.
- */
-import type { CellScore, EvaluationEntry } from "./benchmark.js";
-export interface AggregateOptions {
-    /** A cell is "passed" if its raw score is at least this threshold. */
-    passThreshold: number;
-    /** Per-case regression tolerance: candidate may drop below reference by at most this much. */
-    regressionTolerance: number;
-    /**
-     * Failure-cell protocol (gap A2): a round with more failed cells than
-     * this is rejected outright — failed cells are NEVER averaged in as
-     * zeros. Default 0 (any failure rejects the round).
-     */
-    maxFailedCells: number;
-}
-export declare const DEFAULT_AGGREGATE: AggregateOptions;
-export interface AggregateResult extends Record<string, number | null> {
-    overall: number | null;
-    /** Count of failed cells (excluded from every mean). */
-    failed: number;
-    /** Total cells considered (ok + failed). */
-    total: number;
-    /** Gap C3: total wall-clock duration of all cells in milliseconds. */
-    totalDurationMs: number;
-}
-/**
- * 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 declare function aggregate(cells: readonly CellScore[]): AggregateResult;
-export declare function entryFromCells(label: string, cells: readonly CellScore[], refinementId?: string): EvaluationEntry;
-export interface Decision {
-    accepted: boolean;
-    reasons: string[];
-}
-/** Human-readable decision report with per-case before → after deltas. */
-export declare function decisionReport(reference: EvaluationEntry, candidate: EvaluationEntry, decision: Decision): string[];
-/**
- * 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 declare function flagMaterialDrift(reference: EvaluationEntry, candidateCells: readonly CellScore[]): CellScore[];
-/**
- * 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 declare function decide(reference: EvaluationEntry, candidate: EvaluationEntry, opts: AggregateOptions): Decision;
-//# sourceMappingURL=score.d.ts.map