@loopover/engine 1.0.0

package/dist/signals/preflight-limits.d.ts

@@ -0,0 +1,14 @@
+export declare const PREFLIGHT_LIMITS: {
+    readonly repoFullNameChars: 200;
+    readonly contributorLoginChars: 100;
+    readonly titleChars: 300;
+    readonly bodyChars: 20000;
+    readonly labelChars: 100;
+    readonly changedFileChars: 300;
+    readonly testChars: 300;
+    readonly authorAssociationChars: 100;
+    readonly labels: 50;
+    readonly changedFiles: 200;
+    readonly linkedIssues: 100;
+    readonly tests: 50;
+};

package/dist/signals/preflight-limits.js

@@ -0,0 +1,14 @@
+export const PREFLIGHT_LIMITS = {
+    repoFullNameChars: 200,
+    contributorLoginChars: 100,
+    titleChars: 300,
+    bodyChars: 20_000,
+    labelChars: 100,
+    changedFileChars: 300,
+    testChars: 300,
+    authorAssociationChars: 100,
+    labels: 50,
+    changedFiles: 200,
+    linkedIssues: 100,
+    tests: 50,
+};

package/dist/signals/slop.d.ts

@@ -0,0 +1,56 @@
+import type { AdvisoryFinding } from "../types/predicted-gate-types.js";
+export declare const GENERIC_COMMIT_PATTERN: RegExp;
+export declare function hasClearNoIssueRationale(pr: {
+    title: string;
+    body?: string | null | undefined;
+}): boolean;
+export type SlopBand = "clean" | "low" | "elevated" | "high";
+export type SlopChangedFile = {
+    path: string;
+    additions?: number | undefined;
+    deletions?: number | undefined;
+};
+export type SlopAssessmentInput = {
+    changedFiles?: SlopChangedFile[] | undefined;
+    tests?: string[] | undefined;
+    testFiles?: string[] | undefined;
+    /** PR/branch description. An empty/whitespace description on a code change is a weak-effort signal. */
+    description?: string | null | undefined;
+    /** The PR's commit subject line(s). A generic/empty primary subject (wip / fix / update / ".") is a weak-effort signal. */
+    commitMessages?: string[] | undefined;
+    /** True when this PR sits in a high-risk duplicate cluster (2+ open PRs) — the caller computes it from
+     *  the collision report. Undefined on surfaces without repo context. */
+    inDuplicateCluster?: boolean | undefined;
+    /** Whether this PR links at least one issue (caller computes from `linkedIssues.length > 0`). Only an
+     *  explicit `false` can trip the no-linked-issue-without-rationale signal; undefined means the surface
+     *  has no issue data. */
+    hasLinkedIssue?: boolean | undefined;
+    /** True when the contributor/repo is in the issue-discovery lane, where PRs without a linked issue are
+     *  expected and so the no-linked-issue-without-rationale signal does not apply. */
+    issueDiscoveryLane?: boolean | undefined;
+};
+export type SlopAssessment = {
+    slopRisk: number;
+    band: SlopBand;
+    findings: AdvisoryFinding[];
+};
+export declare const SLOP_WEIGHTS: {
+    readonly trivialWhitespaceChurn: 30;
+    readonly missingTestEvidence: 15;
+    readonly nonSubstantivePadding: 30;
+    readonly emptyDescription: 15;
+    readonly lowQualityCommitMessage: 15;
+    readonly duplicateClusterMembership: 15;
+    readonly noLinkedIssueWithoutRationale: 15;
+};
+export declare const SLOP_RUBRIC_MARKDOWN: string;
+export declare function buildSlopAssessment(input: SlopAssessmentInput): SlopAssessment;
+export declare function buildNonSubstantivePaddingFinding(input: SlopAssessmentInput): AdvisoryFinding | null;
+export declare function buildEmptyDescriptionFinding(input: SlopAssessmentInput): AdvisoryFinding | null;
+export declare function buildLowQualityCommitMessageFinding(input: SlopAssessmentInput): AdvisoryFinding | null;
+export declare function buildDuplicateClusterFinding(input: SlopAssessmentInput): AdvisoryFinding | null;
+export declare function buildNoLinkedIssueRationaleFinding(input: SlopAssessmentInput): AdvisoryFinding | null;
+export declare function buildMissingTestEvidenceFinding(input: SlopAssessmentInput): AdvisoryFinding | null;
+export declare function buildTrivialWhitespaceChurnFinding(input: SlopAssessmentInput): AdvisoryFinding | null;
+export declare function slopBandFor(slopRisk: number): SlopBand;
+export declare function clamp(value: number, min: number, max: number): number;

package/dist/signals/slop.js

