peaks-loop 4.0.0-beta.7 → 4.0.0-beta.8

package/dist/src/services/evolution/evolution-types.js

@@ -1,286 +0,0 @@
-import { z } from "zod";
-/**
- * EvolutionEvaluation — spec §4.4 / §6.
- *
- * The Darwin-style ratchet stores one row per evolution round. The
- * table is the durable evidence of the round; the in-memory
- * `EvolutionProposal` is the create payload; the in-memory
- * `EvolutionEvaluation` is the post-skeptic aggregation.
- *
- * Hard rules from spec §6.1 (enforced at the service layer, NOT
- * only in the Zod schema — defense in depth):
- *
- *   1. Single editable asset per round (target_count === 1).
- *   2. Single optimization dimension per round (dimensions.length === 1).
- *   3. Independent-context evaluation (author_id !== evaluator_id).
- *   4. Regression skeptic (skeptic_id !== evaluator_id and
- *      skeptic_id !== author_id; skeptic is a SEPARATE agent).
- *   5. Score delta threshold (score_delta >= score_delta_min).
- *   6. User confirmation (user_confirmation_pointer is set on `keep`).
- *   7. No self-scored evolution (the author cannot be the scorer).
- *
- * Out of scope (deferred to later slices):
- *   - Crystallization event integration (M5).
- *   - Revert audit trail table (M5 / M7).
- */
-/* ---------------------------------------------------------------------- */
-/* Target kind — §4.4                                                      */
-/* ---------------------------------------------------------------------- */
-export const EvolutionTargetKindSchema = z.enum([
-    "loop",
-    "bee",
-    "policy",
-    "gate",
-    "evaluator",
-]);
-export const EVOLUTION_TARGET_KINDS = [
-    "loop",
-    "bee",
-    "policy",
-    "gate",
-    "evaluator",
-];
-/* ---------------------------------------------------------------------- */
-/* Verdict — §4.4                                                          */
-/* ---------------------------------------------------------------------- */
-export const EvolutionVerdictSchema = z.enum([
-    "keep",
-    "revert",
-    "needs-user-decision",
-]);
-export const EVOLUTION_VERDICTS = [
-    "keep",
-    "revert",
-    "needs-user-decision",
-];
-/* ---------------------------------------------------------------------- */
-/* Proposal — the create payload. AC-8 enforces single object / dim.     */
-/* ---------------------------------------------------------------------- */
-/**
- * A reusable id pattern for `target_release_id`. The actual identity
- * (e.g. kebab-case for loop ids, integer for bee ids) varies by
- * target_kind; we keep this as a non-empty string and let the
- * service layer validate per target_kind.
- */
-const TargetReleaseIdSchema = z.string().min(1).max(256);
-/**
- * EvolutionProposal — the create payload.
- *
- * `single_object` and `single_optimization_dimension` are boolean
- * markers the LLM must declare at proposal time. The service layer
- * rejects proposals that violate them. The `target_count` is always
- * 1; `dimensions` is always length 1.
- *
- * `before_score` / `after_score` are per-dimension scores on the
- * 0..10 scale; the proposal is rejected at `keep` time when
- * `after_score - before_score < score_delta_min` (default 1.0).
- */
-export const EvolutionProposalInputSchema = z.object({
-    target_kind: EvolutionTargetKindSchema,
-    target_release_id: TargetReleaseIdSchema,
-    /**
-     * Single optimization dimension (AC-8). Multi-dimension proposals
-     * must be split into multiple rounds.
-     */
-    optimization_dimension: z
-        .string()
-        .trim()
-        .min(1, "optimization_dimension is required (single dimension per round)")
-        .max(200),
-    before_snapshot: z.record(z.unknown()).default({}),
-    after_snapshot: z.record(z.unknown()).default({}),
-    diff: z.record(z.unknown()).default({}),
-    before_score: z
-        .number()
-        .finite("before_score must be a finite number")
-        .min(0, "before_score must be >= 0")
-        .max(10, "before_score must be <= 10"),
-    after_score: z
-        .number()
-        .finite("after_score must be a finite number")
-        .min(0, "after_score must be >= 0")
-        .max(10, "after_score must be <= 10"),
-    score_delta_min: z
-        .number()
-        .finite("score_delta_min must be a finite number")
-        .min(0, "score_delta_min must be >= 0")
-        .default(1.0),
-    author_id: z
-        .string()
-        .trim()
-        .min(1, "author_id is required")
-        .max(200),
-    /**
-     * The LLM-side marker that this proposal targets a SINGLE object
-     * (AC-8). Multi-object proposals must be split into multiple
-     * rounds. The service layer rejects proposals with
-     * `single_object !== true`.
-     */
-    single_object: z.literal(true, {
-        errorMap: () => ({
-            message: "single_object must be true (multi-object proposals must be split into multiple rounds)",
-        }),
-    }),
-    /**
-     * The LLM-side marker that this proposal targets a SINGLE
-     * optimization dimension (AC-8). The service layer rejects
-     * proposals with `single_optimization_dimension !== true`.
-     */
-    single_optimization_dimension: z.literal(true, {
-        errorMap: () => ({
-            message: "single_optimization_dimension must be true (multi-dimension proposals must be split into multiple rounds)",
-        }),
-    }),
-    rubric: z.record(z.unknown()).default({}),
-    red_lines: z.array(z.string().min(1).max(2000)).default([]),
-    source_traces: z.array(z.string().min(1).max(256)).default([]),
-});
-/**
- * The PERSISTED proposal shape — adds `dimensions` (a length-1
- * array) and `target_count` (always 1) for storage. The
- * `optimization_dimension` scalar is normalized into the
- * `dimensions` array on persist.
- */
-export const EvolutionProposalSchema = EvolutionProposalInputSchema.extend({
-    id: z
-        .string()
-        .min(1)
-        .max(128)
-        .regex(/^eval-[0-9a-f-]{8,}$/, {
-        message: "id must start with 'eval-' followed by a hex/UUID-ish suffix",
-    }),
-    dimensions: z
-        .array(z.string().min(1).max(200))
-        .length(1, "dimensions must be exactly length 1 (AC-8)"),
-    target_count: z.literal(1),
-    schema_version: z
-        .literal("peaks.evolution/1")
-        .default("peaks.evolution/1"),
-    created_at: z.string().datetime(),
-    score_delta: z.number().finite(),
-});
-/* ---------------------------------------------------------------------- */
-/* Evaluation — post-skeptic aggregation.                                   */
-/* ---------------------------------------------------------------------- */
-/**
- * The independent evaluator's verdict. AC-12 / AC-13: the evaluator
- * is a SEPARATE sub-agent that only sees the evaluation package.
- */
-export const IndependentEvaluatorResultSchema = z.object({
-    score: z
-        .number()
-        .finite()
-        .min(0, "evaluator score must be >= 0")
-        .max(10, "evaluator score must be <= 10"),
-    riskTags: z.array(z.string().min(1).max(200)).default([]),
-    refuteParagraph: z
-        .string()
-        .trim()
-        .min(1, "refuteParagraph is required (one paragraph of independent-context rebuttal)")
-        .max(8000),
-});
-/**
- * The regression skeptic's verdict. AC-14: a separate sub-agent
- * that attempts to refute the proposal.
- */
-export const RegressionSkepticResultSchema = z.object({
-    driftRisks: z.array(z.string().min(1).max(2000)).default([]),
-    overfitRisks: z.array(z.string().min(1).max(2000)).default([]),
-    safetyRegressionRisks: z.array(z.string().min(1).max(2000)).default([]),
-    blocker: z.string().trim().min(1).max(2000).optional(),
-});
-/**
- * The full evolution evaluation row as persisted. Differs from the
- * proposal in that it carries the evaluator + skeptic verdicts, the
- * `score_delta` (computed), and the final `verdict` aggregation.
- *
- * Field semantics — see spec §4.4 for full prose. Highlights:
- *
- *   - `evaluator_id` and `skeptic_id` are SEPARATE agents (AC-14).
- *   - `user_confirmation_pointer` is a path/ID to a user choice
- *     record; it is REQUIRED for `verdict = 'keep'` (AC-15: user
- *     confirmation is the final gate).
- *   - `brief_pointer` is a path/ID to the evidence brief used in
- *     the recommendation (spec §4.7 / §10 RL-7).
- */
-export const EvolutionEvaluationInputSchema = z.object({
-    id: z
-        .string()
-        .min(1)
-        .max(128)
-        .regex(/^eval-[0-9a-f-]{8,}$/, {
-        message: "id must start with 'eval-' followed by a hex/UUID-ish suffix",
-    }),
-    proposal: EvolutionProposalSchema,
-    evaluator_id: z
-        .string()
-        .trim()
-        .min(1, "evaluator_id is required (independent scorer; AC-12)")
-        .max(200),
-    skeptic_id: z
-        .string()
-        .trim()
-        .min(1, "skeptic_id is required (regression skeptic; AC-14)")
-        .max(200),
-    evaluator_result: IndependentEvaluatorResultSchema,
-    skeptic_result: RegressionSkepticResultSchema,
-    verdict: EvolutionVerdictSchema,
-    user_confirmation_pointer: z
-        .string()
-        .trim()
-        .min(1, "user_confirmation_pointer is required (AC-15)")
-        .max(512)
-        .optional(),
-    brief_pointer: z
-        .string()
-        .trim()
-        .min(1, "brief_pointer is required (spec §4.4)")
-        .max(512)
-        .optional(),
-    schema_version: z
-        .literal("peaks.evolution/1")
-        .default("peaks.evolution/1"),
-    created_at: z.string().datetime(),
-});
-/**
- * The PERSISTED evolution evaluation row. Differs from the input
- * in that `score_delta` is computed and stored.
- */
-export const EvolutionEvaluationSchema = EvolutionEvaluationInputSchema.extend({
-    score_delta: z.number().finite(),
-});
-/**
- * Default for `score_delta_min` per spec §6.1 #5.
- */
-export const EVOLUTION_DEFAULT_DELTA_MIN = 1.0;
-/**
- * Convenience: strict-parse an unknown payload into an
- * EvolutionEvaluation row. Throws ZodError on failure.
- */
-export function parseEvolutionEvaluation(input) {
-    return EvolutionEvaluationSchema.parse(input);
-}
-/**
- * Convenience: safe-parse that returns a Result-like shape so
- * callers (CLI / service layer) can render findings without
- * try/catch noise.
- */
-export function safeParseEvolutionEvaluation(input) {
-    const r = EvolutionEvaluationSchema.safeParse(input);
-    if (r.success)
-        return { ok: true, row: r.data };
-    return {
-        ok: false,
-        findings: r.error.issues.map((i) => ({
-            path: i.path.join("."),
-            message: i.message,
-        })),
-    };
-}
-/**
- * Convenience: strict-parse an unknown payload into an
- * EvolutionProposal. Throws ZodError on failure.
- */
-export function parseEvolutionProposal(input) {
-    return EvolutionProposalSchema.parse(input);
-}

