peaks-loop 3.1.2 → 4.0.0-beta.10

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

@@ -0,0 +1,286 @@
+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/services/evolution/independent-evaluator-runner.d.ts

@@ -0,0 +1,90 @@
+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/services/evolution/independent-evaluator-runner.js

@@ -0,0 +1,106 @@
+/**
+ * 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/services/evolution/regression-skeptic-runner.d.ts

@@ -0,0 +1,64 @@
+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/services/evolution/regression-skeptic-runner.js

@@ -0,0 +1,113 @@
+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);
+}