synergyspec-selfevolving 1.4.0 → 2.1.0

package/dist/core/self-evolution/reward-aggregator.d.ts

@@ -0,0 +1,59 @@
+/**
+ * 奖励智能体 REWARD AGENT — statistical layer (② A/A noise floor + SPRT).
+ *
+ * Wraps {@link scoreOnce} to run k judged duels for ONE episode, cancel the
+ * judge's position bias by swapping arm order across samples (③), size the
+ * judge's jitter with an A/A pair (the NOISE FLOOR), stop early with a sequential
+ * test (SPRT), and route a within-noise advantage to the ⑤ `insufficient-signal`
+ * verdict. It then writes the ONE aggregated `diagnosis.json` (means + `stats`)
+ * and advances the episode to `scored`.
+ *
+ * Defaults are zero-cost: `samples` defaults to 1, which runs exactly ONE duel
+ * and produces a diagnosis byte-compatible with {@link runRewardAgent} (no extra
+ * spawns, no `stats`). The orchestrator calls THIS as its single reward entry so
+ * the ④ tamper hint + block mode are honored uniformly; everything beyond a
+ * single sample is opt-in via `selfEvolution.reward`.
+ */
+import { spawn as nodeSpawn } from 'node:child_process';
+import { type RewardDiagnosis } from './reward-agent.js';
+import { type EpisodeRecord } from './episode-store.js';
+/** The loop-v2 reward judge-quality config (mirrors `selfEvolution.reward`). */
+export interface RewardConfig {
+    /** Judged duels per episode. Default 1 (single sample, no extra spawns). */
+    samples?: number;
+    /** Minimum |advantage| to trust; within ⇒ insufficient-signal. Measured via A/A when omitted. */
+    noiseFloor?: number;
+    /** Swap arm order across samples (③). Defaults to true when samples > 1. */
+    orderSwap?: boolean;
+    /** Reserved: the gate-not-blend rule is always enforced inside the judge. */
+    requireCorrectnessGate?: boolean;
+    /** Test-tamper handling (the detection is the orchestrator's; this only gates routing). */
+    tamperCheck?: 'off' | 'flag' | 'block';
+}
+export interface RunRewardAgentEnsembleOptions {
+    repoRoot: string;
+    episodeId: string;
+    spawn?: typeof nodeSpawn;
+    binary?: string;
+    maxRepairAttempts?: number;
+    /** Judge-quality knobs; omitted ⇒ single sample, flag-only (historical behavior). */
+    reward?: RewardConfig;
+    /** ④ tamper hint computed upstream; injected into the judge prompt + integrity. */
+    integrityHint?: {
+        suspected: boolean;
+        flags: string[];
+    } | null;
+}
+export interface RunRewardAgentEnsembleResult {
+    diagnosis: RewardDiagnosis;
+    diagnosisPath: string;
+    episode: EpisodeRecord;
+}
+/**
+ * Run the reward judge as a k-sample ensemble (② noise floor + SPRT). At
+ * `samples <= 1` this is a single duel whose diagnosis matches
+ * {@link runRewardAgent} (plus any ④ tamper override). The ONLY write path is
+ * the episode dir (`diagnosis.json` + stage → `scored`).
+ */
+export declare function runRewardAgentEnsemble(opts: RunRewardAgentEnsembleOptions): Promise<RunRewardAgentEnsembleResult>;
+//# sourceMappingURL=reward-aggregator.d.ts.map

package/dist/core/self-evolution/reward-aggregator.js