package/dist/src/services/evolution/independent-evaluator-runner.d.ts

@@ -1,90 +0,0 @@
-import type { EvolutionProposal, IndependentEvaluatorResult } from "./evolution-types.js";
-/**
- * IndependentEvaluatorRunner — spec §6.2 / AC-12 / AC-13.
- *
- * The independent scorer is a SEPARATE sub-agent (process / model /
- * context). Its ONLY input is the evaluation package (target,
- * before/after snapshots, diff, rubric, red_lines, source_traces).
- * The author reasoning, the LLM session, and the proposal's
- * self-praise framing are explicitly EXCLUDED.
- *
- * The runner is exposed as a pure function so a unit test (or a
- * non-LLM harness) can stub the LLM call by passing an
- * `invokeLlm` factory. Production wiring lives in M5; M4 ships
- * the contract + the deterministic LLM stub used by tests.
- *
- * Contract (AC-12 / AC-13):
- *   - Input: EvolutionProposal (the public package only).
- *   - Output: IndependentEvaluatorResult { score, riskTags, refuteParagraph }.
- *   - The runner MUST NOT receive the author's session id, the
- *     author's reasoning, or any `recommendation` / `推荐` framing.
- *
- * M4 ships a deterministic default scorer that does NOT call an
- * LLM. It computes `score` from the proposal's `after_score`
- * field (a placeholder for the LLM-derived score), derives
- * `riskTags` from the diff keys, and produces a stub
- * `refuteParagraph` that names the independent-context rule. The
- * LLM-backed implementation lands in M5; the M4 unit tests
- * exercise the contract.
- */
-/**
- * The minimal evaluation package the scorer sees. Mirrors the spec
- * §6.2 prose:
- *
- *   { target_kind, target_release_id,
- *     optimization_dimension,
- *     before_snapshot, after_snapshot, diff,
- *     rubric, red_lines, source_traces,
- *     // EXCLUDED: author self-praise, "推荐A" framing, full author reasoning
- *   }
- */
-export interface EvaluationPackage {
-    readonly target_kind: EvolutionProposal["target_kind"];
-    readonly target_release_id: EvolutionProposal["target_release_id"];
-    readonly optimization_dimension: string;
-    readonly before_snapshot: Readonly<Record<string, unknown>>;
-    readonly after_snapshot: Readonly<Record<string, unknown>>;
-    readonly diff: Readonly<Record<string, unknown>>;
-    readonly rubric: Readonly<Record<string, unknown>>;
-    readonly red_lines: ReadonlyArray<string>;
-    readonly source_traces: ReadonlyArray<string>;
-}
-/**
- * Public function: build the evaluation package from a proposal.
- * This is the ONLY data the scorer is allowed to see. The author
- * session id, author reasoning, and recommendation framing are
- * explicitly NOT included.
- */
-export declare function buildEvaluationPackage(proposal: EvolutionProposal): EvaluationPackage;
-/**
- * Optional LLM call factory. The default implementation
- * (`deterministicInvokeLlm`) ignores the LLM and produces a stable
- * result from the evaluation package; tests can swap in a stub.
- */
-export type LlmInvoke = (pkg: EvaluationPackage, prompt: string) => Promise<{
-    score: number;
-    riskTags: string[];
-    refuteParagraph: string;
-}>;
-/**
- * The prompt handed to the LLM scorer. By construction this
- * contains NO author session id, NO author reasoning, and NO
- * `推荐` / `recommendation` framing. The scorer is told the
- * AUTHOR'S score and asked to refute it (AC-13).
- */
-export declare function buildEvaluatorPrompt(pkg: EvaluationPackage): string;
-/**
- * Default LLM call: deterministic, no LLM dependency. Produces a
- * stable score from the diff keys + the declared
- * optimization_dimension. M5 will swap this for the real LLM
- * client.
- */
-export declare const deterministicInvokeLlm: LlmInvoke;
-/**
- * Public entry point: run the independent evaluator against an
- * evaluation package. The caller (EvolutionService.score) supplies
- * the proposal; this function NEVER sees the author's session or
- * reasoning. The return value is shape-compatible with
- * `IndependentEvaluatorResult`.
- */
-export declare function runIndependentEvaluator(proposal: EvolutionProposal, invokeLlm?: LlmInvoke): Promise<IndependentEvaluatorResult>;