@@ -0,0 +1,324 @@
+import { isCodeFile, isTestFile, classifyChangedFile } from "./path-matchers.js";
+import { hasLocalTestEvidence, isTestPath } from "./test-evidence.js";
+import { isFocusManifestPublicSafe } from "../focus-manifest.js";
+// PR-side slop-assessment scorer (#5133, Wave 3.5 follow-up to #2333/#2334), extracted from
+// `src/signals/slop.ts` so the miner CLI's iterate-loop (packages/gittensory-miner) can run the SAME
+// deterministic self-review scorer the live gate uses, instead of no real implementation at all
+// (`attempt-runner.js`'s `deps.runSlopAssessment` had no production binding before this). This file is
+// the canonical implementation; `src/signals/slop.ts`'s PR-side exports become a thin re-export shim over
+// it (imported via relative source path, matching this repo's existing engine-consumption convention —
+// see e.g. `src/signals/path-matchers.ts`). Only the PR-side scorer is extracted here — the issue-side
+// triage (`buildIssueSlopAssessment` and friends) stays in `src/`, since it is not needed by the miner's
+// self-review path and was never part of this issue's scope.
+//
+// GENERIC_COMMIT_PATTERN / hasClearNoIssueRationale below are a HAND-KEPT MIRROR of the same-named
+// exports in `src/signals/engine.ts` — that file is not extracted (it is 5700+ lines, deeply
+// interconnected with the live app's DB/Workers/scoring subsystems, and used by many call sites beyond
+// slop.ts), so these two small, fully self-contained pieces are duplicated here instead, matching the
+// established discipline already used by `packages/gittensory-engine/src/miner/self-review-adapter.ts`'s
+// own header comment ("hand-kept structural mirror... keep in sync by hand"). Keep both copies in sync by
+// hand if either changes.
+export const GENERIC_COMMIT_PATTERN = /^(?:(?:wip|fix(?:es|ed|ing)?|updat(?:e|es|ed|ing)|change[sd]?|edit[sd]?|patch|minor|tweak[sd]?|misc|cleanup|chore|stuff|temp|tmp|test|final|done|commit|asdf+)\b|\.+)[\s.!]*$/i;
+export function hasClearNoIssueRationale(pr) {
+    return /\b(?:no issue\s*(?:because\b|:)|no linked issue\s*(?:because\b|:)|no ticket\s*(?:because\b|:)|(?:maintenance|docs?[\s-]+only|tests?[\s-]+only|ci[\s-]+only|refactor[\s-]+only|typo|chore|cleanup)\b)/i.test([pr.title, pr.body ?? ""].join(" "));
+}
+// Deterministic, high-precision signals only — this score is the ONLY thing allowed to gate (block), so it
+// must be false-positive-averse. The "strong" signals (trivialWhitespaceChurn, nonSubstantivePadding) are
+// weighted 30 so the `high` band (>=60) is reachable from any two of them. missingTestEvidence is a
+// weak/corroborating 15: missing-test alone never blocks, and even paired with one strong-30 signal it only
+// reaches 45 (elevated, not blockable at the default block threshold) — it takes two strong signals (or one
+// strong + two weak) to block. `clamp(.,0,100)` keeps the stacked score bounded.
+export const SLOP_WEIGHTS = {
+    trivialWhitespaceChurn: 30,
+    missingTestEvidence: 15,
+    nonSubstantivePadding: 30,
+    emptyDescription: 15,
+    lowQualityCommitMessage: 15,
+    duplicateClusterMembership: 15,
+    noLinkedIssueWithoutRationale: 15,
+};
+export const SLOP_RUBRIC_MARKDOWN = [
+    "# Gittensory slop assessment rubric",
+    "",
+    "- `clean`: 0",
+    "- `low`: 1-30",
+    "- `elevated`: 31-59",
+    "- `high`: 60-100",
+    "",
+    "Current deterministic signals:",
+    "- trivial / whitespace-only churn",
+    "- missing test evidence",
+    "- non-substantive padding (generated / vendored / minified output as source)",
+    "- empty pull request description on a code change",
+    "- generic or empty commit message",
+    "- duplicate / overlapping pull request (high-risk collision cluster)",
+    "- no linked issue and no rationale (outside the issue-discovery lane)",
+].join("\n");
+const MIN_CHURN_LINES = 40;
+const MAX_SOURCE_LINE_SHARE = 0.15;
+// Minimum added lines for a changed test file to count as real test evidence. A genuine test needs at
+// least a describe/it/assert; an empty or stub file (0-2 added lines) does not.
+const MIN_SUBSTANTIVE_TEST_ADDITIONS = 3;
+// A padded diff is one whose churn is dominated by non-substantive output. Set at half the diff so a PR
+// with any meaningful share of real, hand-authored files cannot trip it.
+const PADDING_DOMINANCE_SHARE = 0.5;
+export function buildSlopAssessment(input) {
+    const findings = [];
+    const trivialChurnFinding = buildTrivialWhitespaceChurnFinding(input);
+    const missingTestEvidenceFinding = buildMissingTestEvidenceFinding(input);
+    const nonSubstantivePaddingFinding = buildNonSubstantivePaddingFinding(input);
+    const emptyDescriptionFinding = buildEmptyDescriptionFinding(input);
+    const lowQualityCommitMessageFinding = buildLowQualityCommitMessageFinding(input);
+    const duplicateClusterFinding = buildDuplicateClusterFinding(input);
+    const noLinkedIssueRationaleFinding = buildNoLinkedIssueRationaleFinding(input);
+    if (trivialChurnFinding)
+        findings.push(trivialChurnFinding);
+    if (missingTestEvidenceFinding)
+        findings.push(missingTestEvidenceFinding);
+    if (nonSubstantivePaddingFinding)
+        findings.push(nonSubstantivePaddingFinding);
+    if (emptyDescriptionFinding)
+        findings.push(emptyDescriptionFinding);
+    if (lowQualityCommitMessageFinding)
+        findings.push(lowQualityCommitMessageFinding);
+    if (duplicateClusterFinding)
+        findings.push(duplicateClusterFinding);
+    if (noLinkedIssueRationaleFinding)
+        findings.push(noLinkedIssueRationaleFinding);
+    const slopRisk = clamp((trivialChurnFinding ? SLOP_WEIGHTS.trivialWhitespaceChurn : 0) +
+        (missingTestEvidenceFinding ? SLOP_WEIGHTS.missingTestEvidence : 0) +
+        (nonSubstantivePaddingFinding ? SLOP_WEIGHTS.nonSubstantivePadding : 0) +
+        (emptyDescriptionFinding ? SLOP_WEIGHTS.emptyDescription : 0) +
+        (lowQualityCommitMessageFinding ? SLOP_WEIGHTS.lowQualityCommitMessage : 0) +
+        (duplicateClusterFinding ? SLOP_WEIGHTS.duplicateClusterMembership : 0) +
+        (noLinkedIssueRationaleFinding ? SLOP_WEIGHTS.noLinkedIssueWithoutRationale : 0), 0, 100);
+    return {
+        slopRisk,
+        band: slopBandFor(slopRisk),
+        findings,
+    };
+}
+// Fires when a high-churn diff is dominated by generated/vendored/minified output (files that carry code
+// extensions and so slip past the source-share check in `trivialWhitespaceChurn`) while genuine source and
+// test effort is negligible — i.e. the diff is padded to look substantive. Lockfiles, dependency manifests,
+// and docs are legitimate change categories and never count toward the padding share, so dependency bumps
+// and docs PRs cannot trip this.
+export function buildNonSubstantivePaddingFinding(input) {
+    const totals = summarizePaddingLines(input.changedFiles ?? []);
+    if (totals.changedLineCount < MIN_CHURN_LINES)
+        return null;
+    if (totals.paddingLineCount === 0)
+        return null;
+    if (totals.paddingLineCount / totals.changedLineCount < PADDING_DOMINANCE_SHARE)
+        return null;
+    if (totals.substantiveLineCount / totals.changedLineCount > MAX_SOURCE_LINE_SHARE)
+        return null;
+    return buildPaddingFinding(totals.changedLineCount, totals.paddingLineCount);
+}
+function summarizePaddingLines(changedFiles) {
+    let changedLineCount = 0;
+    let paddingLineCount = 0;
+    let substantiveLineCount = 0;
+    for (const file of changedFiles) {
+        const lines = nonNegative(file.additions) + nonNegative(file.deletions);
+        if (lines === 0)
+            continue;
+        changedLineCount += lines;
+        const category = classifyChangedFile(file.path);
+        if (category === "minified" || category === "generated" || category === "vendored") {
+            paddingLineCount += lines;
+        }
+        else if (category === "source" || category === "test") {
+            substantiveLineCount += lines;
+        }
+    }
+    return { changedLineCount, paddingLineCount, substantiveLineCount };
+}
+function buildPaddingFinding(changedLineCount, paddingLineCount) {
+    // Only integer counts are interpolated, so the text is public-safe by construction.
+    const detail = `${paddingLineCount} of ${changedLineCount} changed line(s) are in generated, vendored, or minified files with little substantive source.`;
+    return {
+        code: "non_substantive_padding",
+        title: "Diff is mostly generated, vendored, or minified output",
+        severity: "warning",
+        detail,
+        action: "Exclude generated, vendored, and minified output and keep the diff focused on substantive changes.",
+        publicText: detail,
+    };
+}
+// Fires only when a real code change ships with an empty / whitespace-only description — a high-precision
+// weak-effort signal. A non-empty description (even a terse one) never trips it, to avoid false positives.
+export function buildEmptyDescriptionFinding(input) {
+    // Single pass over changedFiles instead of map().filter(Boolean).filter(isCodeFile) building three
+    // intermediate arrays: count changed code-file paths directly.
+    let codeFileCount = 0;
+    for (const file of input.changedFiles ?? []) {
+        if (file.path && isCodeFile(file.path))
+            codeFileCount += 1;
+    }
+    if (codeFileCount === 0)
+        return null;
+    if ((input.description ?? "").trim().length > 0)
+        return null;
+    const detail = ensurePublicSafeText(`${codeFileCount} code file(s) changed with an empty pull request description.`, "Code changed with an empty pull request description.");
+    return {
+        code: "empty_pr_description",
+        title: "Code change has no description",
+        severity: "warning",
+        detail,
+        action: "Describe what changed and why so reviewers can evaluate it.",
+        publicText: detail,
+    };
+}
+// Fires when commit-message data is supplied and the primary subject is empty/whitespace, or is entirely a
+// generic low-effort word (wip / fix / update / "." …). High-precision: a specific subject — even one that
+// isn't a Conventional Commit — never trips this blocking signal; only a bare generic word that IS the
+// whole subject does.
+export function buildLowQualityCommitMessageFinding(input) {
+    if (input.commitMessages === undefined || input.commitMessages.length === 0)
+        return null;
+    const messages = input.commitMessages.map((message) => message.trim()).filter((message) => message.length > 0);
+    const primary = messages[0];
+    if (primary !== undefined && !GENERIC_COMMIT_PATTERN.test(primary))
+        return null;
+    const detail = primary === undefined ? "The commit message is empty." : "The commit message is generic (e.g. wip / fix / update) with no specific detail.";
+    return {
+        code: "low_quality_commit_message",
+        title: "Commit message is generic or empty",
+        severity: "warning",
+        detail,
+        action: "Write a specific commit subject that names what changed and why (a Conventional Commit like 'feat(api): add cursor pagination' works well).",
+        publicText: detail,
+    };
+}
+// Fires when the PR sits in a HIGH-risk collision cluster that holds 2+ open pull requests — genuine
+// overlapping/duplicate work.
+export function buildDuplicateClusterFinding(input) {
+    if (input.inDuplicateCluster !== true)
+        return null;
+    const detail = "This pull request overlaps a high-risk cluster of other open pull requests doing similar work.";
+    return {
+        code: "duplicate_cluster_membership",
+        title: "Pull request duplicates other open work",
+        severity: "warning",
+        detail,
+        action: "Check for an existing pull request or issue covering this change and coordinate or consolidate before continuing.",
+        publicText: detail,
+    };
+}
+// Fires when the caller reports NO linked issue, the PR body carries no clear no-issue rationale, and the
+// repo is not in the issue-discovery lane (where unlinked PRs are expected). High-precision: only an
+// explicit `hasLinkedIssue: false` trips it — absent data (undefined) is not a signal — and any clear
+// rationale (maintenance / docs-only / "no issue: …") clears it.
+export function buildNoLinkedIssueRationaleFinding(input) {
+    if (input.hasLinkedIssue !== false)
+        return null;
+    if (input.issueDiscoveryLane === true)
+        return null;
+    if (hasClearNoIssueRationale({ title: "", body: input.description ?? "" }))
+        return null;
+    const detail = "This pull request links no issue and gives no rationale for working without one.";
+    return {
+        code: "no_linked_issue_without_rationale",
+        title: "No linked issue and no rationale",
+        severity: "warning",
+        detail,
+        action: "Link the issue this addresses, or explain in the description why no issue applies (e.g. a typo, docs-only, or maintenance change).",
+        publicText: detail,
+    };
+}
+export function buildMissingTestEvidenceFinding(input) {
+    const changedFiles = input.changedFiles ?? [];
+    const changedPaths = changedFiles.map((file) => file.path).filter(Boolean);
+    const codePaths = changedPaths.filter(isCodeFile);
+    if (codePaths.length === 0)
+        return null;
+    // A changed test FILE only counts as real test evidence when it carries substantive content. An empty or
+    // no-op test (e.g. a committed `tests/noop.test.ts`) would otherwise clear this finding by path alone. When
+    // per-file line counts are unavailable we trust the path (can't prove emptiness); when known, require a few
+    // added lines so a stub can't fake coverage. (#audit-3.1)
+    const hasSubstantiveTestFile = changedFiles.some((file) => {
+        if (!(isTestFile(file.path) || isTestPath(file.path)))
+            return false;
+        return file.additions === undefined || nonNegative(file.additions) >= MIN_SUBSTANTIVE_TEST_ADDITIONS;
+    });
+    const hasChangedTestPaths = hasSubstantiveTestFile || hasLocalTestEvidence({ tests: input.tests, testFiles: input.testFiles });
+    if (hasChangedTestPaths)
+        return null;
+    const detail = ensurePublicSafeText(`Changed paths include ${codePaths.length} code file(s) without accompanying test evidence.`, "Code changes were detected without accompanying test evidence.");
+    const action = ensurePublicSafeText("Add focused regression tests or explain why existing coverage is sufficient.", "Add focused tests or explain why existing coverage is sufficient.");
+    return {
+        code: "missing_test_evidence",
+        title: "Code changes lack test evidence",
+        severity: "warning",
+        detail,
+        action,
+        publicText: detail,
+    };
+}
+export function buildTrivialWhitespaceChurnFinding(input) {
+    const changedFiles = input.changedFiles ?? [];
+    const lineTotals = summarizeChangedLines(changedFiles);
+    if (lineTotals.changedLineCount < MIN_CHURN_LINES)
+        return null;
+    const substantiveLineCount = lineTotals.sourceLineCount + lineTotals.testLineCount;
+    if (substantiveLineCount === 0) {
+        return buildTrivialChurnFinding(lineTotals.changedLineCount, lineTotals.nonCodeLineCount);
+    }
+    const substantiveShare = substantiveLineCount / lineTotals.changedLineCount;
+    if (substantiveShare > MAX_SOURCE_LINE_SHARE)
+        return null;
+    return buildTrivialChurnFinding(lineTotals.changedLineCount, lineTotals.nonCodeLineCount);
+}
+function summarizeChangedLines(changedFiles) {
+    const changedLineCount = changedFiles.reduce((sum, file) => sum + nonNegative(file.additions) + nonNegative(file.deletions), 0);
+    const sourceLineCount = changedFiles
+        .filter((file) => isCodeFile(file.path))
+        .reduce((sum, file) => sum + nonNegative(file.additions) + nonNegative(file.deletions), 0);
+    const testLineCount = changedFiles
+        .filter((file) => isTestFile(file.path))
+        .reduce((sum, file) => sum + nonNegative(file.additions) + nonNegative(file.deletions), 0);
+    const nonCodeLineCount = Math.max(0, changedLineCount - sourceLineCount - testLineCount);
+    return { changedLineCount, sourceLineCount, testLineCount, nonCodeLineCount };
+}
+function buildTrivialChurnFinding(changedLineCount, nonCodeLineCount) {
+    const detail = ensurePublicSafeText(`The diff churns ${changedLineCount} line(s) with only ${Math.max(0, changedLineCount - nonCodeLineCount)} substantive source line(s) touched.`, "The diff shows high churn with minimal substantive source changes.");
+    const action = ensurePublicSafeText("Reduce whitespace-only or formatting-only churn and keep the diff focused on substantive changes.", "Reduce formatting-only churn and keep the diff focused on substantive changes.");
+    return {
+        code: "trivial_whitespace_churn",
+        title: "Diff looks like trivial or whitespace-only churn",
+        severity: "warning",
+        detail,
+        action,
+        publicText: detail,
+    };
+}
+function nonNegative(value) {
+    // `Number.isFinite` already excludes undefined/NaN/Infinity, so by the time the right operand of `&&`
+    // evaluates, `value` is guaranteed to be a real finite number — no `?? 0` fallback is reachable here.
+    return Number.isFinite(value) && value > 0 ? Math.trunc(value) : 0;
+}
+function ensurePublicSafeText(text, fallback) {
+    // Defense-in-depth: every current call site interpolates only integer counts (see e.g.
+    // buildPaddingFinding's own comment), which can never fail isFocusManifestPublicSafe — the fallback
+    // branch guards against a FUTURE call site interpolating unsafe text, not a reachable case today.
+    /* v8 ignore next */
+    return isFocusManifestPublicSafe(text) ? text : fallback;
+}
+// Documented thresholds (#565, recalibrated by #3939): the deterministic slopRisk (0-100) maps to fixed
+// bands — clean = 0, low = 1-30, elevated = 31-59, high = 60-100.
+// Exported (unlike the other internal helpers above) because `src/signals/slop.ts`'s own issue-side
+// triage (not extracted here — see this file's header) reuses the identical band math and imports it
+// back rather than keeping a duplicate copy.
+export function slopBandFor(slopRisk) {
+    if (slopRisk <= 0)
+        return "clean";
+    if (slopRisk < 31)
+        return "low";
+    if (slopRisk < 60)
+        return "elevated";
+    return "high";
+}
+export function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}