@@ -0,0 +1,262 @@
+import { loadRewardScoringContext, scoreOnce, deriveSingleSampleVerdict, buildAnchors, } from './reward-agent.js';
+import { writeDiagnosis, advanceEpisodeStage, } from './episode-store.js';
+// ── SPRT parameters (Wald) ───────────────────────────────────────────────────
+// Treat each duel as a Bernoulli "main wins" (advantage > 0). H1: p1=0.8 (main is
+// genuinely better), H0: p0=0.5 (no real difference). alpha=beta=0.1.
+const SPRT_P1 = 0.8;
+const SPRT_P0 = 0.5;
+const SPRT_ALPHA = 0.1;
+const SPRT_BETA = 0.1;
+const SPRT_UPPER = Math.log((1 - SPRT_BETA) / SPRT_ALPHA); // accept H1 (main-better)
+const SPRT_LOWER = Math.log(SPRT_BETA / (1 - SPRT_ALPHA)); // accept H0 (no difference)
+function clamp01(v) {
+    if (Number.isNaN(v))
+        return 0;
+    return v < 0 ? 0 : v > 1 ? 1 : v;
+}
+function mean(xs) {
+    return xs.length === 0 ? 0 : xs.reduce((a, b) => a + b, 0) / xs.length;
+}
+function stdev(xs) {
+    if (xs.length < 2)
+        return 0;
+    const m = mean(xs);
+    const variance = xs.reduce((a, b) => a + (b - m) ** 2, 0) / (xs.length - 1);
+    return Math.sqrt(variance);
+}
+/** Per-duel SPRT log-likelihood-ratio increment for a Bernoulli "main wins" outcome. */
+function sprtIncrement(mainWon) {
+    return mainWon
+        ? Math.log(SPRT_P1 / SPRT_P0)
+        : Math.log((1 - SPRT_P1) / (1 - SPRT_P0));
+}
+/**
+ * Run the reward judge as a k-sample ensemble (② noise floor + SPRT). At
+ * `samples <= 1` this is a single duel whose diagnosis matches
+ * {@link runRewardAgent} (plus any ④ tamper override). The ONLY write path is
+ * the episode dir (`diagnosis.json` + stage → `scored`).
+ */
+export async function runRewardAgentEnsemble(opts) {
+    const { repoRoot, episodeId } = opts;
+    const samples = Math.max(1, Math.floor(opts.reward?.samples ?? 1));
+    const orderSwap = opts.reward?.orderSwap ?? samples > 1;
+    const tamperBlock = (opts.reward?.tamperCheck ?? 'flag') === 'block' && (opts.integrityHint?.suspected ?? false);
+    const integrityHint = opts.integrityHint ?? null;
+    const ctx = await loadRewardScoringContext(repoRoot, episodeId);
+    const basePromptInput = { ...ctx.promptInput, integrityHint };
+    const armOrderFor = (i) => orderSwap && i % 2 === 1 ? 'baseline-first' : 'main-first';
+    const runDuel = (i) => scoreOnce({
+        promptInput: { ...basePromptInput, armOrder: armOrderFor(i) },
+        baselineSkipped: ctx.baselineSkipped,
+        repoRoot,
+        spawn: opts.spawn,
+        binary: opts.binary,
+        maxRepairAttempts: opts.maxRepairAttempts,
+    });
+    // ── run the duels, with SPRT early-stop when the baseline ran ────────────────
+    const duels = [];
+    let llr = 0;
+    let sequentialDecision = samples <= 1 ? 'single' : 'continue';
+    for (let i = 0; i < samples; i++) {
+        const duel = await runDuel(i);
+        duels.push(duel);
+        if (samples > 1 && !ctx.baselineSkipped && duel.parsed.advantage !== null) {
+            llr += sprtIncrement(duel.parsed.advantage > 0);
+            if (llr >= SPRT_UPPER) {
+                sequentialDecision = 'accept';
+                break;
+            }
+            if (llr <= SPRT_LOWER) {
+                sequentialDecision = 'reject';
+                break;
+            }
+        }
+    }
+    const diagnosis = samples <= 1
+        ? buildSingleSampleDiagnosis(ctx, duels[0], tamperBlock)
+        : await buildAggregatedDiagnosis(opts, ctx, duels, sequentialDecision, tamperBlock);
+    const diagnosisPath = await writeDiagnosis({ repoRoot, episodeId, diagnosis });
+    const episode = await advanceEpisodeStage({
+        repoRoot,
+        episodeId,
+        stage: 'scored',
+        patch: { advantage: diagnosis.advantage },
+    });
+    return { diagnosis, diagnosisPath, episode };
+}
+/** Single-sample diagnosis — identical to {@link runRewardAgent}, plus the ④ block override. */
+function buildSingleSampleDiagnosis(ctx, duel, tamperBlock) {
+    const { parsed, integrity } = duel;
+    let verdict = deriveSingleSampleVerdict(parsed);
+    let advantage = parsed.advantage;
+    let finalIntegrity = integrity;
+    if (tamperBlock) {
+        verdict = 'insufficient-signal';
+        advantage = null;
+        finalIntegrity = withTamperBlockFlag(integrity);
+    }
+    return assembleDiagnosis(ctx.episode, {
+        rewardMain: parsed.rewardMain,
+        rewardBaseline: parsed.rewardBaseline,
+        advantage,
+        anchors: ctx.promptInput.anchors,
+        errors: parsed.errors,
+        gaps: parsed.gaps,
+        textualGradient: parsed.textualGradient,
+        abstained: parsed.abstained,
+        abstainReason: parsed.abstainReason,
+        verdict,
+        confidence: parsed.confidence ?? undefined,
+        integrity: finalIntegrity,
+    });
+}
+/** Aggregate k duels into one diagnosis (means + ② stats + verdict from noise floor). */
+async function buildAggregatedDiagnosis(opts, ctx, duels, sequentialDecision, tamperBlock) {
+    const rewardMains = duels.map((d) => d.parsed.rewardMain);
+    const rewardMain = mean(rewardMains);
+    const advantages = duels
+        .map((d) => d.parsed.advantage)
+        .filter((a) => a !== null);
+    // Representative duel: when the baseline ran, the one whose advantage is
+    // closest to the mean; otherwise the one whose rewardMain is closest to the
+    // mean. Its gaps/errors/gradient carry the diagnostic content.
+    const advantageMean = advantages.length > 0 ? mean(advantages) : null;
+    const target = advantageMean ?? rewardMain;
+    const repValue = (d) => advantageMean !== null ? (d.parsed.advantage ?? Number.POSITIVE_INFINITY) : d.parsed.rewardMain;
+    const rep = duels.reduce((best, d) => Math.abs(repValue(d) - target) < Math.abs(repValue(best) - target) ? d : best);
+    const rewardBaseline = ctx.baselineSkipped
+        ? null
+        : mean(duels.map((d) => d.parsed.rewardBaseline ?? 0));
+    // ② Noise floor: the configured value, else measured from ONE A/A duel
+    // (main-vs-main) whose advantage should be ~0; its magnitude is the jitter.
+    let noiseFloor = opts.reward?.noiseFloor ?? null;
+    if (noiseFloor === null && !ctx.baselineSkipped) {
+        noiseFloor = await measureNoiseFloor(opts, ctx);
+    }
+    const advantageStdev = advantages.length >= 2 ? stdev(advantages) : null;
+    // ⑤ Verdict from the aggregated advantage vs the noise floor.
+    let verdict;
+    let advantage = advantageMean;
+    if (advantageMean === null) {
+        verdict = undefined; // baseline skipped — only the main arm was scored
+    }
+    else if (noiseFloor !== null && Math.abs(advantageMean) <= noiseFloor) {
+        verdict = 'insufficient-signal';
+        advantage = null;
+    }
+    else if (advantageMean > 1e-9) {
+        verdict = 'main-better';
+    }
+    else if (advantageMean < -1e-9) {
+        verdict = 'baseline-better';
+    }
+    else {
+        verdict = 'tie';
+    }
+    // Confidence: 0 when insufficient-signal; else the signal's share of (signal + jitter).
+    const confidence = advantageMean === null
+        ? undefined
+        : verdict === 'insufficient-signal'
+            ? 0
+            : clamp01(Math.abs(advantageMean) / (Math.abs(advantageMean) + (advantageStdev ?? 0) + 1e-9));
+    // Merge integrity across duels: tamper from the hint; divergence from the rep;
+    // flags = de-duplicated union (each duel already folded in any tamper flags).
+    const flags = Array.from(new Set(duels.flatMap((d) => d.integrity.flags)));
+    let integrity = {
+        testTamperSuspected: rep.integrity.testTamperSuspected,
+        judgeVerifierDivergence: rep.integrity.judgeVerifierDivergence,
+        flags,
+    };
+    if (tamperBlock) {
+        verdict = 'insufficient-signal';
+        advantage = null;
+        integrity = withTamperBlockFlag(integrity);
+    }
+    return assembleDiagnosis(ctx.episode, {
+        rewardMain,
+        rewardBaseline,
+        advantage,
+        anchors: ctx.promptInput.anchors,
+        errors: rep.parsed.errors,
+        gaps: rep.parsed.gaps,
+        textualGradient: rep.parsed.textualGradient,
+        abstained: rep.parsed.abstained,
+        abstainReason: rep.parsed.abstainReason,
+        verdict,
+        confidence,
+        integrity,
+        stats: {
+            samples: duels.length,
+            advantageMean,
+            advantageStdev,
+            noiseFloor,
+            sequentialDecision,
+        },
+    });
+}
+/** Run one A/A duel (main vs main) and return |advantage| as the judge's jitter. */
+async function measureNoiseFloor(opts, ctx) {
+    const main = ctx.promptInput.mainArm;
+    const aaAnchors = buildAnchors(main.objective, main.objective);
+    const aaPromptInput = {
+        ...ctx.promptInput,
+        integrityHint: null,
+        baselineArm: main,
+        policyVersions: {
+            main: ctx.promptInput.policyVersions.main,
+            baseline: ctx.promptInput.policyVersions.main,
+        },
+        anchors: aaAnchors,
+        armOrder: 'main-first',
+    };
+    try {
+        const aa = await scoreOnce({
+            promptInput: aaPromptInput,
+            baselineSkipped: false,
+            repoRoot: opts.repoRoot,
+            spawn: opts.spawn,
+            binary: opts.binary,
+            maxRepairAttempts: opts.maxRepairAttempts,
+        });
+        return aa.parsed.advantage === null ? null : Math.abs(aa.parsed.advantage);
+    }
+    catch {
+        // A/A is a calibration aid, not load-bearing: a failed A/A leaves the floor
+        // unmeasured (null ⇒ no insufficient-signal gating from the floor).
+        return null;
+    }
+}
+function withTamperBlockFlag(integrity) {
+    const flag = 'tamper: blocked (tamperCheck=block) — forced insufficient-signal';
+    return {
+        ...integrity,
+        flags: integrity.flags.includes(flag) ? integrity.flags : [...integrity.flags, flag],
+    };
+}
+/** Build the {@link RewardDiagnosis} record (schema 2) from an episode + computed parts. */
+function assembleDiagnosis(episode, parts) {
+    return {
+        schemaVersion: 2,
+        episodeId: episode.episodeId,
+        changeName: episode.changeName,
+        targetId: episode.targetId,
+        policyVersions: {
+            main: episode.policyVersionMain,
+            baseline: episode.policyVersionBaseline,
+        },
+        rewardMain: parts.rewardMain,
+        rewardBaseline: parts.rewardBaseline,
+        advantage: parts.advantage,
+        anchors: parts.anchors,
+        errors: parts.errors,
+        gaps: parts.gaps,
+        textualGradient: parts.textualGradient,
+        abstained: parts.abstained,
+        ...(parts.abstainReason !== undefined ? { abstainReason: parts.abstainReason } : {}),
+        ...(parts.verdict !== undefined ? { verdict: parts.verdict } : {}),
+        ...(parts.confidence !== undefined ? { confidence: parts.confidence } : {}),
+        integrity: parts.integrity,
+        ...(parts.stats !== undefined ? { stats: parts.stats } : {}),
+    };
+}
+//# sourceMappingURL=reward-aggregator.js.map