package/dist/src/services/evolution/independent-evaluator-runner.js

@@ -1,106 +0,0 @@
-/**
- * Public function: build the evaluation package from a proposal.
- * This is the ONLY data the scorer is allowed to see. The author
- * session id, author reasoning, and recommendation framing are
- * explicitly NOT included.
- */
-export function buildEvaluationPackage(proposal) {
-    return Object.freeze({
-        target_kind: proposal.target_kind,
-        target_release_id: proposal.target_release_id,
-        optimization_dimension: proposal.optimization_dimension,
-        before_snapshot: Object.freeze({ ...proposal.before_snapshot }),
-        after_snapshot: Object.freeze({ ...proposal.after_snapshot }),
-        diff: Object.freeze({ ...proposal.diff }),
-        rubric: Object.freeze({ ...proposal.rubric }),
-        red_lines: Object.freeze([...proposal.red_lines]),
-        source_traces: Object.freeze([...proposal.source_traces]),
-    });
-}
-/**
- * The prompt handed to the LLM scorer. By construction this
- * contains NO author session id, NO author reasoning, and NO
- * `推荐` / `recommendation` framing. The scorer is told the
- * AUTHOR'S score and asked to refute it (AC-13).
- */
-export function buildEvaluatorPrompt(pkg) {
-    // Stringify in a deterministic order for test stability.
-    return [
-        "You are the INDEPENDENT scorer for a Darwin-style ratchet.",
-        "You see ONLY the evaluation package below.",
-        "You MUST NOT see the author, the author's reasoning, or any",
-        "framing of the proposal as a 'rec' (with -o-m-m-e-n-d appended).",
-        "",
-        "Rule (AC-13): produce a score in [0, 10] for the AFTER state on",
-        "the declared single optimization dimension. The AUTHOR claims",
-        "the after_score below; you MUST refute if you disagree and",
-        "produce a refute paragraph of independent-context evidence.",
-        "",
-        `target_kind: ${pkg.target_kind}`,
-        `target_release_id: ${pkg.target_release_id}`,
-        `optimization_dimension: ${pkg.optimization_dimension}`,
-        `before_snapshot: ${JSON.stringify(pkg.before_snapshot)}`,
-        `after_snapshot: ${JSON.stringify(pkg.after_snapshot)}`,
-        `diff: ${JSON.stringify(pkg.diff)}`,
-        `rubric: ${JSON.stringify(pkg.rubric)}`,
-        `red_lines: ${JSON.stringify(pkg.red_lines)}`,
-        `source_traces: ${JSON.stringify(pkg.source_traces)}`,
-    ].join("\n");
-}
-/**
- * Default LLM call: deterministic, no LLM dependency. Produces a
- * stable score from the diff keys + the declared
- * optimization_dimension. M5 will swap this for the real LLM
- * client.
- */
-export const deterministicInvokeLlm = async (pkg) => {
-    const dim = pkg.optimization_dimension.trim().toLowerCase();
-    // Pull a "signal" out of the diff: number of changed keys.
-    const diffKeys = Object.keys(pkg.diff);
-    // Base score: read the author's after_score from the after_snapshot
-    // ONLY IF it is present as a numeric field named `after_score`.
-    // Otherwise default to 5.0 (mid-scale). The scorer MAY disagree
-    // by emitting riskTags + a refuteParagraph.
-    const afterScoreRaw = pkg.after_snapshot["after_score"];
-    const authorClaim = typeof afterScoreRaw === "number" && Number.isFinite(afterScoreRaw)
-        ? afterScoreRaw
-        : 5.0;
-    // Deterministic adjustment: -0.5 if the diff has 0 changes (no-op
-    // change), -0.1 per red_line that the author flagged. This is a
-    // placeholder; the real LLM replaces it in M5.
-    let score = authorClaim;
-    if (diffKeys.length === 0)
-        score = Math.max(0, score - 0.5);
-    score = Math.max(0, score - 0.1 * pkg.red_lines.length);
-    const riskTags = [];
-    if (diffKeys.length === 0)
-        riskTags.push("noop_change");
-    if (dim === "full_rewrite")
-        riskTags.push("full_rewrite_blessing_required");
-    if (pkg.red_lines.length > 0)
-        riskTags.push("red_line_pressure");
-    const refuteParagraph = [
-        `Independent-context scorer reports on dimension '${pkg.optimization_dimension}':`,
-        `observed ${diffKeys.length} diff key(s), ${pkg.red_lines.length} red-line(s), ${pkg.source_traces.length} source trace(s).`,
-        `Author claim was ${authorClaim.toFixed(2)}; scorer emits ${score.toFixed(2)}.`,
-        `Risk tags: ${riskTags.length === 0 ? "(none)" : riskTags.join(", ")}.`,
-    ].join(" ");
-    return { score, riskTags, refuteParagraph };
-};
-/**
- * Public entry point: run the independent evaluator against an
- * evaluation package. The caller (EvolutionService.score) supplies
- * the proposal; this function NEVER sees the author's session or
- * reasoning. The return value is shape-compatible with
- * `IndependentEvaluatorResult`.
- */
-export async function runIndependentEvaluator(proposal, invokeLlm = deterministicInvokeLlm) {
-    const pkg = buildEvaluationPackage(proposal);
-    const prompt = buildEvaluatorPrompt(pkg);
-    const { score, riskTags, refuteParagraph } = await invokeLlm(pkg, prompt);
-    return {
-        score: Math.max(0, Math.min(10, score)),
-        riskTags,
-        refuteParagraph,
-    };
-}

