@martinloop/mcp 0.3.5 → 0.3.7

package/dist/vendor/core/repo-analyzer.js

@@ -0,0 +1,263 @@
+/**
+ * Repo Style Analyzer
+ *
+ * Scans a repository to detect coding conventions, patterns, and style
+ * so that governed agent runs produce code matching the existing codebase.
+ *
+ * Detects:
+ * - Naming conventions (camelCase, snake_case, PascalCase, kebab-case)
+ * - Test framework (Vitest, Jest, Mocha, node:test)
+ * - Package manager (pnpm, npm, yarn, bun)
+ * - Module system (ESM, CJS, mixed)
+ * - File organization pattern (feature folders, type folders, flat)
+ * - TypeScript strictness level
+ * - Comment density
+ * - Formatting (tabs vs spaces, semicolons, quotes)
+ */
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join, extname } from "node:path";
+/**
+ * Analyze a repository and return a style profile.
+ */
+export function analyzeRepoStyle(rootDir) {
+    const profile = {
+        packageManager: detectPackageManager(rootDir),
+        moduleSystem: detectModuleSystem(rootDir),
+        testFramework: detectTestFramework(rootDir),
+        language: detectLanguage(rootDir),
+        typescriptStrict: detectTypeScriptStrict(rootDir),
+        fileNaming: "kebab-case",
+        codeNaming: "camelCase",
+        semicolons: true,
+        quotes: "double",
+        indentation: "2-spaces",
+        avgLinesPerFile: 0,
+        organization: "mixed",
+        promptDirectives: []
+    };
+    // Sample source files for style detection
+    const sourceFiles = collectSourceFiles(rootDir, 50);
+    if (sourceFiles.length > 0) {
+        const styleSignals = analyzeSourceFiles(sourceFiles);
+        profile.fileNaming = styleSignals.fileNaming;
+        profile.codeNaming = styleSignals.codeNaming;
+        profile.semicolons = styleSignals.semicolons;
+        profile.quotes = styleSignals.quotes;
+        profile.indentation = styleSignals.indentation;
+        profile.avgLinesPerFile = styleSignals.avgLinesPerFile;
+    }
+    profile.organization = detectOrganization(rootDir);
+    profile.promptDirectives = buildPromptDirectives(profile);
+    return profile;
+}
+function detectPackageManager(rootDir) {
+    if (existsSync(join(rootDir, "pnpm-lock.yaml")))
+        return "pnpm";
+    if (existsSync(join(rootDir, "bun.lockb")) || existsSync(join(rootDir, "bun.lock")))
+        return "bun";
+    if (existsSync(join(rootDir, "yarn.lock")))
+        return "yarn";
+    if (existsSync(join(rootDir, "package-lock.json")))
+        return "npm";
+    return "unknown";
+}
+function detectModuleSystem(rootDir) {
+    const pkgPath = join(rootDir, "package.json");
+    if (!existsSync(pkgPath))
+        return "unknown";
+    try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        if (pkg.type === "module")
+            return "esm";
+        if (pkg.type === "commonjs")
+            return "cjs";
+    }
+    catch { /* ignore */ }
+    return "unknown";
+}
+function detectTestFramework(rootDir) {
+    const pkgPath = join(rootDir, "package.json");
+    if (!existsSync(pkgPath))
+        return "unknown";
+    try {
+        const raw = readFileSync(pkgPath, "utf8");
+        if (raw.includes("vitest"))
+            return "vitest";
+        if (raw.includes("jest"))
+            return "jest";
+        if (raw.includes("mocha"))
+            return "mocha";
+        if (raw.includes("node:test"))
+            return "node-test";
+    }
+    catch { /* ignore */ }
+    if (existsSync(join(rootDir, "vitest.config.ts")) || existsSync(join(rootDir, "vitest.config.js")))
+        return "vitest";
+    if (existsSync(join(rootDir, "jest.config.ts")) || existsSync(join(rootDir, "jest.config.js")))
+        return "jest";
+    return "unknown";
+}
+function detectLanguage(rootDir) {
+    if (existsSync(join(rootDir, "tsconfig.json")) ||
+        existsSync(join(rootDir, "tsconfig.base.json")) ||
+        existsSync(join(rootDir, "tsconfig.build.json"))) {
+        return "typescript";
+    }
+    return "javascript";
+}
+function detectTypeScriptStrict(rootDir) {
+    const candidates = ["tsconfig.json", "tsconfig.base.json", "tsconfig.build.json"];
+    for (const candidate of candidates) {
+        const tsConfigPath = join(rootDir, candidate);
+        if (!existsSync(tsConfigPath))
+            continue;
+        try {
+            const raw = readFileSync(tsConfigPath, "utf8");
+            if (raw.includes('"strict": true') || raw.includes('"strict":true'))
+                return true;
+        }
+        catch { /* skip */ }
+    }
+    return false;
+}
+function collectSourceFiles(rootDir, limit) {
+    const results = [];
+    const extensions = new Set([".ts", ".tsx", ".js", ".jsx"]);
+    function walk(dir, depth) {
+        if (depth > 5 || results.length >= limit)
+            return;
+        try {
+            const entries = readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (results.length >= limit)
+                    return;
+                if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist")
+                    continue;
+                const fullPath = join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    walk(fullPath, depth + 1);
+                }
+                else if (entry.isFile() && extensions.has(extname(entry.name))) {
+                    results.push(fullPath);
+                }
+            }
+        }
+        catch { /* skip */ }
+    }
+    walk(rootDir, 0);
+    return results;
+}
+function analyzeSourceFiles(files) {
+    let semiCount = 0;
+    let noSemiCount = 0;
+    let singleQuoteCount = 0;
+    let doubleQuoteCount = 0;
+    let tabCount = 0;
+    let twoSpaceCount = 0;
+    let fourSpaceCount = 0;
+    let totalLines = 0;
+    for (const filePath of files) {
+        try {
+            const content = readFileSync(filePath, "utf8");
+            const lines = content.split("\n");
+            totalLines += lines.length;
+            for (const line of lines.slice(0, 100)) {
+                if (line.trimEnd().endsWith(";"))
+                    semiCount++;
+                else if (line.trim().length > 0)
+                    noSemiCount++;
+                if (/'\w/.test(line))
+                    singleQuoteCount++;
+                if (/"\w/.test(line))
+                    doubleQuoteCount++;
+                if (line.startsWith("\t"))
+                    tabCount++;
+                else if (line.startsWith("  ") && !line.startsWith("    "))
+                    twoSpaceCount++;
+                else if (line.startsWith("    "))
+                    fourSpaceCount++;
+            }
+        }
+        catch { /* skip */ }
+    }
+    const semicolons = semiCount > noSemiCount;
+    const quotes = singleQuoteCount > doubleQuoteCount * 2 ? "single" :
+        doubleQuoteCount > singleQuoteCount * 2 ? "double" : "mixed";
+    const indentation = tabCount > twoSpaceCount + fourSpaceCount ? "tabs" :
+        twoSpaceCount > fourSpaceCount * 2 ? "2-spaces" :
+            fourSpaceCount > twoSpaceCount * 2 ? "4-spaces" : "mixed";
+    return {
+        fileNaming: "kebab-case", // Default, hard to detect reliably without more files
+        codeNaming: "camelCase", // TypeScript default
+        semicolons,
+        quotes,
+        indentation,
+        avgLinesPerFile: files.length > 0 ? Math.round(totalLines / files.length) : 0
+    };
+}
+function detectOrganization(rootDir) {
+    const srcDir = join(rootDir, "src");
+    if (!existsSync(srcDir))
+        return "flat";
+    try {
+        const entries = readdirSync(srcDir, { withFileTypes: true });
+        const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+        const hasFeatureDirs = dirs.some((d) => !["utils", "lib", "types", "helpers", "common", "shared", "__tests__", "tests"].includes(d));
+        const hasTypeDirs = dirs.some((d) => ["components", "hooks", "services", "models", "controllers", "routes", "middleware"].includes(d));
+        if (hasFeatureDirs && !hasTypeDirs)
+            return "feature-folders";
+        if (hasTypeDirs && !hasFeatureDirs)
+            return "type-folders";
+        if (hasFeatureDirs && hasTypeDirs)
+            return "mixed";
+    }
+    catch { /* skip */ }
+    return "flat";
+}
+/**
+ * Build prompt directives from the style profile.
+ * These get injected into the agent's prompt to match repo conventions.
+ */
+export function buildPromptDirectives(profile) {
+    const directives = [];
+    if (profile.language === "typescript") {
+        directives.push("Write TypeScript, not JavaScript.");
+        if (profile.typescriptStrict) {
+            directives.push("TypeScript strict mode is enabled. Use explicit types, avoid any.");
+        }
+    }
+    if (profile.moduleSystem === "esm") {
+        directives.push("Use ES module imports (import/export), not require().");
+    }
+    else if (profile.moduleSystem === "cjs") {
+        directives.push("Use CommonJS (require/module.exports), not ES module imports.");
+    }
+    if (profile.testFramework !== "unknown") {
+        directives.push(`Use ${profile.testFramework} for tests. Do not introduce a different test framework.`);
+    }
+    if (profile.semicolons) {
+        directives.push("Use semicolons at the end of statements.");
+    }
+    else {
+        directives.push("Do not use semicolons at the end of statements.");
+    }
+    if (profile.quotes === "single") {
+        directives.push("Use single quotes for strings.");
+    }
+    else if (profile.quotes === "double") {
+        directives.push("Use double quotes for strings.");
+    }
+    if (profile.indentation === "tabs") {
+        directives.push("Use tabs for indentation.");
+    }
+    else if (profile.indentation === "2-spaces") {
+        directives.push("Use 2-space indentation.");
+    }
+    else if (profile.indentation === "4-spaces") {
+        directives.push("Use 4-space indentation.");
+    }
+    if (profile.packageManager !== "unknown") {
+        directives.push(`This project uses ${profile.packageManager}. Do not use other package managers.`);
+    }
+    return directives;
+}

package/dist/vendor/core/rollback.js

@@ -29,12 +29,11 @@ export async function captureRollbackBoundary(input) {
     for (const filePath of snapshotPaths) {
         snapshots.push(await readRollbackSnapshot(input.repoRoot, filePath));
     }
+    const headRef = readGitScalar(input.repoRoot, ["rev-parse", "HEAD"]);
     return {
         strategy: "git_head_plus_snapshot",
         capturedAt: input.capturedAt,
-        ...(readGitScalar(input.repoRoot, ["rev-parse", "HEAD"])
-            ? { headRef: readGitScalar(input.repoRoot, ["rev-parse", "HEAD"]) }
-            : {}),
+        ...(headRef ? { headRef } : {}),
         trackedDirtyFiles: repoState.trackedDirtyFiles,
         untrackedFiles: repoState.untrackedFiles,
         snapshots

package/dist/vendor/core/routing.d.ts

@@ -15,6 +15,14 @@ export interface RouteDecision {
     blockedSteps: string[];
     compressed: boolean;
     compressionSummary?: string;
+    /**
+     * Recommended model tier based on task complexity and route.
+     * Follows cost-aware routing: direct → haiku/sonnet, manager → sonnet,
+     * consensus → opus. Never use a more expensive model than the task needs.
+     */
+    recommendedModelTier: "haiku" | "sonnet" | "opus";
+    /** Estimated cost saving vs always using sonnet */
+    estimatedSavingVsSonnetUsd: number;
 }
 export interface RouteClassificationInput {
     objective: string;
@@ -29,6 +37,40 @@ export interface RouteClassificationInput {
     /** Historical success rate for similar tasks with direct execution (0-1). */
     historicalDirectSuccessRate?: number;
 }
+/**
+ * Resolve a tier to a concrete model ID for a specific engine.
+ * Allows downstream adapters to switch models automatically.
+ */
+export declare function resolveModelForTier(tier: RouteDecision["recommendedModelTier"], engine: "claude" | "codex" | "gemini" | "openai" | string): string;
+/**
+ * Available engine registry — describes what's installed and its capability.
+ * Populated by doctor/preflight from PATH and env var detection.
+ */
+export interface AvailableEngine {
+    id: string;
+    available: boolean;
+    /** Cost tier: cheap < mid < expensive */
+    costTier: "cheap" | "mid" | "expensive";
+    /** Capability tier: determines which task types this engine can handle */
+    capabilityTier: "haiku" | "sonnet" | "opus";
+}
+/**
+ * Select the best available engine for a given tier requirement.
+ *
+ * When multiple engines are available, picks the cheapest that meets
+ * the capability requirement. Falls back gracefully:
+ * - If required tier unavailable, upgrades to next tier of same engine
+ * - If only one engine family available, uses its best equivalent
+ *
+ * @param requiredTier - Minimum capability tier needed
+ * @param availableEngines - What's installed and authenticated
+ * @returns Best engine ID and concrete model to use
+ */
+export declare function selectBestEngine(requiredTier: RouteDecision["recommendedModelTier"], availableEngines: AvailableEngine[]): {
+    engineId: string;
+    model: string;
+    reasoning: string;
+};
 export declare function classifyRoute(input: RouteClassificationInput): RouteDecision;
 /**
  * Checks whether a run's Pre Work Burn exceeds the routing policy limits.

package/dist/vendor/core/routing.js

@@ -84,6 +84,144 @@ function calculateDirectConfidence(signals, input) {
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Cost-aware model tier routing
+//
+// Engine-agnostic tier system — each engine maps tiers to real model IDs.
+// Never pay for reasoning/orchestration on simple tasks.
+//
+// Tier → concrete model per engine:
+//   haiku  → claude-haiku-4-5, gpt-4o-mini, gemini-2.5-flash, deepseek-chat, qwen3-8b,  llama-3.1-8b
+//   sonnet → claude-sonnet-4-6, gpt-4o,     gemini-2.5-pro,  deepseek-r1,   qwen3-32b, llama-3.3-70b
+//   opus   → claude-opus-4-6,  o3,          gemini-2.5-ultra, deepseek-r1-671b, qwen3-235b, llama-3.1-405b
+//
+// Pricing reference (USD per 1M tokens, approx 2026):
+//   haiku:  $0.80 input / $4.00 output  (~1x baseline)
+//   sonnet: $3.00 input / $15.00 output (~4x haiku)
+//   opus:   $15.00 input / $75.00 output (~19x haiku)
+// ---------------------------------------------------------------------------
+const SONNET_AVG_COST_PER_USD_BUDGET = 0.35; // sonnet uses ~35% of budget on average
+const HAIKU_AVG_COST_PER_USD_BUDGET = 0.10; // haiku uses ~10% — ~3.5x cheaper
+function selectModelTier(mode) {
+    // Route already encodes complexity. Direct = passed the simplicity check → haiku.
+    if (mode === "direct")
+        return "haiku";
+    if (mode === "manager")
+        return "sonnet";
+    return "opus";
+}
+/**
+ * Resolve a tier to a concrete model ID for a specific engine.
+ * Allows downstream adapters to switch models automatically.
+ */
+export function resolveModelForTier(tier, engine) {
+    const matrix = {
+        claude: {
+            haiku: "claude-haiku-4-5-20251001",
+            sonnet: "claude-sonnet-4-6",
+            opus: "claude-opus-4-6"
+        },
+        codex: {
+            haiku: "gpt-4o-mini",
+            sonnet: "gpt-4.1",
+            opus: "o3"
+        },
+        gemini: {
+            haiku: "gemini-2.5-flash",
+            sonnet: "gemini-2.5-pro",
+            opus: "gemini-2.5-ultra"
+        },
+        openai: {
+            haiku: "gpt-4o-mini",
+            sonnet: "gpt-4o",
+            opus: "o3"
+        },
+        deepseek: {
+            haiku: "deepseek-chat",
+            sonnet: "deepseek-r1",
+            opus: "deepseek-r1"
+        },
+        qwen: {
+            haiku: "qwen/qwen3-8b",
+            sonnet: "qwen/qwen3-32b",
+            opus: "qwen/qwen3-235b-a22b"
+        },
+        llama: {
+            haiku: "meta-llama/llama-3.1-8b-instruct",
+            sonnet: "meta-llama/llama-3.3-70b-instruct",
+            opus: "meta-llama/llama-3.1-405b-instruct"
+        }
+    };
+    const engineKey = engine.toLowerCase().split("-")[0] ?? engine;
+    const claudeMatrix = matrix.claude;
+    return matrix[engineKey]?.[tier] ?? claudeMatrix?.[tier] ?? "claude-sonnet-4-6";
+}
+function estimateSavingVsSonnet(tier, budgetUsd) {
+    if (tier === "sonnet")
+        return 0;
+    if (tier === "haiku")
+        return Math.round((SONNET_AVG_COST_PER_USD_BUDGET - HAIKU_AVG_COST_PER_USD_BUDGET) * budgetUsd * 100) / 100;
+    // opus costs more than sonnet — negative saving
+    return Math.round(-1 * SONNET_AVG_COST_PER_USD_BUDGET * budgetUsd * 0.5 * 100) / 100;
+}
+/**
+ * Select the best available engine for a given tier requirement.
+ *
+ * When multiple engines are available, picks the cheapest that meets
+ * the capability requirement. Falls back gracefully:
+ * - If required tier unavailable, upgrades to next tier of same engine
+ * - If only one engine family available, uses its best equivalent
+ *
+ * @param requiredTier - Minimum capability tier needed
+ * @param availableEngines - What's installed and authenticated
+ * @returns Best engine ID and concrete model to use
+ */
+export function selectBestEngine(requiredTier, availableEngines) {
+    const available = availableEngines.filter((e) => e.available);
+    if (available.length === 0) {
+        // Nothing detected — default to claude (user must install)
+        return {
+            engineId: "claude",
+            model: resolveModelForTier(requiredTier, "claude"),
+            reasoning: "No engines detected. Defaulting to claude. Run martin doctor for setup instructions."
+        };
+    }
+    const tierRank = {
+        haiku: 0, sonnet: 1, opus: 2
+    };
+    const requiredRank = tierRank[requiredTier];
+    // Find the cheapest engine that meets or exceeds the required tier
+    const eligible = available
+        .filter((e) => tierRank[e.capabilityTier] >= requiredRank)
+        .sort((a, b) => {
+        // Sort by cost (cheap first), then by exact tier match
+        const costOrder = { cheap: 0, mid: 1, expensive: 2 };
+        if (costOrder[a.costTier] !== costOrder[b.costTier]) {
+            return costOrder[a.costTier] - costOrder[b.costTier];
+        }
+        // Prefer exact tier match over overqualified
+        const aExact = a.capabilityTier === requiredTier ? 0 : 1;
+        const bExact = b.capabilityTier === requiredTier ? 0 : 1;
+        return aExact - bExact;
+    });
+    if (eligible.length > 0) {
+        const best = eligible[0];
+        const model = resolveModelForTier(requiredTier, best.id);
+        return {
+            engineId: best.id,
+            model,
+            reasoning: `Selected ${best.id} (${model}) as cheapest available engine for ${requiredTier}-tier task.`
+        };
+    }
+    // All available engines are below required tier — upgrade to best available
+    const best = available.sort((a, b) => tierRank[b.capabilityTier] - tierRank[a.capabilityTier])[0];
+    const model = resolveModelForTier(best.capabilityTier, best.id);
+    return {
+        engineId: best.id,
+        model,
+        reasoning: `No ${requiredTier}-tier engine available. Upgrading to ${best.id} (${model}) — best available.`
+    };
+}
 export function classifyRoute(input) {
     const policy = { ...DEFAULT_ROUTING_POLICY, ...input.policy };
     const signals = extractComplexitySignals(input);
@@ -92,6 +230,7 @@ export function classifyRoute(input) {
     const blockedSteps = [];
     // Policy override: forced mode
     if (policy.mode === "direct") {
+        const tier = selectModelTier("direct");
         return {
             selectedMode: "direct",
             confidence: 1,
@@ -100,10 +239,13 @@ export function classifyRoute(input) {
             reason: ["Policy forces direct execution mode."],
             blockedSteps: ["manager", "planner", "router", "consensus"],
             compressed: true,
-            compressionSummary: "Policy: direct mode — skipping all orchestration."
+            compressionSummary: "Policy: direct mode — skipping all orchestration.",
+            recommendedModelTier: tier,
+            estimatedSavingVsSonnetUsd: estimateSavingVsSonnet(tier, input.budgetUsd)
         };
     }
     if (policy.mode === "consensus") {
+        const tier = selectModelTier("consensus");
         return {
             selectedMode: "consensus",
             confidence: 0.5,
@@ -111,7 +253,9 @@ export function classifyRoute(input) {
             expectedPreworkBurnPct: 35,
             reason: ["Policy forces consensus mode."],
             blockedSteps: [],
-            compressed: false
+            compressed: false,
+            recommendedModelTier: tier,
+            estimatedSavingVsSonnetUsd: estimateSavingVsSonnet(tier, input.budgetUsd)
         };
     }
     // Adaptive routing
@@ -124,6 +268,7 @@ export function classifyRoute(input) {
         if (signals.scopeRestricted)
             reason.push("Path scope is restricted.");
         blockedSteps.push("manager", "consensus");
+        const tier = selectModelTier("direct");
         return {
             selectedMode: "direct",
             confidence: directConfidence,
@@ -132,7 +277,9 @@ export function classifyRoute(input) {
             reason,
             blockedSteps,
             compressed: true,
-            compressionSummary: `Compressed from manager→planner→worker to direct worker. Estimated savings: ${String(Math.round(input.budgetUsd * 0.3 * 100) / 100)} USD.`
+            compressionSummary: `Compressed from manager→planner→worker to direct worker. Estimated savings: ${String(Math.round(input.budgetUsd * 0.3 * 100) / 100)} USD.`,
+            recommendedModelTier: tier,
+            estimatedSavingVsSonnetUsd: estimateSavingVsSonnet(tier, input.budgetUsd)
         };
     }
     // Complex task — needs orchestration
@@ -145,14 +292,18 @@ export function classifyRoute(input) {
     if (signals.fileCount > 5)
         reason.push(`Touches ${String(signals.fileCount)}+ files.`);
     const needsConsensus = signals.hasSecurityKeywords && signals.hasMigrationKeywords;
+    const mode = needsConsensus ? "consensus" : "manager";
+    const tier = selectModelTier(mode);
     return {
-        selectedMode: needsConsensus ? "consensus" : "manager",
+        selectedMode: mode,
         confidence: directConfidence,
         expectedCostUsd: input.budgetUsd * (needsConsensus ? 0.8 : 0.6),
         expectedPreworkBurnPct: needsConsensus ? 40 : 25,
         reason,
         blockedSteps: needsConsensus ? [] : ["consensus"],
-        compressed: false
+        compressed: false,
+        recommendedModelTier: tier,
+        estimatedSavingVsSonnetUsd: estimateSavingVsSonnet(tier, input.budgetUsd)
     };
 }
 function estimateDirectCost(budgetUsd) {

package/dist/vendor/core/test-integrity.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Test Integrity Validator
+ *
+ * Detects circular test validation — the problem where AI agents generate
+ * tests that only pass because they test the agent's own output, not real
+ * behavior. A test that passes on both the pre-change and post-change
+ * codebase proves nothing about the change.
+ *
+ * Strategy:
+ * 1. Snapshot which test files existed before the agent ran
+ * 2. After the run, identify NEW test files the agent created
+ * 3. For each new test: check if it imports/references pre-existing code
+ *    (real test) or only references agent-generated code (circular test)
+ * 4. Flag tests that don't exercise any pre-existing function
+ *
+ * This module provides the analysis primitives. The verification pipeline
+ * calls these during the post-run verification step.
+ */
+export interface TestIntegrityReport {
+    totalNewTests: number;
+    realTests: number;
+    suspiciousTests: number;
+    findings: TestIntegrityFinding[];
+    verdict: "pass" | "warn" | "fail";
+    summary: string;
+}
+export interface TestIntegrityFinding {
+    filePath: string;
+    issue: "no_pre_existing_imports" | "self_referential" | "trivial_assertion" | "empty_test";
+    severity: "high" | "medium" | "low";
+    detail: string;
+}
+/**
+ * Detect test files in a directory tree.
+ */
+export declare function findTestFiles(rootDir: string): string[];
+/**
+ * Check if a filename matches test file patterns.
+ */
+export declare function isTestFile(filename: string, fullPath?: string): boolean;
+/**
+ * Snapshot existing test files before an agent run.
+ */
+export declare function snapshotTestFiles(rootDir: string): Set<string>;
+/**
+ * Identify new test files created during an agent run.
+ */
+export declare function identifyNewTests(rootDir: string, preRunSnapshot: Set<string>): string[];
+/**
+ * Extract import paths from a TypeScript/JavaScript file.
+ */
+export declare function extractImports(content: string): string[];
+/**
+ * Check if a test file contains only trivial assertions.
+ */
+export declare function hasTrivialAssertionsOnly(content: string): boolean;
+/**
+ * Check if a test file imports any pre-existing source files.
+ */
+export declare function importsPreExistingCode(testContent: string, preRunSourceFiles: Set<string>): boolean;
+/**
+ * Validate the integrity of tests created during a governed run.
+ */
+export declare function validateTestIntegrity(rootDir: string, preRunTestSnapshot: Set<string>, preRunSourceFiles: Set<string>): TestIntegrityReport;