dsh-continual-evolve 0.10.6 → 0.12.0

package/lib/declines.js

@@ -1,175 +0,0 @@
-/**
- * Cross-session ledger of declined memory proposals (the decline loop).
- *
- * In-memory `GateState.memoryDecisions` dies on restart and its decision
- * cursor is per-checkpoint, so a declined project/global batch is re-asked
- * in the next session. This file persists batch fingerprints plus content
- * tokens under `<baseDir>/evolve/declined-memory.json`: exact batches are
- * suppressed at approval time, and checkpoints overlapping declined content
- * are suppressed before the agent is even invoked. Token matching is
- * containment (entry ⊆ checkpoint) with a conservative floor; rephrasing
- * below the floor still asks (documented limitation, not silent loss).
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { createHash } from "node:crypto";
-import { join } from "node:path";
-import { secretLeakReason } from "./promotion.js";
-import { tokenize } from "./search.js";
-import { EVOLVE_DIR } from "./store.js";
-/** Cap on remembered declines; oldest-first pruning keeps the file small. */
-export const MAX_DECLINED_MEMORY_LEDGER = 50;
-/** Cap on stored content tokens per entry; enough for coverage, never prose. */
-export const MAX_DECLINED_ENTRY_TOKENS = 128;
-/** Minimum coverage of an entry's tokens by the checkpoint to pre-suppress. */
-export const DECLINED_PRECHECK_COVERAGE = 0.85;
-/** Minimum overlapping tokens; tiny entries must never match vacuously. */
-export const DECLINED_PRECHECK_MIN_TOKENS = 5;
-const DECLINED_MEMORY_FILE = "declined-memory.json";
-/** Full path of the decline ledger file. */
-export function declinedMemoryPath(baseDir) {
-    return join(baseDir, EVOLVE_DIR, DECLINED_MEMORY_FILE);
-}
-/**
- * Fingerprint one scope batch. Normalization is whitespace-only on purpose:
- * case folding could conflate distinct facts (e.g. env var names), and a
- * missed match only costs one more popup (fail-closed).
- *
- * @param scope - persistent scope the batch targets.
- * @param edits - the scope batch in proposal order (order is significant).
- * @returns 16-char hex fingerprint.
- */
-export function fingerprintMemoryBatch(scope, edits) {
-    const parts = [scope];
-    for (const edit of edits) {
-        parts.push([edit.action, edit.id ?? "", edit.title ?? "", edit.content ?? ""].join("|"));
-    }
-    const material = parts.join("\n").replace(/\s+/g, " ").trim();
-    return createHash("sha256").update(material, "utf8").digest("hex").slice(0, 16);
-}
-/**
- * Load the decline ledger. Missing or malformed files read as empty so a
- * broken ledger degrades to the status quo (ask anyway), never to a crash
- * on the approval path.
- *
- * @param baseDir - engine base directory.
- * @returns validated ledger entries (possibly empty).
- */
-export function loadDeclinedMemory(baseDir) {
-    const path = declinedMemoryPath(baseDir);
-    if (!existsSync(path))
-        return [];
-    try {
-        const raw = JSON.parse(readFileSync(path, "utf8"));
-        if (!Array.isArray(raw))
-            return [];
-        return raw
-            .filter((entry) => {
-            if (typeof entry !== "object" || entry === null)
-                return false;
-            const candidate = entry;
-            return ((candidate.scope === "project" || candidate.scope === "global") &&
-                typeof candidate.fingerprint === "string");
-        })
-            .map((entry) => ({
-            ...entry,
-            tokens: Array.isArray(entry.tokens) ? entry.tokens.filter((token) => typeof token === "string") : [],
-        }));
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Whether this exact batch was declined before.
- *
- * @param entries - loaded ledger.
- * @param scope - persistent scope of the pending batch.
- * @param fingerprint - fingerprint of the pending batch.
- */
-export function isDeclinedRepeat(entries, scope, fingerprint) {
-    return entries.some((entry) => entry.scope === scope && entry.fingerprint === fingerprint);
-}
-/**
- * Record one human decline, pruning oldest-first past the cap. The batch
- * edits supply fingerprint material, match tokens, and the secret screen:
- * a secret-shaped decline is still declined, but never lands in the ledger
- * (it was never engine-screened, so it must not be persisted anywhere).
- *
- * @param baseDir - engine base directory.
- * @param scope - persistent scope that was declined.
- * @param edits - the declined scope batch in proposal order.
- * @param title - first edit title, kept for audit readability.
- * @returns the ledger file path, or undefined when skipped by the secret screen.
- * @throws On filesystem write failure; callers on the approval path should
- * contain it (suppression is an optimization, never load-bearing).
- */
-export function recordDeclinedMemory(baseDir, scope, edits, title) {
-    const screenable = edits.map((edit) => `${edit.title ?? ""}\n${edit.content ?? ""}`).join("\n");
-    if (secretLeakReason(screenable) !== undefined)
-        return undefined;
-    const entries = loadDeclinedMemory(baseDir);
-    entries.push({
-        scope,
-        fingerprint: fingerprintMemoryBatch(scope, edits),
-        title,
-        tokens: declinedContentTokens(edits),
-        declinedAt: new Date().toISOString(),
-    });
-    entries.sort((left, right) => (left.declinedAt < right.declinedAt ? -1 : 1));
-    while (entries.length > MAX_DECLINED_MEMORY_LEDGER)
-        entries.shift();
-    const path = declinedMemoryPath(baseDir);
-    mkdirSync(join(baseDir, EVOLVE_DIR), { recursive: true });
-    writeFileSync(path, `${JSON.stringify(entries, null, 2)}\n`, "utf8");
-    return path;
-}
-/**
- * Deduplicated content tokens of one batch, capped. Shared CJK-aware
- * tokenizer with the manifest ranking, so both sides of the containment
- * check speak the same token language.
- *
- * @param edits - batch edits.
- * @returns at most MAX_DECLINED_ENTRY_TOKENS distinct tokens.
- */
-export function declinedContentTokens(edits) {
-    const seen = new Set();
-    for (const edit of edits) {
-        for (const token of tokenize(`${edit.title ?? ""} ${edit.content ?? ""}`)) {
-            seen.add(token);
-            if (seen.size >= MAX_DECLINED_ENTRY_TOKENS)
-                return [...seen];
-        }
-    }
-    return [...seen];
-}
-/**
- * Match a pending checkpoint against declined content (entry ⊆ checkpoint).
- * Conservative by design: high coverage plus an absolute token floor, so
- * tiny or vague declines can never suppress anything.
- *
- * @param entries - loaded ledger.
- * @param checkpointTokens - tokens of the pending checkpoint trajectory.
- * @returns the strongest hit, or undefined when nothing clears the floor.
- */
-export function matchDeclinedCheckpoint(entries, checkpointTokens) {
-    const pending = new Set(checkpointTokens);
-    let best;
-    for (const entry of entries) {
-        if (entry.tokens.length === 0)
-            continue;
-        let hits = 0;
-        for (const token of entry.tokens) {
-            if (pending.has(token))
-                hits += 1;
-        }
-        if (hits < DECLINED_PRECHECK_MIN_TOKENS)
-            continue;
-        const coverage = hits / entry.tokens.length;
-        if (coverage < DECLINED_PRECHECK_COVERAGE)
-            continue;
-        if (best === undefined || coverage > best.coverage)
-            best = { entry, coverage, hits };
-    }
-    return best;
-}
-//# sourceMappingURL=declines.js.map

package/lib/evaluate.d.ts

@@ -1,74 +0,0 @@
-/**
- * The evaluation matrix runner: executes every case × run as a TWO-STAGE
- * structured-output subagent pair, with the provider/model frozen to the
- * calling agent's own route.
- *
- * Stage 1 — executor: a fresh child performs the case task with its tools
- * and records CONCRETE EVIDENCE of what it did and found. It NEVER sees the
- * rubric (gap A1, evaluator/scorer separation): the agent under test cannot
- * optimize its behavior toward the grading criteria, and cannot grade its
- * own execution.
- *
- * Stage 2 — reviewer: an INDEPENDENT child grades the executor's evidence
- * strictly against the rubric. The rubric plaintext is decrypted in the host
- * and flows ONLY into this reviewer branch; the executor branch never
- * touches it. A separate model instance grading someone else's evidence
- * removes the self-serving bias of self-scoring.
- *
- * Failure-cell protocol (gap A2): a unit that cannot produce a score
- * (decrypt error, executor crash, reviewer crash, protocol error) returns a
- * cell with `status: "failed"` — NEVER a zero — so aggregation can exclude
- * it and the acceptance rule can reject rounds with too many failures instead
- * of silently averaging a 0 into the mean.
- *
- * Each cell carries the executor child's session id (gap A4): the score can
- * be drilled back to the exact session transcript that produced the evidence.
- *
- * Uses the host-plane `subagents` service (available in every profile) with
- * the native `outputSchema` structured-output seam: the provider validates
- * each child's reply against its cell schema, so the host never parses model
- * text for evaluations. (The workflow engine was rejected because the web
- * profile keeps it in a per-agent isolated realm a host plugin cannot
- * resolve.)
- */
-import type { Context } from "@deepseek-ai/cordis";
-import type { Agent } from "@deepseek-ai/dsh-agent";
-import type { BenchmarkCase, CellScore } from "./benchmark.js";
-export interface EvaluateOptions {
-    cases: readonly BenchmarkCase[];
-    runs: number;
-    passThreshold: number;
-    /** Serialized harness state under test (the candidate's guidance). */
-    harnessOverview: string;
-    label: string;
-    /** AES-256 key for the encrypted rubric envelopes (see src/rubric.ts). */
-    rubricKey?: Buffer;
-    signal?: AbortSignal;
-}
-export interface EvaluationOutcome {
-    label: string;
-    cells: CellScore[];
-    stopReason: string;
-}
-/** How many evaluation units may run concurrently (bounded subagent fan-out). */
-export declare const DEFAULT_EVALUATION_CONCURRENCY = 4;
-/** Evidence handed to the reviewer is capped so the grading call stays bounded. */
-export declare const MAX_EVIDENCE_CHARS = 8000;
-export declare function evaluateState(ctx: Context, agent: Agent, options: EvaluateOptions): Promise<EvaluationOutcome>;
-export interface ExecutorResult {
-    caseId: string;
-    run: number;
-    evidence: string;
-}
-/**
- * Deterministic hash of a case's statement + rubric envelope (gap A3):
- * a 16-char SHA-256 prefix, hex-encoded. Used to detect material changes
- * between reference and candidate evaluation runs (see
- * `score.flagMaterialDrift`).
- */
-export declare function caseHash(caseItem: BenchmarkCase): string;
-/** Validate a provider-validated executor result; returns undefined when malformed. */
-export declare function normalizeExecutor(value: unknown, caseId: string, run: number): ExecutorResult | undefined;
-/** Validate a provider-validated structured cell; returns undefined when malformed. */
-export declare function normalizeCell(value: unknown, caseId: string, run: number, passThreshold: number): CellScore | undefined;
-//# sourceMappingURL=evaluate.d.ts.map

package/lib/evaluate.js

@@ -1,271 +0,0 @@
-import { createHash } from "node:crypto";
-import { mapPool } from "./pool.js";
-import { decryptRubric, deriveKey, DEV_RUBRIC_KEY } from "./rubric.js";
-/** Key used when the caller did not resolve one: mirrors resolveRubricKey's last-resort dev fallback. */
-function devRubricKey() {
-    return deriveKey(DEV_RUBRIC_KEY);
-}
-/** Stage 1: the agent under test — sees the task, never the rubric. */
-const EXECUTOR_SYSTEM_PROMPT = `You are one evaluation unit in a benchmark matrix.
-
-You are the agent under evaluation. Perform the case task using your tools.
-You are NOT asked to grade yourself: a separate evaluator will judge your
-work against criteria you do not see. Instead, record CONCRETE, VERIFIABLE
-EVIDENCE of what you did and found — the actual commands/reads you performed,
-what the harness state contains, the exact text you produced. Evidence is
-what your work will be scored from; vague self-assessment earns nothing.
-
-The harness guidance attached to the state under test is included in the task.
-Your reply is structured (see the requested output schema): caseId, run, and
-evidence (the concrete artifact/report of your execution).`;
-/** Stage 2: the independent grader — sees the rubric, never executes the task. */
-const REVIEWER_SYSTEM_PROMPT = `You are an independent evaluator in a benchmark matrix.
-
-You did NOT perform the task and you cannot interact with the runtime: grade
-strictly from the EVIDENCE produced by the agent under evaluation, against
-the rubric. The harness guidance under test is included for context so you
-can judge whether the evidence genuinely reflects the state under test
-(e.g. whether the agent actually inspected the harness store).
-
-Score YOUR JUDGMENT of the evidence against the rubric criteria: a
-0-100 score, and passed (true iff score >= the stated threshold). Cite in
-notes the concrete rubric criteria and the evidence that supports the score.
-Do not inflate: grade the evidence as presented, not what the agent might
-have meant.`;
-const EXECUTOR_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        caseId: { type: "string" },
-        run: { type: "number" },
-        evidence: { type: "string" },
-    },
-    required: ["caseId", "run", "evidence"],
-};
-const CELL_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        caseId: { type: "string" },
-        run: { type: "number" },
-        score: { type: "number" },
-        passed: { type: "boolean" },
-        notes: { type: "string" },
-    },
-    required: ["caseId", "run", "score", "passed", "notes"],
-};
-/** How many evaluation units may run concurrently (bounded subagent fan-out). */
-export const DEFAULT_EVALUATION_CONCURRENCY = 4;
-/** Evidence handed to the reviewer is capped so the grading call stays bounded. */
-export const MAX_EVIDENCE_CHARS = 8000;
-export async function evaluateState(ctx, agent, options) {
-    if (!agent.options.provider || !agent.options.model) {
-        throw new Error("evolve: benchmark evaluation requires a provider/model route");
-    }
-    const subagents = ctx.subagents;
-    if (!subagents) {
-        throw new Error("evolve: benchmark evaluation requires the subagents service");
-    }
-    const units = [];
-    for (const c of options.cases) {
-        for (let run = 1; run <= options.runs; run += 1) {
-            units.push({ case: c, run });
-        }
-    }
-    const cells = await mapPool(units, DEFAULT_EVALUATION_CONCURRENCY, (unit) => runUnit(subagents, agent, options, unit.case, unit.run));
-    return { label: options.label, cells, stopReason: "completed" };
-}
-/** A cell that could not be produced: never a zero, excluded by aggregation. */
-function failedCell(caseId, run, message) {
-    return { caseId, run, status: "failed", score: 0, passed: false, notes: message };
-}
-/**
- * Deterministic hash of a case's statement + rubric envelope (gap A3):
- * a 16-char SHA-256 prefix, hex-encoded. Used to detect material changes
- * between reference and candidate evaluation runs (see
- * `score.flagMaterialDrift`).
- */
-export function caseHash(caseItem) {
-    const material = `${caseItem.statement}\n${caseItem.rubric}`;
-    return createHash("sha256").update(material).digest("hex").slice(0, 16);
-}
-async function runUnit(subagents, agent, options, c, run) {
-    // Gap C3: track wall-clock duration of the entire cell evaluation.
-    const cellStart = Date.now();
-    // The ONLY rubric decryption point: the envelope is opened here, in the
-    // host, and the plaintext goes ONLY into the reviewer prompt — the
-    // executor branch never touches it (gap A1).
-    let rubric;
-    try {
-        rubric = decryptRubric(c.rubric, options.rubricKey ?? devRubricKey());
-    }
-    catch (cause) {
-        return { ...failedCell(c.id, run, `rubric decrypt failed: ${cause instanceof Error ? cause.message : String(cause)}`), durationMs: Date.now() - cellStart };
-    }
-    // Runtime evidence (gap A3): record actual provider/model from the host,
-    // and compute a material hash of the case for change detection.
-    const actualProvider = agent.options.provider ?? "unknown";
-    const actualModel = agent.options.model ?? "unknown";
-    const hash = caseHash(c);
-    // Stage 1: executor — task + evidence, NO rubric.
-    let evidence;
-    let sessionId;
-    try {
-        const executorRun = await subagents.start("spawn", {
-            label: `${c.id} r${run} execute`,
-            prompt: [
-                {
-                    type: "text",
-                    text: [
-                        EXECUTOR_SYSTEM_PROMPT,
-                        "---",
-                        "Your harness guidance (state under test):",
-                        `<harness_overview>\n${options.harnessOverview}\n</harness_overview>`,
-                        `Case ${c.id} — task (statement):\n${c.statement}`,
-                        `Run ${run} of ${options.runs}.`,
-                        "Execute the task with your tools, then produce the structured evidence.",
-                    ].join("\n\n"),
-                },
-            ],
-            parent: agent,
-            signal: options.signal ?? new AbortController().signal,
-            outputSchema: EXECUTOR_SCHEMA,
-        });
-        try {
-            const settled = await executorRun.result;
-            if (settled.stopReason !== "completed") {
-                throw new Error(`executor stopped: ${settled.stopReason ?? "unknown"}`);
-            }
-            const parsed = normalizeExecutor(settled.structured, c.id, run) ?? fromEvidenceText(settled.output, c.id, run);
-            if (!parsed) {
-                throw new Error("executor returned neither a structured value nor usable text");
-            }
-            evidence = parsed;
-            sessionId = executorRun.id || undefined;
-        }
-        finally {
-            executorRun.dispose();
-        }
-    }
-    catch (cause) {
-        return { ...failedCell(c.id, run, `executor failed: ${cause instanceof Error ? cause.message : String(cause)}`), provider: actualProvider, model: actualModel, caseHash: hash, durationMs: Date.now() - cellStart };
-    }
-    // Stage 2: independent reviewer — rubric + evidence, NO task execution.
-    try {
-        const reviewerRun = await subagents.start("spawn", {
-            label: `${c.id} r${run} grade`,
-            prompt: [
-                {
-                    type: "text",
-                    text: [
-                        REVIEWER_SYSTEM_PROMPT,
-                        "---",
-                        "Your harness guidance (state under test):",
-                        `<harness_overview>\n${options.harnessOverview}\n</harness_overview>`,
-                        `Case ${c.id} — task (statement):\n${c.statement}`,
-                        `Rubric — grade the evidence strictly against these criteria:\n${rubric}`,
-                        `Evidence produced by the agent under evaluation:\n<evidence>\n${trimEvidence(evidence.evidence)}\n</evidence>`,
-                        `Run ${run} of ${options.runs}. passThreshold = ${options.passThreshold}.`,
-                        "Produce the structured score.",
-                    ].join("\n\n"),
-                },
-            ],
-            parent: agent,
-            signal: options.signal ?? new AbortController().signal,
-            outputSchema: CELL_SCHEMA,
-        });
-        try {
-            const settled = await reviewerRun.result;
-            if (settled.stopReason !== "completed") {
-                throw new Error(`reviewer stopped: ${settled.stopReason ?? "unknown"}`);
-            }
-            const cell = normalizeCell(settled.structured, c.id, run, options.passThreshold) ??
-                fromOutputText(settled.output, c.id, run, options.passThreshold);
-            if (!cell) {
-                throw new Error("reviewer returned neither a structured value nor usable text");
-            }
-            return { ...cell, ...(sessionId !== undefined ? { sessionId } : {}), provider: actualProvider, model: actualModel, caseHash: hash, durationMs: Date.now() - cellStart };
-        }
-        finally {
-            reviewerRun.dispose();
-        }
-    }
-    catch (cause) {
-        return { ...failedCell(c.id, run, `reviewer failed: ${cause instanceof Error ? cause.message : String(cause)}`), provider: actualProvider, model: actualModel, caseHash: hash, durationMs: Date.now() - cellStart };
-    }
-}
-/** Cap the evidence handed to the reviewer so the grading call stays bounded. */
-function trimEvidence(text) {
-    if (text.length <= MAX_EVIDENCE_CHARS)
-        return text;
-    return `${text.slice(0, MAX_EVIDENCE_CHARS)}\n…[evidence truncated at ${MAX_EVIDENCE_CHARS} chars]`;
-}
-/** Validate a provider-validated executor result; returns undefined when malformed. */
-export function normalizeExecutor(value, caseId, run) {
-    if (typeof value !== "object" || value === null || Array.isArray(value))
-        return undefined;
-    const record = value;
-    const evidence = typeof record["evidence"] === "string" ? record["evidence"] : "";
-    if (evidence.trim().length === 0)
-        return undefined;
-    return {
-        caseId: typeof record["caseId"] === "string" && record["caseId"].length > 0 ? record["caseId"] : caseId,
-        run: typeof record["run"] === "number" && Number.isFinite(record["run"]) ? Math.trunc(record["run"]) : run,
-        evidence,
-    };
-}
-/** Fallback: recover the executor result from its text blocks when no structured value arrived. */
-function fromEvidenceText(blocks, caseId, run) {
-    if (!Array.isArray(blocks))
-        return undefined;
-    const text = blocks
-        .filter((block) => block.type === "text")
-        .map((block) => block.text ?? "")
-        .join("\n");
-    const trimmed = text.trim();
-    if (trimmed.length === 0)
-        return undefined;
-    try {
-        return normalizeExecutor(JSON.parse(trimmed), caseId, run);
-    }
-    catch {
-        // Not JSON — keep the raw text as the evidence.
-        return { caseId, run, evidence: trimmed };
-    }
-}
-/** Validate a provider-validated structured cell; returns undefined when malformed. */
-export function normalizeCell(value, caseId, run, passThreshold) {
-    if (typeof value !== "object" || value === null || Array.isArray(value))
-        return undefined;
-    const record = value;
-    const score = Number(record["score"]);
-    if (!Number.isFinite(score))
-        return undefined;
-    return {
-        caseId: typeof record["caseId"] === "string" && record["caseId"].length > 0 ? record["caseId"] : caseId,
-        run: typeof record["run"] === "number" && Number.isFinite(record["run"]) ? Math.trunc(record["run"]) : run,
-        status: "ok",
-        score: Math.min(100, Math.max(0, score)),
-        passed: record["passed"] === true || score >= passThreshold,
-        notes: typeof record["notes"] === "string" ? record["notes"] : "",
-    };
-}
-/** Fallback: recover a cell from the child's text blocks when no structured value arrived. */
-function fromOutputText(blocks, caseId, run, passThreshold) {
-    if (!Array.isArray(blocks))
-        return undefined;
-    const text = blocks
-        .filter((block) => block.type === "text")
-        .map((block) => block.text ?? "")
-        .join("\n");
-    if (text.length === 0)
-        return undefined;
-    try {
-        const value = JSON.parse(text);
-        return normalizeCell(value, caseId, run, passThreshold);
-    }
-    catch {
-        return undefined;
-    }
-}
-//# sourceMappingURL=evaluate.js.map