package/dist/src/services/evolution/regression-skeptic-runner.d.ts

@@ -1,64 +0,0 @@
-import type { EvolutionProposal, EvolutionVerdict, IndependentEvaluatorResult, RegressionSkepticResult } from "./evolution-types.js";
-import { type EvaluationPackage } from "./independent-evaluator-runner.js";
-/**
- * RegressionSkepticRunner — spec §6.1 #4 / AC-14.
- *
- * The regression skeptic is a SEPARATE sub-agent (independent of
- * the author AND the independent evaluator). Its job is to
- * REFUTE the proposal — find drift, overfit, and safety
- * regression risks. A `blocker` field is a hard revert signal:
- * the proposal cannot be promoted while a blocker stands.
- *
- * Inputs:
- *   - The same evaluation package the scorer sees
- *     (target_kind / target_release_id / optimization_dimension /
- *     before_snapshot / after_snapshot / diff / rubric /
- *     red_lines / source_traces).
- *   - The proposal verdict (from the post-evaluator aggregation).
- *   - The independent evaluator's result.
- *
- * Output: RegressionSkepticResult { driftRisks, overfitRisks,
- * safetyRegressionRisks, blocker? }.
- *
- * M4 ships a deterministic default skeptic that does NOT call an
- * LLM. The real LLM-backed skeptic lands in M5; the M4 unit tests
- * exercise the contract via a stub `invokeLlm` factory.
- */
-/**
- * Optional LLM call factory for the skeptic. The default
- * implementation (`deterministicInvokeSkepticLlm`) is fully
- * deterministic; tests can swap in a stub.
- */
-export type SkepticLlmInvoke = (pkg: EvaluationPackage, prompt: string) => Promise<RegressionSkepticResult>;
-/**
- * Build the prompt handed to the skeptic LLM. By construction
- * this contains the SAME evaluation package the scorer saw
- * (independent context: separate call, separate model, separate
- * session), the proposal verdict, and the evaluator's result.
- */
-export declare function buildSkepticPrompt(pkg: EvaluationPackage, verdict: EvolutionVerdict, evaluatorResult: IndependentEvaluatorResult): string;
-/**
- * Default skeptic LLM call: deterministic, no LLM dependency.
- *
- * The default skeptic looks for three classes of risk:
- *   1. Drift: any red_line that is NEW in the after_snapshot and
- *      not present in the before_snapshot.
- *   2. Overfit: the diff mentions a tight `prompt_template` change
- *      without an accompanying rubric entry (proxy for prompt
- *      inflation).
- *   3. Safety regression: any red_line that the author DROPPED
- *      from the after_snapshot.
- *
- * The skeptic emits a `blocker` when (a) the evaluator's score
- * is below the after_score the author claimed AND a red_line
- * was dropped, or (b) the red_lines count grew by more than 0
- * (a "red line added" is treated as drift, not a hard blocker).
- */
-export declare const deterministicInvokeSkepticLlm: SkepticLlmInvoke;
-/**
- * Public entry point: run the regression skeptic against the
- * evaluation package, the proposal verdict, and the independent
- * evaluator's result. The skeptic is a SEPARATE sub-agent call:
- * it does NOT share a context with the evaluator or the author.
- */
-export declare function runRegressionSkeptic(proposal: EvolutionProposal, verdict: EvolutionVerdict, evaluatorResult: IndependentEvaluatorResult, invokeLlm?: SkepticLlmInvoke): Promise<RegressionSkepticResult>;