package/dist/core/self-evolution/scope-gate.d.ts

@@ -0,0 +1,66 @@
+/**
+ * 范围⊆诊断 scope⊆diagnosis gate for the 演进智能体 EVOLVING AGENT — loop v2
+ * (self-evolution as in-context RL).
+ *
+ * The 奖励智能体 REWARD AGENT names a set of GAPS, each anchored to a (file,
+ * section) the 文本梯度 textual gradient points at. The EVOLVING AGENT's ONE
+ * bounded edit must stay INSIDE those named sections — it may not wander off
+ * and rewrite an unrelated heading just because the file is editable. This gate
+ * is the check: from the line diff, compute each changed range's ENCLOSING
+ * section, and PASS iff every (file, section) the edit touches is covered by
+ * some diagnosis gap.
+ *
+ * Section addressing:
+ *   - `.md` files: the nearest PRECEDING markdown heading of any `#`-level
+ *     (`# …`, `## …`, …). A change before the first heading has section `''`
+ *     (the file preamble).
+ *   - YAML / other files: the nearest preceding TOP-LEVEL key (`key:` at column
+ *     0). A change before the first top-level key has section `''`.
+ *
+ * Coverage:
+ *   - a gap `{file: '*'}` covers ANY file;
+ *   - a gap `{section: '*'}` covers the WHOLE file;
+ *   - otherwise the gap's `file` AND `section` must match exactly.
+ *
+ * Pure + dependency-free (golden-testable). Re-uses {@link lineDiff} so its
+ * notion of "changed lines" is identical to the ≤ L budget check.
+ */
+import { type DiffEdit } from './line-diff.js';
+/** A (file, section) the 奖励智能体 REWARD AGENT's diagnosis points the edit at. */
+export interface DiagnosisGap {
+    /** Repo-relative POSIX path, or `'*'` to cover any file. */
+    file: string;
+    /** Section anchor (markdown heading text / YAML top-level key), or `'*'`. */
+    section: string;
+}
+/** One changed (file, section) the edit touched but no gap covered. */
+export interface ScopeViolation {
+    file: string;
+    section: string;
+    /** 1-based inclusive line spans (in the proposed file) that fell out of scope. */
+    lines: {
+        startLine: number;
+        endLine: number;
+    }[];
+}
+export interface ScopeGateResult {
+    pass: boolean;
+    violations: ScopeViolation[];
+}
+export interface CheckScopeWithinDiagnosisInput {
+    /** Proposed full-file replacements the EVOLVING AGENT wants to write. */
+    edits: readonly DiffEdit[];
+    /** Current on-disk contents of the same files (for the line diff). */
+    currentFiles: readonly DiffEdit[];
+    /** The diagnosis gaps the edit's scope must be a subset of. */
+    gaps: readonly DiagnosisGap[];
+}
+/**
+ * Run the 范围⊆诊断 scope⊆diagnosis gate. For every edit, diff it against its
+ * current content, resolve each changed range's enclosing section, and flag any
+ * (file, section) not covered by a gap. Returns `{pass, violations}`; a pure
+ * deletion (no inserted range) is in-scope by construction (it removes named or
+ * unnamed lines but introduces no new out-of-scope section) and is not flagged.
+ */
+export declare function checkScopeWithinDiagnosis(input: CheckScopeWithinDiagnosisInput): ScopeGateResult;
+//# sourceMappingURL=scope-gate.d.ts.map