package/dist/signals/test-evidence.d.ts

@@ -0,0 +1,25 @@
+export declare function isTestPath(file: string): boolean;
+/** True iff `file` is a hand-authored program-source file: a recognized source extension that is not itself a
+ *  test file. The single source of truth for every `isCodeFile` in the signals layer, so the source/test
+ *  classifiers can never drift (the same way isCodeFile's `isTestFile` wrappers all delegate to isTestPath). */
+export declare function isSourcePath(file: string): boolean;
+/** cs/swift/groovy/kts plus php, C/C++/Objective-C, vue/svelte/astro, and dart — see isSourcePath for the
+ *  canonical JVM/.NET/Swift/Groovy/Kotlin-script matcher kept symmetric with isTestPath. Generated Dart part
+ *  files (.g.dart/.freezed.dart/.gr.dart) stay non-code (#3724). The single source of truth both the Worker
+ *  (src/signals/path-matchers.ts) and the published @loopover/mcp/gittensory-miner CLIs delegate
+ *  to, so the three previously-independent hand-ports can't silently drift from each other again. */
+export declare function isCodeFile(file: string): boolean;
+export declare function hasLocalTestEvidence(input: {
+    tests?: string[] | undefined;
+    testFiles?: string[] | undefined;
+}): boolean;
+export declare function hasValidationNote(value: string): boolean;
+/**
+ * Coarse classification of how much test coverage accompanies a set of changed paths.
+ * Used by slop signals to weight diffs that touch source but include no tests differently
+ * from those with proportionally strong test changes.
+ */
+export type TestCoverageClassification = "strong" | "adequate" | "weak" | "absent";
+export declare function classifyTestCoverage(changedPaths: string[]): TestCoverageClassification;
+export declare const TEST_FRAMEWORKS: readonly ["vitest", "jest", "pytest", "go-test", "rspec", "cargo-test"];
+export type TestFramework = (typeof TEST_FRAMEWORKS)[number];