package/lib/evolve-event.d.ts

@@ -1,40 +0,0 @@
-import type { RefinementResult } from "./types.js";
-/** The structured event payload emitted after every successful refinement. */
-export interface EvolveCompleteEvent {
-    /** Event discriminator for consumers. */
-    type: "evolve_complete";
-    /** The refinement id (same as the result). */
-    refinementId: string;
-    /** One-line summary of the refinement. */
-    summary: string;
-    /** Number of edits that were actually applied. */
-    appliedEdits: number;
-    /** Number of edits that failed to apply. */
-    failedEdits: number;
-    /** Scope of the refinement ("local" or "global"). */
-    scope: string;
-    /** What triggered this refinement (e.g. "auto_review", "manual_plan", "manual_tool"). */
-    trigger: string;
-    /** Session id that owns the refinement (auto or manual). */
-    sessionId: string;
-    /** ISO timestamp. */
-    timestamp: string;
-    /** Per-edit summaries (kind + id + action) for consumers that want detail. */
-    edits: {
-        action: string;
-        kind: string;
-        id: string;
-        applied: boolean;
-    }[];
-}
-/** Build a structured evolve-complete event from a refinement result. */
-export declare function buildEvolveCompleteEvent(result: RefinementResult, trigger: string, sessionId: string): EvolveCompleteEvent;
-/**
- * Emit an evolve_complete event to the reviews.jsonl audit trail. The event
- * is JSONL-formatted (one line) so consumers can tail and parse it. This is
- * a best-effort write — failure never blocks the refinement path. Storage
- * hygiene (#20): the trail is truncated to its tail after the append so the
- * audit file cannot grow without bound; readers only need a recent window.
- */
-export declare function emitEvolveComplete(baseDir: string, event: EvolveCompleteEvent, reviewsRetain?: number): void;
-//# sourceMappingURL=evolve-event.d.ts.map