package/dist/core/self-evolution/scope-gate.js

@@ -0,0 +1,107 @@
+/**
+ * 范围⊆诊断 scope⊆diagnosis gate for the 演进智能体 EVOLVING AGENT — loop v2
+ * (self-evolution as in-context RL).
+ *
+ * The 奖励智能体 REWARD AGENT names a set of GAPS, each anchored to a (file,
+ * section) the 文本梯度 textual gradient points at. The EVOLVING AGENT's ONE
+ * bounded edit must stay INSIDE those named sections — it may not wander off
+ * and rewrite an unrelated heading just because the file is editable. This gate
+ * is the check: from the line diff, compute each changed range's ENCLOSING
+ * section, and PASS iff every (file, section) the edit touches is covered by
+ * some diagnosis gap.
+ *
+ * Section addressing:
+ *   - `.md` files: the nearest PRECEDING markdown heading of any `#`-level
+ *     (`# …`, `## …`, …). A change before the first heading has section `''`
+ *     (the file preamble).
+ *   - YAML / other files: the nearest preceding TOP-LEVEL key (`key:` at column
+ *     0). A change before the first top-level key has section `''`.
+ *
+ * Coverage:
+ *   - a gap `{file: '*'}` covers ANY file;
+ *   - a gap `{section: '*'}` covers the WHOLE file;
+ *   - otherwise the gap's `file` AND `section` must match exactly.
+ *
+ * Pure + dependency-free (golden-testable). Re-uses {@link lineDiff} so its
+ * notion of "changed lines" is identical to the ≤ L budget check.
+ */
+import { lineDiff } from './line-diff.js';
+function toPosix(p) {
+    return p.replace(/\\/g, '/');
+}
+/**
+ * The enclosing section of 1-based `line` in `proposedContent`. For `.md`
+ * files it is the nearest preceding heading's text; otherwise the nearest
+ * preceding top-level (`key:` at column 0) key. `''` when nothing precedes it.
+ */
+function enclosingSection(relPath, proposedLines, line) {
+    const isMarkdown = /\.md$/i.test(relPath);
+    let section = '';
+    // Scan from the file top down to (and including) the changed line; the last
+    // matching anchor at-or-before it is the enclosing section.
+    const upto = Math.min(line, proposedLines.length);
+    for (let idx = 0; idx < upto; idx++) {
+        const text = proposedLines[idx];
+        if (isMarkdown) {
+            const h = /^#{1,6}\s+(.+?)\s*$/.exec(text);
+            if (h)
+                section = h[1];
+        }
+        else {
+            // Top-level key: an identifier-ish key at column 0 followed by ':'.
+            const k = /^([^\s:#][^:]*):(?:\s|$)/.exec(text);
+            if (k)
+                section = k[1].trim();
+        }
+    }
+    return section;
+}
+/** True iff some gap covers `(file, section)` per the wildcard rules. */
+function isCovered(file, section, gaps) {
+    for (const gap of gaps) {
+        const fileOk = gap.file === '*' || toPosix(gap.file) === file;
+        if (!fileOk)
+            continue;
+        if (gap.section === '*' || gap.section === section)
+            return true;
+    }
+    return false;
+}
+/**
+ * Run the 范围⊆诊断 scope⊆diagnosis gate. For every edit, diff it against its
+ * current content, resolve each changed range's enclosing section, and flag any
+ * (file, section) not covered by a gap. Returns `{pass, violations}`; a pure
+ * deletion (no inserted range) is in-scope by construction (it removes named or
+ * unnamed lines but introduces no new out-of-scope section) and is not flagged.
+ */
+export function checkScopeWithinDiagnosis(input) {
+    const currentByPath = new Map(input.currentFiles.map((f) => [toPosix(f.relPath), f.content]));
+    // Accumulate violations keyed by file+section so the lines coalesce per spot.
+    const violationByKey = new Map();
+    for (const edit of input.edits) {
+        const rel = toPosix(edit.relPath);
+        const current = currentByPath.get(rel) ?? '';
+        const proposedLines = edit.content.length === 0 ? [] : edit.content.replace(/\n$/, '').split('\n');
+        const d = lineDiff(current, edit.content);
+        for (const range of d.changedRanges) {
+            const section = enclosingSection(rel, proposedLines, range.startLine);
+            if (isCovered(rel, section, input.gaps))
+                continue;
+            const key = `${rel}
${section}`;
+            const existing = violationByKey.get(key);
+            if (existing) {
+                existing.lines.push({ startLine: range.startLine, endLine: range.endLine });
+            }
+            else {
+                violationByKey.set(key, {
+                    file: rel,
+                    section,
+                    lines: [{ startLine: range.startLine, endLine: range.endLine }],
+                });
+            }
+        }
+    }
+    const violations = [...violationByKey.values()];
+    return { pass: violations.length === 0, violations };
+}
+//# sourceMappingURL=scope-gate.js.map

package/dist/core/self-evolution/success-channel.js

@@ -229,7 +229,7 @@ export async function mineSuccessSignals(opts) {
     const walkedPaths = [];
     const minedKeys = new Map();
     const protect = (targetId, section) => {
-        const key = `${targetId}${section}`;
+        const key = `${targetId} ${section}`;
         if (!minedKeys.has(key))
             minedKeys.set(key, { targetId, section });
     };
@@ -282,7 +282,7 @@ export async function mineSuccessSignals(opts) {
         }
     }
     // Best-effort persist (health-baseline.ts pattern): a failed side-write must
-    // never fail the learn/auto-evolve run that triggered the mining.
+    // never fail the learn/episode run that triggered the mining.
     let protectionsWritten = 0;
     try {
         const file = protectionsPath(projectRoot);

package/dist/core/self-evolution/tamper-check.d.ts

@@ -0,0 +1,24 @@
+export interface DetectTestTamperInput {
+    /** Absolute path to the change dir (holds the 5 artifacts + test-report.md + any test files). */
+    changeDirPath: string;
+}
+export interface TamperResult {
+    suspected: boolean;
+    /** Human-readable reasons, e.g. "spec-tests.md declares 36 scenarios but test-report shows 4 collected". Empty when clean. */
+    flags: string[];
+}
+/**
+ * Count the scenarios/tests a `spec-tests.md` declares. The canonical gen-tests
+ * format is a "Requirement Traceability Matrix" markdown table — one row per
+ * mapped (requirement, test) pair. We count those data rows (skipping the
+ * header + separator and any row whose test cell is "—"/blank, which marks a
+ * step with no applicable test). Returns null when no countable table is found.
+ */
+export declare function countDeclaredScenarios(specTestsText: string): number | null;
+/**
+ * Detect whether a change's tests were tampered to fake a pass. Reads only
+ * files under `input.changeDirPath`; tolerates every missing file. `suspected`
+ * is true iff at least one strong heuristic fired.
+ */
+export declare function detectTestTamper(input: DetectTestTamperInput): Promise<TamperResult>;
+//# sourceMappingURL=tamper-check.d.ts.map