package/dist/signals/test-evidence.js

@@ -0,0 +1,108 @@
+export function isTestPath(file) {
+    return (/(^|\/)(test|tests|spec|__tests__)\//i.test(file) ||
+        /(^|\/)src\/test\//i.test(file) ||
+        /(^|\/)[^/]+_test\.(go|py|rb|dart)$/i.test(file) || // Dart/Flutter `foo_test.dart` co-located with source
+        /(^|\/)test_[^/]*\.py$/i.test(file) || // pytest's default `test_*.py` prefix convention (the suffix rule above only catches `*_test.py`)
+        /(^|\/)[^/]+_spec\.rb$/i.test(file) ||
+        /\.(test|spec)\.(ts|tsx|mts|cts|js|jsx|mjs|cjs|py|rb|rs)$/i.test(file) ||
+        /(^|\/)[^/]+\.(cy|e2e)\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/i.test(file) ||
+        // JVM / C# / Swift / PHP `SomethingTest(s)`/`SomethingSpec` class-suffix convention
+        // (JUnit, Kotlin/ScalaTest, Spock, xUnit/NUnit, XCTest, PHPUnit/PHPSpec). Case-sensitive on the
+        // PascalCase suffix so it can't false-positive on words that merely end in
+        // "test"/"spec" (Latest.java, Contest.cs, manifest.scala, Latest.php).
+        /(^|\/)\w*(Tests?|Spec)\.(java|kt|kts|scala|cs|swift|groovy|php)$/.test(file) ||
+        /(^|\/)__snapshots__\//i.test(file));
+}
+// Canonical hand-authored-source extensions — the SOURCE-side sibling of isTestPath's class-suffix rule.
+// The two matchers MUST stay symmetric: isTestPath recognizes java/kt/kts/scala/cs/swift/groovy test files,
+// so this set lists those same languages. Otherwise a C#/Swift/Groovy/Kotlin-script SOURCE change is classified
+// as neither code nor test and silently escapes both the missing-tests gate signals and token scoring.
+const SOURCE_FILE_EXTENSION = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs|py|rb|rs|kt|kts|scala|java|cs|swift|groovy|go|sql)$/i;
+/** True iff `file` is a hand-authored program-source file: a recognized source extension that is not itself a
+ *  test file. The single source of truth for every `isCodeFile` in the signals layer, so the source/test
+ *  classifiers can never drift (the same way isCodeFile's `isTestFile` wrappers all delegate to isTestPath). */
+export function isSourcePath(file) {
+    return SOURCE_FILE_EXTENSION.test(file) && !isTestPath(file);
+}
+// Extensions recognized as code outside isSourcePath's core set (php, native, front-end frameworks, Dart).
+// isSourcePath owns the JVM/.NET/Swift/Groovy/Kotlin-script set symmetric with isTestPath.
+const EXTENDED_SOURCE_EXTENSION = /\.(php|cpp|cc|c|h|hpp|m|vue|svelte|astro|dart)$/i;
+/** cs/swift/groovy/kts plus php, C/C++/Objective-C, vue/svelte/astro, and dart — see isSourcePath for the
+ *  canonical JVM/.NET/Swift/Groovy/Kotlin-script matcher kept symmetric with isTestPath. Generated Dart part
+ *  files (.g.dart/.freezed.dart/.gr.dart) stay non-code (#3724). The single source of truth both the Worker
+ *  (src/signals/path-matchers.ts) and the published @loopover/mcp/gittensory-miner CLIs delegate
+ *  to, so the three previously-independent hand-ports can't silently drift from each other again. */
+export function isCodeFile(file) {
+    if (isSourcePath(file))
+        return true;
+    return EXTENDED_SOURCE_EXTENSION.test(file) && !isTestPath(file) && !/\.(g|freezed|gr)\.dart$/i.test(file);
+}
+export function hasLocalTestEvidence(input) {
+    return (input.tests ?? []).length > 0 || (input.testFiles ?? []).some((file) => isTestPath(file));
+}
+// A body can mention testing without having actually done it ("No tests run", "Tests not run", "Not
+// tested locally", "did not run any tests") -- the affirmative keyword match below would otherwise treat
+// that as passing evidence and let a configured manifest test expectation silently disappear. Rather than
+// enumerate ever more literal phrase templates (which a previous version of this function tried, and which
+// still missed "Not tested" because its test-noun list didn't include the verb form "tested"), detect
+// negation by PROXIMITY: a negation word within a few words of a test/validation stem, in either order,
+// with a shared stem definition so the "is this a test/validation mention at all" question is answered
+// exactly once. The filler between the negation word and the stem may not cross a clause/sentence boundary
+// (a comma, period, exclamation mark, or question mark), so an unrelated "not" earlier in the body (e.g.
+// "This is not a breaking change. Tested with npm run test:ci.") cannot suppress a later, unrelated
+// affirmative note. A colon, semicolon, or dash is deliberately NOT a hard boundary here -- see
+// LABEL_SEPARATOR_GAP below.
+const TEST_STEM = "(?:test(?:ed|s|ing)?|validat(?:ion|ed)|verif(?:y|ied|ying)|manual check|smoke(?:\\s+tests?)?)";
+const NEGATION_WORD = "(?:no|not|never|without|skip(?:ped)?|didn't|doesn't|isn't|wasn't|weren't|haven't|hasn't)";
+const NEGATION_CONTINUATION = "(?:not|never|failed|failing|skipped|incomplete)";
+const SAME_SENTENCE_FILLER_WORD = "[^\\s.,!?;]+";
+// A label-style status line often glues its separator directly onto the negation word or stem with no
+// surrounding whitespace ("Tests: not run.", "Validation; skipped.", "Tests - not run."). The plain
+// `\s+` gap below would never match across that punctuation, so the negation went undetected and the
+// bare "Tests"/"Validation" keyword fell through to the affirmative check instead (#3304, round 4).
+// Allow ONE label separator (colon, semicolon, or a hyphen/en-dash/em-dash) with any trailing
+// whitespace to stand in for the mandatory whitespace, but only at the junction touching the negation
+// word or stem itself -- every other gap between filler words stays pure whitespace, so a label
+// separator elsewhere in the sentence still cannot let a negation reach across unrelated content (the
+// filler-word bound below already exists for exactly this reason).
+const LABEL_SEPARATOR_GAP = "(?:\\s+|[:;\\-\\u2013\\u2014]\\s*)";
+const NEGATES_BEFORE_TEST_STEM = new RegExp(`\\b${NEGATION_WORD}\\b${LABEL_SEPARATOR_GAP}(?:${SAME_SENTENCE_FILLER_WORD}\\s+){0,3}${TEST_STEM}\\b`, "i");
+const NEGATES_AFTER_TEST_STEM = new RegExp(`\\b${TEST_STEM}\\b${LABEL_SEPARATOR_GAP}(?:${SAME_SENTENCE_FILLER_WORD}\\s+){0,2}${NEGATION_CONTINUATION}\\b`, "i");
+// A compound negated adjective with no separating whitespace at all ("untested", "unvalidated", "unverified").
+const NEGATES_TEST_STEM_PREFIX = /\bun(?:tested|validated|verified)\b/i;
+const AFFIRMATIVE_TEST_MENTION = /\b(test(?:ed|s|ing)?|validation|validated|verified|manual check|smoke|pytest|vitest|npm test|pnpm test|cargo test|go test)\b/i;
+// A body can contain BOTH a genuine negated clause ("No tests run locally.") and a separate, later clause
+// with real affirmative evidence ("Validated with npm run test:ci.") -- evaluating the negation checks
+// against the WHOLE body would let the first clause veto the second, discarding real evidence the manifest
+// gate is specifically trying to detect (#3304, round 3). Split on the same clause-boundary punctuation the
+// proximity checks already treat as a hard stop -- colon/semicolon/dash are excluded here on purpose
+// (#3304, round 4): they are typically a label separator glued directly onto the word on either side
+// ("Tests: not run."), and splitting on them would sever the stem from its own negation before the
+// proximity checks ever run, the same way the round-3 bug worked one level up. Require at least one
+// clause to be an affirmative, non-negated mention -- so an earlier honest "no tests" disclosure can no
+// longer suppress later evidence.
+export function hasValidationNote(value) {
+    return value
+        .split(/[.,!?]+/)
+        .some((clause) => !NEGATES_TEST_STEM_PREFIX.test(clause) &&
+        !NEGATES_BEFORE_TEST_STEM.test(clause) &&
+        !NEGATES_AFTER_TEST_STEM.test(clause) &&
+        AFFIRMATIVE_TEST_MENTION.test(clause));
+}
+export function classifyTestCoverage(changedPaths) {
+    if (changedPaths.length === 0)
+        return "absent";
+    const testCount = changedPaths.filter(isTestPath).length;
+    if (testCount === 0)
+        return "absent";
+    const ratio = testCount / changedPaths.length;
+    if (ratio >= 0.4)
+        return "strong";
+    if (ratio >= 0.2)
+        return "adequate";
+    return "weak";
+}
+// #2187 (foundational slice of #1972 — boundary-safe test generation): a small, precise framework list.
+// Consumed by the MCP test-gen tool's enum (src/mcp/server.ts testGenShape) so a caller cannot request a
+// spec for a framework this engine doesn't recognize.
+export const TEST_FRAMEWORKS = ["vitest", "jest", "pytest", "go-test", "rspec", "cargo-test"];