package/lib/evolve-event.js

@@ -1,59 +0,0 @@
-/**
- * Structured "evolve complete" events (gap C4): a durable, machine-readable
- * record emitted after every successful refinement application — whether
- * auto-gated or manual. Third-party consumers can observe these events via
- * the plugin log (JSONL) and the reviews.jsonl audit trail.
- *
- * Design: prime-agent `/refine` emits `refine_complete{id,summary,
- * appliedEdits,scope}` extension events. We follow the same pattern with
- * added provenance (trigger, source) so consumers know WHY the refinement
- * happened and WHO initiated it.
- */
-import { appendFileSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-import { DEFAULT_REVIEWS_RETAIN, pruneJsonlFile, reviewsPath } from "./store.js";
-/** Build a structured evolve-complete event from a refinement result. */
-export function buildEvolveCompleteEvent(result, trigger, sessionId) {
-    return {
-        type: "evolve_complete",
-        refinementId: result.id,
-        summary: result.summary,
-        appliedEdits: result.appliedEdits.filter((e) => e.applied).length,
-        failedEdits: result.appliedEdits.filter((e) => !e.applied).length,
-        scope: result.scope ?? "local",
-        trigger,
-        sessionId,
-        timestamp: new Date().toISOString(),
-        edits: result.appliedEdits.map((e) => ({
-            action: e.action,
-            kind: e.kind,
-            id: e.id,
-            applied: e.applied,
-        })),
-    };
-}
-/**
- * Emit an evolve_complete event to the reviews.jsonl audit trail. The event
- * is JSONL-formatted (one line) so consumers can tail and parse it. This is
- * a best-effort write — failure never blocks the refinement path. Storage
- * hygiene (#20): the trail is truncated to its tail after the append so the
- * audit file cannot grow without bound; readers only need a recent window.
- */
-export function emitEvolveComplete(baseDir, event, reviewsRetain = DEFAULT_REVIEWS_RETAIN) {
-    try {
-        const dir = join(baseDir, "evolve");
-        mkdirSync(dir, { recursive: true });
-        appendFileSync(join(dir, "reviews.jsonl"), `${JSON.stringify(event)}\n`, "utf8");
-    }
-    catch {
-        // Event emission is diagnostic; never interrupt the refinement path.
-        return;
-    }
-    try {
-        pruneJsonlFile(reviewsPath(baseDir), reviewsRetain);
-    }
-    catch {
-        // ignored — the next emission retries
-    }
-}
-//# sourceMappingURL=evolve-event.js.map

package/lib/failures.d.ts

@@ -1,42 +0,0 @@
-export interface FailureRecord {
-    /** When the failure was recorded (ISO). Unknown for aggregated benchmark cells without timestamps. */
-    timestamp?: string;
-    /** Where the failure came from: "review-gate" | "benchmark:<bid>:<caseId>". */
-    source: string;
-    /** Failure class (see classifyFailure). */
-    kind: string;
-    /** The original failure text (notes or rationale). */
-    message: string;
-}
-export interface FailureSummary {
-    total: number;
-    /** Count per failure class, sorted descending (most frequent first). */
-    byKind: Record<string, number>;
-    /** Count per source (gate vs benchmark:bid). */
-    bySource: Record<string, number>;
-}
-/**
- * Classify a failure message by prefix rules. Deterministic and additive:
- * unknown text falls into "other" so the summary never drops a failure.
- */
-export declare function classifyFailure(message: string): string;
-/** Aggregate a record list into counts. Empty input yields an all-zero summary. */
-export declare function summarizeFailures(records: readonly FailureRecord[]): FailureSummary;
-/**
- * Read failed review-gate records from `<baseDir>/evolve/reviews.jsonl`
- * (outcome === "failed"). Tolerant of a missing/corrupt file.
- */
-export declare function readReviewFailures(baseDir: string): FailureRecord[];
-/**
- * Read failed cells from every benchmark scoreboard under
- * `<baseDir>/evolve/benchmarks/<bid>/`. Tolerant of missing/corrupt data.
- */
-export declare function readBenchmarkFailures(baseDir: string): FailureRecord[];
-/** Combine both sources into one summary. */
-export declare function collectFailureSummary(baseDir: string): {
-    summary: FailureSummary;
-    records: FailureRecord[];
-};
-/** Human-readable report for the command line. */
-export declare function formatFailureSummary(summary: FailureSummary): string;
-//# sourceMappingURL=failures.d.ts.map