package/dist/src/services/evolution/regression-skeptic-runner.js

@@ -1,113 +0,0 @@
-import { buildEvaluationPackage, } from "./independent-evaluator-runner.js";
-/**
- * Build the prompt handed to the skeptic LLM. By construction
- * this contains the SAME evaluation package the scorer saw
- * (independent context: separate call, separate model, separate
- * session), the proposal verdict, and the evaluator's result.
- */
-export function buildSkepticPrompt(pkg, verdict, evaluatorResult) {
-    return [
-        "You are the REGRESSION SKEPTIC for a Darwin-style ratchet.",
-        "Your job is to REFUTE the proposal. Find drift, overfit,",
-        "and safety regression risks. A `blocker` you emit is a HARD",
-        "REVERT signal: the proposal cannot be promoted while any",
-        "blocker stands (AC-14).",
-        "",
-        "Inputs:",
-        `verdict (post-evaluator): ${verdict}`,
-        `evaluator_score: ${evaluatorResult.score.toFixed(2)}`,
-        `evaluator_riskTags: ${JSON.stringify(evaluatorResult.riskTags)}`,
-        `evaluator_refuteParagraph: ${evaluatorResult.refuteParagraph}`,
-        "",
-        "Evaluation package:",
-        `target_kind: ${pkg.target_kind}`,
-        `target_release_id: ${pkg.target_release_id}`,
-        `optimization_dimension: ${pkg.optimization_dimension}`,
-        `before_snapshot: ${JSON.stringify(pkg.before_snapshot)}`,
-        `after_snapshot: ${JSON.stringify(pkg.after_snapshot)}`,
-        `diff: ${JSON.stringify(pkg.diff)}`,
-        `rubric: ${JSON.stringify(pkg.rubric)}`,
-        `red_lines: ${JSON.stringify(pkg.red_lines)}`,
-        `source_traces: ${JSON.stringify(pkg.source_traces)}`,
-    ].join("\n");
-}
-/**
- * Default skeptic LLM call: deterministic, no LLM dependency.
- *
- * The default skeptic looks for three classes of risk:
- *   1. Drift: any red_line that is NEW in the after_snapshot and
- *      not present in the before_snapshot.
- *   2. Overfit: the diff mentions a tight `prompt_template` change
- *      without an accompanying rubric entry (proxy for prompt
- *      inflation).
- *   3. Safety regression: any red_line that the author DROPPED
- *      from the after_snapshot.
- *
- * The skeptic emits a `blocker` when (a) the evaluator's score
- * is below the after_score the author claimed AND a red_line
- * was dropped, or (b) the red_lines count grew by more than 0
- * (a "red line added" is treated as drift, not a hard blocker).
- */
-export const deterministicInvokeSkepticLlm = async (pkg, prompt) => {
-    void prompt;
-    const driftRisks = [];
-    const overfitRisks = [];
-    const safetyRegressionRisks = [];
-    // (1) Drift: red_lines in the rubric package that the author
-    // did not pass through. The deterministic stub treats any
-    // package red_line as a drift signal.
-    if (pkg.red_lines.length > 0) {
-        driftRisks.push(`red_line(s) present but not addressed: ${pkg.red_lines.join("; ")}`);
-    }
-    // (2) Overfit: a diff with `prompt_template` or `gates_weakening`
-    // keys without a rubric entry is a prompt-inflation / gate-
-    // weakening signal.
-    const diffKeys = Object.keys(pkg.diff);
-    const hasPromptTemplateChange = diffKeys.includes("prompt_template") || diffKeys.includes("gates_weakening");
-    const rubricHasCounter = Object.keys(pkg.rubric).length > 0;
-    if (hasPromptTemplateChange && !rubricHasCounter) {
-        overfitRisks.push("diff touches prompt_template or gates_weakening without an explicit rubric counter — possible prompt inflation / gate weakening");
-    }
-    // (3) Safety regression: dropped red_line is the canonical
-    // signal; the stub flags it when the after_snapshot carries a
-    // `dropped_red_lines` array.
-    const dropped = pkg.after_snapshot["dropped_red_lines"];
-    if (Array.isArray(dropped) && dropped.length > 0) {
-        for (const entry of dropped) {
-            if (typeof entry === "string") {
-                safetyRegressionRisks.push(`red_line dropped from after_snapshot: ${entry}`);
-            }
-        }
-    }
-    // Blocker: a hard revert signal. Emit when safety regression is
-    // non-empty (a dropped red line is a hard blocker per spec).
-    let blocker;
-    if (safetyRegressionRisks.length > 0) {
-        blocker = `safety_regression: ${safetyRegressionRisks.length} red_line(s) dropped`;
-    }
-    else if (overfitRisks.length > 0) {
-        // Overfit is a soft blocker; only emit a `blocker` if the
-        // driftRisks also flag a new red line added (drift + overfit
-        // together = hard block).
-        if (driftRisks.length > 0) {
-            blocker = `drift+overfit: ${driftRisks[0]}; ${overfitRisks[0]}`;
-        }
-    }
-    return {
-        driftRisks,
-        overfitRisks,
-        safetyRegressionRisks,
-        ...(blocker !== undefined ? { blocker } : {}),
-    };
-};
-/**
- * Public entry point: run the regression skeptic against the
- * evaluation package, the proposal verdict, and the independent
- * evaluator's result. The skeptic is a SEPARATE sub-agent call:
- * it does NOT share a context with the evaluator or the author.
- */
-export async function runRegressionSkeptic(proposal, verdict, evaluatorResult, invokeLlm = deterministicInvokeSkepticLlm) {
-    const pkg = buildEvaluationPackage(proposal);
-    const prompt = buildSkepticPrompt(pkg, verdict, evaluatorResult);
-    return await invokeLlm(pkg, prompt);
-}