package/dist/subprocess-env.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The standard env-var allowlist for a locally-authenticated CLI subprocess: home + proxy + TLS-cert + locale +
+ * XDG config paths, so the CLI keeps its own auth/proxy/cert settings, but nothing else (no runtime secrets) leaks
+ * in. A caller that needs a different/larger set (e.g. a coding-agent driver) passes its own list to
+ * {@link buildAllowlistedEnv} rather than editing this one.
+ */
+export declare const SUBPROCESS_CLI_ENV_ALLOWLIST: readonly ["HOME", "HTTPS_PROXY", "HTTP_PROXY", "LANG", "LC_ALL", "NODE_EXTRA_CA_CERTS", "NO_PROXY", "PATH", "SSL_CERT_DIR", "SSL_CERT_FILE", "TERM", "XDG_CONFIG_HOME", "XDG_DATA_HOME", "XDG_STATE_HOME", "https_proxy", "http_proxy", "no_proxy"];
+/**
+ * Build a child-process env by copying ONLY `allowlist` keys from `parent`, then overlaying `extra`. Parameterized
+ * (the allowlist is a caller argument, not hardcoded) so different subprocess kinds can use different allowlists.
+ * `undefined` values are dropped from both sources; `extra` wins over an allowlisted parent value for the same key.
+ * Pure — never reads the ambient process env itself.
+ */
+export declare function buildAllowlistedEnv(parent: Record<string, string | undefined>, allowlist: readonly string[], extra?: Record<string, string | undefined>): Record<string, string | undefined>;
+/** Well-known secret token shapes to strip from untrusted subprocess output. Ported verbatim from
+ *  src/selfhost/ai.ts (`SECRET_PATTERNS`) — keep the two in sync (or shim ai.ts onto this) rather than weakening. */
+export declare const SECRET_PATTERNS: readonly RegExp[];
+/**
+ * Redact secrets from untrusted subprocess output before it flows to logs/Sentry: strip each caller-supplied known
+ * secret value exactly (length-guarded so a short/empty token can't blank unrelated text), then well-known token
+ * shapes ({@link SECRET_PATTERNS}). Ported from src/selfhost/ai.ts's `redactSecrets`. Pure.
+ */
+export declare function redactSecrets(text: string, knownSecrets?: readonly string[]): string;

