@stsepelin/checktrail 0.1.0-alpha.3 → 0.1.0-alpha.5

package/README.md

@@ -4,7 +4,7 @@ Local code validation with a CLI, MCP tools, and evidence of what actually ran.
 
 Formerly Repo Verifier. See the [rename guide](docs/RENAMING.md) for existing source checkouts.
 
-**Published preview: 0.1.0-alpha.2; source candidate: 0.1.0-alpha.3.** Public source is available at
+**Published preview: 0.1.0-alpha.4.** Public source is available at
 [stsepelin/checktrail](https://github.com/stsepelin/checktrail).
 See [implementation status](docs/STATUS.md), the [plan](docs/PLAN.md) and the
 [language matrix](docs/LANGUAGES.md) before relying on an adapter.
@@ -18,13 +18,16 @@ and MCP configuration generator.
 acceptance work; [client checks](docs/CLIENTS.md) record actual application coverage.
 [Public adoption](docs/PUBLIC-ADOPTION.md) records the published package on five
 pinned libraries, including setup friction and compatibility gaps.
-The alpha.3 candidate fixes the recorded [TypeScript 4.9.5 incompatibility](docs/TYPESCRIPT.md);
-it has not been published.
-
-The [hosted matrix](https://github.com/stsepelin/checktrail/actions/runs/35590670960)
-passed at release commit `4ce8398` on Linux and macOS. The exact npm tarball and
+Alpha.3 fixes the recorded [TypeScript 4.9.5 incompatibility](docs/TYPESCRIPT.md).
+The [setup scope guide](docs/SETUP-SCOPES.md) explains language, documentation and workflow coverage.
+Alpha.4 adds explicit [Go scope exclusions](docs/GO-SCOPE.md) and matching
+race-test package discovery. Its [release record](docs/measurements/release-alpha4.json)
+includes package, client and upgrade/rollback verification.
+
+The [hosted matrix](https://github.com/stsepelin/checktrail/actions/runs/35603451711)
+passed at release commit `ebe7f5c` on Linux and macOS. The exact npm tarball and
 fresh CLI/MCP installations were verified. The
-[MCP Registry entry](https://registry.modelcontextprotocol.io/v0.1/servers/io.github.stsepelin%2Fchecktrail/versions/0.1.0-alpha.2)
+[MCP Registry entry](https://registry.modelcontextprotocol.io/v0.1/servers/io.github.stsepelin%2Fchecktrail/versions/0.1.0-alpha.4)
 is active; execution remains disabled by default.
 
 Checktrail discovers projects, plans registered checks, invokes native tools
@@ -186,6 +189,9 @@ selection with inventoried source; `go.staticcheck` adds explicit all-rule analy
 and normalized findings. See [Go scope](docs/GO-SCOPE.md). The constrained
 [`go.golangci-lint` profile](docs/GOLANGCI-LINT.md) accepts explicit native linter
 selection while disabling hidden issue filters and fixes.
+The alpha.5 source candidate adds [Go build-tag profiles](docs/GO-BUILD.md)
+with one explicit configuration per selected native check. Alpha.4 does not
+include this capability; a runnable example is in `examples/go-build`.
 
 `php.phpstan` combines per-file analysis accounting with native JSON diagnostics.
 See the [PHPStan contract](docs/PHPSTAN.md).

package/dist/src/adapters.js

@@ -1,3 +1,5 @@
+import { applyGoBuildPolicy } from "./go-build.js";
+import { applyGoScopePolicy } from "./go-scope-policy.js";
 import { actionlintCheck, workflowRoot } from "./actionlint.js";
 import { clangCheck } from "./clang.js";
 import { javaCheck } from "./java.js";
@@ -312,7 +314,7 @@ export async function checksFor(source, project, requested) {
                         ...env,
                         CGO_ENABLED: "1",
                         GORACE: "exitcode=66 log_path=stderr",
-                    }),
+                    }, true),
                     {
                         executable: "go",
                         args: ["test", "-race", "-json", "-count=1", "./..."],
@@ -354,6 +356,8 @@ export async function checksFor(source, project, requested) {
             });
         if (explicit)
             checks.push(await golangciCheck(source, project));
+        await applyGoScopePolicy(source, project, checks);
+        await applyGoBuildPolicy(source, project, checks);
         return checks;
     }
     if (project.adapter === "infrastructure") {

package/dist/src/architecture.d.ts

@@ -78,6 +78,7 @@ export declare const architectureReportSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const architectureSummarySchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
+    reason: z.ZodString;
     engineVersion: z.ZodString;
     provenance: z.ZodLiteral<"imported-dependency-graph">;
     outcome: z.ZodEnum<{
@@ -85,7 +86,6 @@ export declare const architectureSummarySchema: z.ZodObject<{
         failed: "failed";
         incomplete: "incomplete";
     }>;
-    reason: z.ZodString;
     counts: z.ZodObject<{
         projects: z.ZodNumber;
         verifiedProjects: z.ZodNumber;

package/dist/src/contract-schema.d.ts

@@ -64,6 +64,7 @@ export declare const contractReportSchema: z.ZodObject<{
 export type ContractReport = z.infer<typeof contractReportSchema>;
 export declare const contractSummarySchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
+    reason: z.ZodString;
     engineVersion: z.ZodString;
     provenance: z.ZodLiteral<"imported-contract-samples">;
     outcome: z.ZodEnum<{
@@ -71,7 +72,6 @@ export declare const contractSummarySchema: z.ZodObject<{
         failed: "failed";
         incomplete: "incomplete";
     }>;
-    reason: z.ZodString;
     counts: z.ZodObject<{
         contracts: z.ZodNumber;
         passed: z.ZodNumber;

package/dist/src/contracts.d.ts

@@ -5,10 +5,10 @@ export declare function validateContracts(input: unknown, options?: {
 }): Promise<ContractReport>;
 export declare function projectContractReport(result: ContractReport, detailed: boolean): {
     schemaVersion: 1;
+    reason: string;
     engineVersion: string;
     provenance: "imported-contract-samples";
     outcome: "passed" | "failed" | "incomplete";
-    reason: string;
     counts: {
         contracts: number;
         passed: number;

package/dist/src/evidence.js

@@ -172,6 +172,8 @@ function goTests(text, allowPackageFailures = false) {
 }
 export function evaluate(check, processes, root) {
     const result = {
+        ...(check.goScope ? { goScope: check.goScope } : {}),
+        ...(check.goBuild ? { goBuild: check.goBuild } : {}),
         ...(check.external ? { external: check.external } : {}),
         id: check.id,
         adapter: check.adapter,
@@ -223,7 +225,7 @@ export function evaluate(check, processes, root) {
                 ...(native.tests ? { tests: native.tests } : {}),
             };
         if (!goScopeComplete(check, processes[0], root, check.kind === "test" ? processes[1]?.stdout : undefined))
-            return set("inconclusive", "Native Go selection omitted inventoried source, a package has no passing test, or scope could not be established.");
+            return set("inconclusive", "Native Go selection or declared exclusions did not reconcile, a package has no passing test, or scope could not be established.");
         return { ...result, ...(native.tests ? { tests: native.tests } : {}) };
     }
     if (check.parser === "eslint-json")

package/dist/src/finding-policy-schema.d.ts

@@ -115,6 +115,7 @@ export declare const findingComparisonSchema: z.ZodObject<{
 export type FindingComparison = z.infer<typeof findingComparisonSchema>;
 export declare const findingComparisonSummarySchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
+    reason: z.ZodString;
     engineVersion: z.ZodString;
     provenance: z.ZodLiteral<"finding-comparison">;
     outcome: z.ZodEnum<{
@@ -122,7 +123,6 @@ export declare const findingComparisonSummarySchema: z.ZodObject<{
         failed: "failed";
         incomplete: "incomplete";
     }>;
-    reason: z.ZodString;
     counts: z.ZodObject<{
         current: z.ZodNumber;
         new: z.ZodNumber;

package/dist/src/go-build.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import type { Check, Inventory, Project } from "./types.js";
+export declare const goBuildTagsSchema: z.ZodArray<z.ZodString>;
+export declare const goBuildSelectionSchema: z.ZodObject<{
+    profile: z.ZodString;
+    tags: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const goBuildPolicySchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    profiles: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        tags: z.ZodArray<z.ZodString>;
+        checks: z.ZodArray<z.ZodEnum<{
+            "go.vet": "go.vet";
+            "go.test": "go.test";
+            "go.test-race": "go.test-race";
+            "go.staticcheck": "go.staticcheck";
+            "go.golangci-lint": "go.golangci-lint";
+        }>>;
+        excludedFiles: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type GoBuildSelection = z.infer<typeof goBuildSelectionSchema>;
+export declare function applyGoBuildPolicy(source: Inventory, project: Project, checks: Check[]): Promise<void>;

package/dist/src/go-build.js

@@ -0,0 +1,113 @@
+import { lstat } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { goScopePolicySchema } from "./go-scope-policy.js";
+import { readProjectFile } from "./inventory.js";
+const nativeCheck = z.enum([
+    "go.vet",
+    "go.test",
+    "go.test-race",
+    "go.staticcheck",
+    "go.golangci-lint",
+]);
+export const goBuildTagsSchema = z
+    .array(z
+    .string()
+    .max(64)
+    .regex(/^[A-Za-z_][A-Za-z0-9_]*$/))
+    .max(32);
+export const goBuildSelectionSchema = z.strictObject({
+    profile: z
+        .string()
+        .max(64)
+        .regex(/^[A-Za-z][A-Za-z0-9_-]*$/),
+    tags: goBuildTagsSchema,
+});
+export const goBuildPolicySchema = z.strictObject({
+    schemaVersion: z.literal(1),
+    profiles: z
+        .array(z.strictObject({
+        name: goBuildSelectionSchema.shape.profile,
+        tags: goBuildTagsSchema,
+        checks: z.array(nativeCheck).min(1).max(5),
+        excludedFiles: goScopePolicySchema.shape.excludedFiles,
+    }))
+        .min(1)
+        .max(5),
+});
+export async function applyGoBuildPolicy(source, project, checks) {
+    const file = path.posix.join(project.path, "checktrail.go-build.json");
+    const scoped = checks.filter((check) => check.id !== "go.format");
+    try {
+        let entry;
+        try {
+            entry = await lstat(path.join(source.root, file));
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return;
+            throw error;
+        }
+        if (!entry.isFile() || !source.files.includes(file))
+            throw new Error("Go build policy must be an inventoried regular file");
+        try {
+            await lstat(path.join(source.root, project.path, "checktrail.go-scope.json"));
+            throw new Error("Use either Go build profiles or the module scope policy, not both");
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        const policy = goBuildPolicySchema.parse(JSON.parse(await readProjectFile(source.root, file)));
+        const profiles = new Map();
+        const names = new Set();
+        for (const profile of policy.profiles) {
+            if (names.has(profile.name))
+                throw new Error("Duplicate Go build profile name");
+            names.add(profile.name);
+            if (new Set(profile.tags).size !== profile.tags.length)
+                throw new Error("Duplicate Go build tag");
+            const paths = profile.excludedFiles.map((item) => item.path);
+            if (new Set(paths).size !== paths.length ||
+                paths.some((p) => !project.files.includes(p)))
+                throw new Error("Go build exclusions must name unique inventoried project files");
+            for (const id of profile.checks) {
+                if (profiles.has(id))
+                    throw new Error("A Go check can select only one build profile");
+                profiles.set(id, profile);
+            }
+        }
+        for (const check of scoped) {
+            const profile = profiles.get(check.id);
+            if (!profile) {
+                check.unavailableReason = "Selected Go check has no build profile";
+                continue;
+            }
+            check.goBuild = { profile: profile.name, tags: [...profile.tags] };
+            check.goScope = {
+                schemaVersion: 1,
+                excludedFiles: profile.excludedFiles,
+            };
+            for (const command of check.commands) {
+                if (command.executable === "go" ||
+                    command.executable === "staticcheck") {
+                    const index = command.args.indexOf("./...");
+                    if (index < 0)
+                        throw new Error("Unsupported Go build command");
+                    if (profile.tags.length)
+                        command.args.splice(index, 0, `-tags=${profile.tags.join(",")}`);
+                }
+                else if (check.id === "go.golangci-lint") {
+                    command.args[3] = JSON.stringify(profile.tags);
+                }
+                else
+                    throw new Error("Unsupported Go build command");
+            }
+        }
+    }
+    catch (error) {
+        for (const check of scoped)
+            check.unavailableReason =
+                error instanceof Error ? error.message : "Invalid Go build policy";
+    }
+}

package/dist/src/go-scope-policy.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+import type { Check, Inventory, Project } from "./types.js";
+export declare const goScopePolicySchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    excludedFiles: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type GoScopePolicy = z.infer<typeof goScopePolicySchema>;
+export declare function applyGoScopePolicy(source: Inventory, project: Project, checks: Check[]): Promise<void>;

package/dist/src/go-scope-policy.js

@@ -0,0 +1,50 @@
+import { lstat } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { readProjectFile } from "./inventory.js";
+export const goScopePolicySchema = z.strictObject({
+    schemaVersion: z.literal(1),
+    excludedFiles: z
+        .array(z.strictObject({
+        path: z
+            .string()
+            .max(4096)
+            .regex(/^(?!\/)(?!.*(?:^|\/)\.{1,2}(?:\/|$))(?!.*\/\/)(?!.*[\\*?[\]{}])[\u0020-\u007e\u0080-\uffff]+\.go$/),
+        reason: z.string().min(1).max(1000).regex(/\S/),
+    }))
+        .max(1000),
+});
+export async function applyGoScopePolicy(source, project, checks) {
+    const file = path.posix.join(project.path, "checktrail.go-scope.json");
+    const scoped = checks.filter((check) => check.id !== "go.format");
+    try {
+        let entry;
+        try {
+            entry = await lstat(path.join(source.root, file));
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return;
+            throw error;
+        }
+        if (!entry.isFile() ||
+            entry.isSymbolicLink() ||
+            source.excluded.includes(file))
+            throw new Error("Go scope policy must be an inventoried regular file");
+        if (!source.files.includes(file))
+            throw new Error("Go scope policy is not inventoried");
+        const policy = goScopePolicySchema.parse(JSON.parse(await readProjectFile(source.root, file)));
+        const paths = policy.excludedFiles.map((entry) => entry.path);
+        if (new Set(paths).size !== paths.length)
+            throw new Error("Duplicate Go scope exclusion");
+        if (paths.some((file) => !project.files.includes(file)))
+            throw new Error("Go scope exclusions must name inventoried project files");
+        for (const check of scoped)
+            check.goScope = policy;
+    }
+    catch (error) {
+        for (const check of scoped)
+            check.unavailableReason =
+                error instanceof Error ? error.message : "Invalid Go scope policy";
+    }
+}

package/dist/src/go-scope.d.ts

@@ -7,5 +7,5 @@ export declare const goEnvironment: {
     GOENV: string;
     GOCACHEPROG: string;
 };
-export declare function goScopeCommand(project: string, env?: Record<string, string>): Command;
+export declare function goScopeCommand(project: string, env?: Record<string, string>, race?: boolean): Command;
 export declare function goScopeComplete(check: Check, process: ProcessResult | undefined, root: string | undefined, testOutput?: string): boolean;

package/dist/src/go-scope.js

@@ -1,3 +1,4 @@
+import { goScopePolicySchema } from "./go-scope-policy.js";
 import path from "node:path";
 import { z } from "zod";
 export const goEnvironment = {
@@ -8,10 +9,10 @@ export const goEnvironment = {
     GOENV: "off",
     GOCACHEPROG: "",
 };
-export function goScopeCommand(project, env = goEnvironment) {
+export function goScopeCommand(project, env = goEnvironment, race = false) {
     return {
         executable: "go",
-        args: ["list", "-json", "./..."],
+        args: ["list", "-json", ...(race ? ["-race"] : []), "./..."],
         cwd: project,
         env,
     };
@@ -60,6 +61,7 @@ const packageSchema = z.object({
     CgoFiles: names,
     TestGoFiles: names,
     XTestGoFiles: names,
+    IgnoredGoFiles: names,
     Error: z.unknown().optional(),
     DepsErrors: z.array(z.unknown()).optional(),
 });
@@ -68,11 +70,26 @@ export function goScopeComplete(check, process, root, testOutput) {
         !process ||
         process.exitCode !== 0 ||
         process.stderr.trim() ||
+        process.timedOut ||
+        process.cancelled ||
+        process.truncated ||
+        process.signal !== null ||
+        process.errorCode !== undefined ||
         !check.scope.length)
         return false;
     try {
         const packages = objects(process.stdout).map((value) => packageSchema.parse(value));
         const expected = new Set(check.scope.map((file) => path.resolve(root, check.project, file)));
+        if (expected.size !== check.scope.length)
+            return false;
+        const policy = check.goScope === undefined
+            ? undefined
+            : goScopePolicySchema.parse(check.goScope);
+        const exclusions = new Set((policy?.excludedFiles ?? []).map((entry) => path.resolve(root, check.project, entry.path)));
+        if (exclusions.size !== (policy?.excludedFiles.length ?? 0) ||
+            [...exclusions].some((file) => !expected.has(file)))
+            return false;
+        const ignored = new Set();
         const seen = new Set();
         const ids = new Set();
         for (const item of packages) {
@@ -88,13 +105,30 @@ export function goScopeComplete(check, process, root, testOutput) {
                 ...item.TestGoFiles,
                 ...item.XTestGoFiles,
             ]) {
-                if (path.basename(file) !== file || !file.endsWith(".go"))
+                if (path.basename(file) !== file ||
+                    file.includes("\\") ||
+                    !file.endsWith(".go"))
                     return false;
                 const resolved = path.resolve(item.Dir, file);
-                if (!expected.has(resolved) || seen.has(resolved))
+                if (!expected.has(resolved) ||
+                    exclusions.has(resolved) ||
+                    seen.has(resolved) ||
+                    ignored.has(resolved))
                     return false;
                 seen.add(resolved);
             }
+            for (const file of item.IgnoredGoFiles) {
+                if (path.basename(file) !== file ||
+                    file.includes("\\") ||
+                    !file.endsWith(".go"))
+                    return false;
+                const resolved = path.resolve(item.Dir, file);
+                if (!exclusions.has(resolved) ||
+                    ignored.has(resolved) ||
+                    seen.has(resolved))
+                    return false;
+                ignored.add(resolved);
+            }
         }
         if (testOutput !== undefined) {
             const tested = new Set();
@@ -114,7 +148,10 @@ export function goScopeComplete(check, process, root, testOutput) {
             if (tested.size !== ids.size)
                 return false;
         }
-        return ids.size > 0 && seen.size === expected.size;
+        return (ids.size > 0 &&
+            seen.size > 0 &&
+            ignored.size === exclusions.size &&
+            seen.size + ignored.size === expected.size);
     }
     catch {
         return false;

package/dist/src/golangci-runner.js

@@ -1,3 +1,4 @@
+import { goBuildTagsSchema } from "./go-build.js";
 import { spawnSync } from "node:child_process";
 import { mkdtemp, writeFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
@@ -31,9 +32,10 @@ const configuration = z.strictObject({
     formatters: z.record(z.string(), z.unknown()).optional(),
 });
 async function main() {
-    const [root, configFile, ...files] = process.argv.slice(2);
-    if (!root || !configFile || !files.length)
+    const [root, configFile, encodedTags, ...files] = process.argv.slice(2);
+    if (!root || !configFile || !encodedTags || !files.length)
         throw new Error("Invalid golangci-lint arguments");
+    const tags = goBuildTagsSchema.parse(JSON.parse(encodedTags));
     const version = spawnSync("golangci-lint", ["version", "--short"], {
         encoding: "utf8",
         maxBuffer: 8192,
@@ -63,6 +65,7 @@ async function main() {
             version: "2",
             run: {
                 tests: true,
+                "build-tags": tags,
                 "modules-download-mode": "readonly",
                 "relative-path-mode": "wd",
                 "issues-exit-code": 1,

package/dist/src/golangci.js

@@ -19,6 +19,7 @@ export async function golangciCheck(source, project) {
                     fileURLToPath(new URL("./golangci-runner.js", import.meta.url)),
                     source.root,
                     configs[0] ?? "",
+                    "[]",
                     ...files,
                 ],
                 cwd: project.path,

package/dist/src/output.js

@@ -22,6 +22,10 @@ export function projectPlan(plan, detailed) {
         excludedCount: plan.excluded.length,
         checks: plan.checks.map((check) => ({
             id: check.id,
+            ...(check.goBuild ? { goBuildTagCount: check.goBuild.tags.length } : {}),
+            ...(check.goScope
+                ? { goExcludedFileCount: check.goScope.excludedFiles.length }
+                : {}),
             kind: check.kind,
             ready: !check.unavailableReason,
         })),
@@ -41,6 +45,10 @@ export function projectReport(report, detailed) {
         sourceError: report.sourceError,
         checks: report.checks.map((check) => ({
             id: check.id,
+            ...(check.goBuild ? { goBuildTagCount: check.goBuild.tags.length } : {}),
+            ...(check.goScope
+                ? { goExcludedFileCount: check.goScope.excludedFiles.length }
+                : {}),
             status: check.status,
             ...(check.tests ? { tests: check.tests } : {}),
         })),

package/dist/src/report-validation.d.ts

@@ -39,6 +39,17 @@ export declare function validatedReport(input: unknown): {
                 source: "adapter-reported";
             }[] | undefined;
         } | undefined;
+        goScope?: {
+            schemaVersion: 1;
+            excludedFiles: {
+                path: string;
+                reason: string;
+            }[];
+        } | undefined;
+        goBuild?: {
+            profile: string;
+            tags: string[];
+        } | undefined;
         tests?: {
             total: number;
             passed: number;

package/dist/src/runtime-inventory.d.ts

@@ -72,6 +72,7 @@ export declare const runtimeComparisonSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const runtimeComparisonSummarySchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
+    reason: z.ZodString;
     engineVersion: z.ZodString;
     provenance: z.ZodLiteral<"imported-runtime-comparison">;
     outcome: z.ZodEnum<{
@@ -79,7 +80,6 @@ export declare const runtimeComparisonSummarySchema: z.ZodObject<{
         failed: "failed";
         incomplete: "incomplete";
     }>;
-    reason: z.ZodString;
     beforeFingerprint: z.ZodString;
     afterFingerprint: z.ZodString;
     counts: z.ZodObject<{
@@ -95,10 +95,10 @@ export type RuntimeComparison = z.infer<typeof runtimeComparisonSchema>;
 export declare function compareRuntimeInventories(beforeInput: unknown, afterInput: unknown): RuntimeComparison;
 export declare function projectRuntimeComparison(result: RuntimeComparison, detailed: boolean): {
     schemaVersion: 1;
+    reason: string;
     engineVersion: string;
     provenance: "imported-runtime-comparison";
     outcome: "passed" | "failed" | "incomplete";
-    reason: string;
     beforeFingerprint: string;
     afterFingerprint: string;
     counts: {

package/dist/src/schemas.d.ts

@@ -1,3 +1,5 @@
+export { goBuildPolicySchema } from "./go-build.js";
+export { goScopePolicySchema } from "./go-scope-policy.js";
 export { externalManifestSchema, externalReferenceSchema, externalRequestSchema, externalResultSchema, } from "./external-adapter.js";
 export { actionlintConfigSchema } from "./actionlint.js";
 export { dotnetConfigSchema } from "./dotnet.js";
@@ -50,6 +52,17 @@ export declare const reportSchema: z.ZodObject<{
         adapter: z.ZodString;
         project: z.ZodString;
         scope: z.ZodArray<z.ZodString>;
+        goScope: z.ZodOptional<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            excludedFiles: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                reason: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        goBuild: z.ZodOptional<z.ZodObject<{
+            profile: z.ZodString;
+            tags: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
         status: z.ZodEnum<{
             error: "error";
             passed: "passed";
@@ -200,6 +213,8 @@ export declare const reportSummarySchema: z.ZodObject<{
             failed: z.ZodNumber;
             skipped: z.ZodNumber;
         }, z.core.$strict>>;
+        goExcludedFileCount: z.ZodOptional<z.ZodNumber>;
+        goBuildTagCount: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
     runId: z.ZodString;
     outcome: z.ZodEnum<{
@@ -256,6 +271,17 @@ export declare const planSchema: z.ZodObject<{
         adapter: z.ZodString;
         project: z.ZodString;
         scope: z.ZodArray<z.ZodString>;
+        goScope: z.ZodOptional<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            excludedFiles: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                reason: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        goBuild: z.ZodOptional<z.ZodObject<{
+            profile: z.ZodString;
+            tags: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
         kind: z.ZodEnum<{
             format: "format";
             analysis: "analysis";
@@ -354,6 +380,8 @@ export declare const planSummarySchema: z.ZodObject<{
             unsupported: "unsupported";
         }>;
         ready: z.ZodBoolean;
+        goExcludedFileCount: z.ZodOptional<z.ZodNumber>;
+        goBuildTagCount: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
     schemaVersion: z.ZodLiteral<1>;
     engineVersion: z.ZodString;