package/dist/subprocess-env.js

@@ -0,0 +1,74 @@
+// Shared subprocess env-allowlist + secret-redaction helpers (#4284). Any driver that spawns a locally-authenticated
+// CLI (the review `claude`/`codex` subprocess in src/selfhost/ai.ts, and the coding-agent drivers coming in
+// gittensory-miner) needs the SAME two safety primitives: hand the child a STRICT allowlisted env (never the full
+// worker/host env, which can carry runtime credentials into a prompt-injectable subprocess), and redact well-known
+// secret shapes out of the child's untrusted stderr before it reaches logs. This module is the single engine-hosted
+// source of truth for both, so those callers depend on one implementation instead of copy-pasting the pattern.
+/**
+ * The standard env-var allowlist for a locally-authenticated CLI subprocess: home + proxy + TLS-cert + locale +
+ * XDG config paths, so the CLI keeps its own auth/proxy/cert settings, but nothing else (no runtime secrets) leaks
+ * in. A caller that needs a different/larger set (e.g. a coding-agent driver) passes its own list to
+ * {@link buildAllowlistedEnv} rather than editing this one.
+ */
+export const SUBPROCESS_CLI_ENV_ALLOWLIST = [
+    "HOME",
+    "HTTPS_PROXY",
+    "HTTP_PROXY",
+    "LANG",
+    "LC_ALL",
+    "NODE_EXTRA_CA_CERTS",
+    "NO_PROXY",
+    "PATH",
+    "SSL_CERT_DIR",
+    "SSL_CERT_FILE",
+    "TERM",
+    "XDG_CONFIG_HOME",
+    "XDG_DATA_HOME",
+    "XDG_STATE_HOME",
+    "https_proxy",
+    "http_proxy",
+    "no_proxy",
+];
+/**
+ * Build a child-process env by copying ONLY `allowlist` keys from `parent`, then overlaying `extra`. Parameterized
+ * (the allowlist is a caller argument, not hardcoded) so different subprocess kinds can use different allowlists.
+ * `undefined` values are dropped from both sources; `extra` wins over an allowlisted parent value for the same key.
+ * Pure — never reads the ambient process env itself.
+ */
+export function buildAllowlistedEnv(parent, allowlist, extra = {}) {
+    const child = {};
+    for (const key of allowlist) {
+        const value = parent[key];
+        if (value !== undefined)
+            child[key] = value;
+    }
+    for (const [key, value] of Object.entries(extra)) {
+        if (value !== undefined)
+            child[key] = value;
+    }
+    return child;
+}
+/** Well-known secret token shapes to strip from untrusted subprocess output. Ported verbatim from
+ *  src/selfhost/ai.ts (`SECRET_PATTERNS`) — keep the two in sync (or shim ai.ts onto this) rather than weakening. */
+export const SECRET_PATTERNS = [
+    /\bsk-[A-Za-z0-9_-]{16,}/g, // OpenAI / Anthropic keys (sk-..., sk-ant-..., sk-proj-...)
+    /\bgh[oprsu]_[A-Za-z0-9]{20,}/g, // GitHub PAT / OAuth / server / refresh tokens
+    /\bgithub_pat_[A-Za-z0-9_]{20,}/g, // GitHub fine-grained PAT
+    /\beyJ[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,}/g, // JWT (header.payload.signature)
+    /\bAKIA[0-9A-Z]{16}/g, // AWS access key id
+];
+/**
+ * Redact secrets from untrusted subprocess output before it flows to logs/Sentry: strip each caller-supplied known
+ * secret value exactly (length-guarded so a short/empty token can't blank unrelated text), then well-known token
+ * shapes ({@link SECRET_PATTERNS}). Ported from src/selfhost/ai.ts's `redactSecrets`. Pure.
+ */
+export function redactSecrets(text, knownSecrets = []) {
+    let out = text;
+    for (const secret of knownSecrets) {
+        if (secret.length >= 8)
+            out = out.split(secret).join("[redacted]");
+    }
+    for (const pattern of SECRET_PATTERNS)
+        out = out.replace(pattern, "[redacted]");
+    return out;
+}