This MCP server provides read-only, deterministic repository test-architecture auditing and planning across supported language adapters.
Run a complete repository analysis (analyze_repository) covering project detection, audits, blockers, findings, candidate ranking, test plans, execution hints, verification commands, and stats.
Discover project roots, supported/unsupported ecosystems, registered adapters, and deterministic project-detection rules.
Audit one selected project (audit_repo) or all detected supported projects (audit_projects) and return raw audit artifacts.
Reuse existing audit artifacts to summarize coverage, rank test candidates, generate project-aware test plans, collect findings/stats, and analyze test placement.
Explain individual audit targets and derive provider-neutral execution hints from plans.
Return a structured deferred result for test generation (generate_selected_test); it does not generate or write tests.
Inspect adapter metadata and project-marker rules without auditing source targets.
Detects and incorporates Bun test runner usage into JavaScript/TypeScript audit and test planning.
Audits PHP projects using Composer, including PSR-4 autoloading and PHPUnit test configuration.
Detects Cypress end-to-end test usage in JavaScript/TypeScript projects and integrates it into test strategy.
Analyzes Django web projects, including static test-client route evidence for test planning.
Audits Elixir applications, including Mix project structure, task ownership, and ExUnit test detection.
Supports Express and Supertest-based projects, contributing route evidence for test planning in JavaScript/TypeScript audits.
Analyzes FastAPI projects, including static test-client route evidence for test planning.
Analyzes Flask projects, including static test-client route evidence for test planning.
Audits JVM projects built with Gradle, including dependency-qualified module evidence and test framework support (JUnit, kotlin.test, TestNG, etc.).
Provides comprehensive repository audit and test planning for JavaScript projects, detecting multiple test frameworks and project structures.
Detects Jest test framework usage in JavaScript projects and integrates it into test strategy analysis.
Audits Kotlin/JVM projects, including Gradle/Maven module roots and support for JUnit, kotlin.test, and TestNG tests.
Audits Elixir Mix applications, analyzing MixProject/Mixfile and Mix task ownership for test strategy.
Detects Mocha test usage (including CommonJS) in JavaScript projects and integrates it into test strategy.
Audits .NET (C#) test projects, including xUnit, NUnit, MSTest, and project file configuration for test planning.
Audits PHP projects, including Composer structure and PHPUnit test class analysis.
Analyzes Python projects using Poetry for dependency management and integrates with test strategy.
Detects pytest configuration and usage in Python projects, including fixture reachability and async extensions.
Provides comprehensive auditing and test planning for Python projects, supporting multiple frameworks and packaging tools.
Detects React component testing patterns, including React Testing Library, for JavaScript/TypeScript projects.
Supports auditing of Ruby projects, providing test strategy analysis based on repository structure.
Audits Cargo packages and workspaces, handling #[test] and #[cfg(test)] modules for test planning.
Supports auditing of Swift projects, providing test strategy analysis based on repository structure.
Detects Testing Library usage (e.g., React Testing Library) in JavaScript/TypeScript projects and integrates it into test strategy.
Provides comprehensive repository audit and test planning for TypeScript projects, including TypeScript execution scripts and test framework detection.
Detects Vitest as a test runner and incorporates it into JavaScript/TypeScript test strategy.
Audit-first test strategy tooling for codebases.
Repo Test Architect builds a deterministic audit graph before asking any model or agent to reason about tests. The goal is to identify repo-native, high-value test work from facts the tool can inspect locally: project roots, framework signals, existing tests, source classifications, blockers, and remaining risk.
The current implementation can:
audit JavaScript/TypeScript, PHP, Python, Ruby, and Swift projects through supported adapters
audit supported, bounded Kotlin/JVM fixtures through the same shared artifact model
audit conventional Go modules and literal repository-contained go.work members through a supported bounded adapter
audit conventional Cargo packages and literal repository-contained workspace members through a supported bounded Rust adapter
audit one conventional SDK-style C# test project or one unique literal production/test project edge, including bounded native xUnit MTP-v2 and MSTest.Sdk v4 ownership, literal and one-hop root-aliased target frameworks, one repository-contained direct *.cs compile include, finite target-conditioned package shapes, bounded nearest-file build and central-package props, exact immutable test-field receivers, stable direct-call results, inline out results, framework exception and collection/string assertions, one-hop test helpers, and guarded well-known System type collisions, through a supported bounded .NET adapter
audit one conventional Composer/PSR-4 project with PHPUnit through a supported bounded PHP adapter
audit one conventional Mix application with exact MixProject/Mixfile, bounded source and Mix-task ownership, literal local ExUnit wrapper discovery, and test-body evidence through a supported bounded Elixir adapter
detect polyglot project roots and report unsupported ecosystems without hiding them
produce a complete repository analysis, findings, ranking, plan, execution hints, and verification commands in one audit pass
classify source files by likely test value and defer low-value direct tests
rank candidates and generate test plans from the audit graph
derive provider-neutral execution, context, parallel-safety, and repository-reasoning hints without selecting models or spawning subagents
analyze conservative test placement findings across project boundaries
collect project-level stats for coverage, candidate counts, frameworks, commands, and adapter usage
provide disabled-by-default local MCP diagnostics, safe internal-error report IDs, runtime checks, and inspectable sanitized bundles without external reporting
expose the same deterministic behavior through CLI commands, a local invoke harness, and a stdio MCP SDK server
lock behavior with golden snapshots, model-consistency scenarios, package checks, and cross-OS CI
Native test generation is intentionally deferred. generate_selected_test returns a structured deferred artifact until adapter-specific generation policy and repair-loop fixtures exist.
Repo Test Architect 1.1.0 is available on npm as latest and in the Official MCP Registry, with stable support for the documented CLI, MCP tools, configuration and versioned artifact contracts. Treat its findings as evidence-backed review input rather than an automatic instruction to change a repository. See the 1.1.0 release notes for per-project failure containment, skipped-test handling, artifact validation, compatibility notes and publication status, and the 1.0.0 release notes for the stable contract.
Ten adapters are supported within their documented boundaries. Dart/Flutter remains experimental, and native test generation remains deferred.
Maintenance is provided as time permits, with no guaranteed response time or feature schedule. Focused community PRs are welcome; see Contributing and Support.
Node.js 20 or newer is required.
Run the CLI without a global install:
npx --yes repo-test-architect doctor
npx --yes repo-test-architect analyze .Pin the stable version:
npx --yes repo-test-architect@1.1.0 doctor
npx --yes repo-test-architect@1.1.0 analyze .Or install the CLI and MCP server binaries:
npm install --global repo-test-architect
repo-test-architect doctor
repo-test-architect analyze .Add the local stdio MCP server to an MCP-capable client:
{
"mcpServers": {
"repo-test-architect": {
"command": "npx",
"args": [
"--yes",
"repo-test-architect",
"mcp"
]
}
}
}To keep an MCP client on this exact release, pin its version:
{
"mcpServers": {
"repo-test-architect": {
"command": "npx",
"args": [
"--yes",
"repo-test-architect@1.1.0",
"mcp"
]
}
}
}The client launches the server locally. Repository source stays on the machine unless the client or another configured tool sends it elsewhere. Connected models receive instructions to start with analyze_repository for a general repository review. See MCP client config and agent install paths for global-install, local-checkout, and host-specific guidance.
Related MCP server: graphward
For a human-readable review of the current repository:
npx --yes repo-test-architect analyze .analyze detects every project root, runs each supported adapter once, and derives the audit summary, top findings, candidate ranking, test plan, execution hints, project stats, and verification commands. Markdown stays compact; JSON preserves the complete evidence bundle:
npx --yes repo-test-architect analyze . --format json
npx --yes repo-test-architect analyze . --changedUseful focused views:
Goal | Command |
Complete repository review |
|
Concise architecture findings |
|
Actionable cross-project plan |
|
Raw reusable project audits |
|
Runtime readiness |
|
Run repo-test-architect --help for the short command map or repo-test-architect <command> --help for options. The CLI reference documents the full surface.
For an MCP-connected model, the equivalent default is analyze_repository. Use narrower tools only when the request asks for one artifact or already supplies an audit artifact.
Available adapters:
dart (experimental): Dart and Flutter pubspec packages, conventional package:test and flutter_test entrypoints, exact library-import evidence, widget test recommendations, and bounded dart test / flutter test commands; see Dart and Flutter support
csharp: one static SDK-style test project or one unique literal production/test project edge, including bounded native xUnit MTP-v2 and MSTest.Sdk v4 ownership, exact literal or one-hop root-aliased target membership, one repository-contained direct *.cs compile include, finite project-local target-conditioned package predicates, and a pair selected amid unrelated projects, with bounded nearest-file Directory.Build.props metadata and static Directory.Packages.props versions, xUnit, NUnit, or MSTest attributed tests, exact project-file commands, runnable-body-owned direct type calls, bounded concrete-local or immutable test-field receivers, one-hop stable direct-call, receiver-call, or inline out var result assertions, bounded exception assertions, and one same-class private-static test-helper hop; see the C# alpha support matrix
elixir: one conventional Mix application with literal app and exact MixProject/Mixfile ownership, conventional/app-prefixed modules and protocols, exact Mix tasks, bounded acronym, terminal-plural, repeated-declaration, and compiled local ExUnit-wrapper ownership, static startup options, test-body-scoped direct fully qualified or exact-alias calls, conservative filename evidence, and a blocker-free mix test command; see Elixir alpha support
javascript: JavaScript/TypeScript repositories with Node's test runner (including TypeScript execution scripts), Bun test, AVA, Mocha/CommonJS, Vitest, Jest, Playwright, Cypress, Express/Supertest, React Testing Library detection, and bounded literal browser request-to-route evidence; see the alpha support matrix for evidence boundaries and known gaps
go: conventional go.mod projects and literal repository-contained go.work members using runnable standard-library TestXxx, FuzzXxx, or ExampleXxx tests, package-local filename, unique top-level and parser-owned concrete receiver-method symbols through explicit types, exact simple constructor results, or exact statically typed test-helper results, bounded standard-library and Testify assertion usage, parser-scoped local shadow checks, same-package or exact external-package imports (including dot imports), generic top-level functions, and bounded callable-body-owned same-package or module-local source hops, module-local commands, and optional explicit GOOS/GOARCH/custom-tag selection; see the alpha support matrix for the supported boundary and blockers
kotlin: conventional Gradle/Maven JVM module roots, settings-owned Gradle aggregates, and root-declared Maven reactors with Kotlin and/or Java standard source sets, dependency-qualified direct/exported-transitive module evidence, JUnit 4/5, kotlin.test, bounded Gradle/JUnit Platform Kotest common specs, conventional Gradle/Spock features, and method-level TestNG through direct Maven dependencies or Gradle useTestNG(); see the Kotlin/JVM alpha support matrix
php: one root Composer project with literal string-valued PSR-4 source/test ownership, bounded literal autoloaded function files, statically declared PHPUnit, exact bounded commands or explicit safe command withholding, conventional runnable test classes including one unique source- or test-owned PHPUnit base edge, direct imported or exact same-namespace class calls, and conservative basename fallback; see PHP alpha support
python: bounded Python package, FastAPI, Django, and Flask layouts with declarative multi-package/namespace ownership, configured pytest discovery, exact absolute/relative imports, one-hop source dependency evidence, static framework test-client route evidence, pytest/unittest, async and property-based extensions, fixture reachability, pip/setuptools, uv, Poetry, Hatch, tox, nox, and coverage configuration; see the Python alpha support matrix
rust: conventional Cargo packages and literal repository-contained workspace members using the built-in #[test] harness, inline #[cfg(test)] modules, exact exclusion of external test-only module graphs, exact crate-module imports from tests/, and exact unconditional crate-root symbol re-exports; see the Rust alpha support matrix
ruby: one conventional Bundler project with lib/ sources, one root gemspec or a complete exact named root-gemspec set, runnable Minitest::Test test_* methods or RSpec examples, exact bounded commands, root .rspec and exact per-file spec_helper loading, three-edge literal require/unique-constant evidence, exact singleton calls, exact constant-owned RSpec described_class, direct immutable constructor-local, one-line RSpec let/subject, exact source-factory and same-group RSpec helper receivers, and exact same-file literal shared-example inclusion, bounded assertion usage, conservative basename fallback, and explicit Minitest-spec/Rails/mixed-runner blockers; see the Ruby alpha support matrix
swift: Swift Package Manager, Xcode-style and Bazel/rules_swift layouts, Swift Testing, XCTest, Quick/Nimble, SnapshotTesting, VaporTesting/XCTVapor, reactive frameworks, and generic Fluent database boundaries with driver-specific qualifiers; see the Swift alpha support matrix
Project detection reports Elixir Mix roots through the supported bounded adapter. Unsupported ecosystems remain visible so clients can distinguish "not audited yet" from "not present."
Don't see your stack? Open an adapter request with the language or ecosystem, build system, test frameworks, and—when possible—a representative public repository. Requests help prioritize adapters against real repository shapes and user demand.
The public package exposes the audit CLI, the stdio MCP server, and a deterministic MCP invoke harness under the stable binary names documented below.
The commands below expose focused artifacts, fixtures, evals, diagnostics, and release checks for advanced use and repository development.
Run the complete analysis directly or against the polyglot example:
npm run analyze
npm run analyze:json
npm run analyze:example
npm run analyze:example:jsonCheck runtime and diagnostics readiness:
npm run doctor
npm run doctor:jsonLocal MCP diagnostics are disabled by default. They can be explicitly directed to stderr or a bounded local JSONL file; see Local diagnostics. Build a sanitized, inspectable bundle with:
npm run diagnostic-bundle -- --diagnostics-file ./.repo-test-architect/diagnostics.jsonl --format json
node ./src/cli/index.js diagnostic-bundle --diagnostics-file ./.repo-test-architect/diagnostics.jsonl --format jsonList registered adapters:
npm run adapters
npm run adapters:jsonInspect project detection marker rules:
npm run detect-rules
npm run detect-rules:jsonDetect project roots and adapter matches:
npm run detect:example
npm run detect:example:json
npm run detect:kotlin-fixture
npm run detect:kotlin-fixture:json
npm run detect:apple-fixture
npm run detect:apple-fixture:json
npm run audit-projects:example
npm run audit-projects:example:json
npm run audit-projects:changed-since
npm run summarize-projects:example
npm run summarize-projects:example:json
npm run rank-projects:example
npm run rank-projects:example:json
npm run plan-projects:example
npm run plan-projects:example:json
npm run hints-projects:example
npm run hints-projects:example:json
npm run findings-projects:example
npm run findings-projects:example:json
npm run placement-projects:example
npm run placement-projects:example:json
npm run placement-projects:split-example:json
npm run stats-projects:example
npm run stats-projects:example:jsonFor project-aware self-audits, exclude checked-in fixture or sample roots with a quoted subtree pattern:
node ./src/cli/index.js findings-projects . --exclude-project "examples/**"Reuse a saved project audit artifact:
node ./src/cli/index.js audit-projects ./examples/polyglot-workspace --format json
node ./src/cli/index.js summarize-projects --from-project-audits ./project-audits.json --format json
node ./src/cli/index.js rank-projects --from-project-audits ./project-audits.json --format json
node ./src/cli/index.js plan-projects --from-project-audits ./project-audits.json --format json
node ./src/cli/index.js findings-projects --from-project-audits ./project-audits.json --format json
node ./src/cli/index.js placement-projects --from-project-audits ./project-audits.json --format json
node ./src/cli/index.js stats-projects --from-project-audits ./project-audits.json --format jsonnpm run audit:example
npm run audit:kotlin-fixtureOutput the structured audit graph:
npm run audit:example:json
npm run audit:kotlin-fixture:jsonGenerate an actionable test plan from the audit graph:
npm run plan:example
npm run plan:example:json
npm run hints:example
npm run hints:example:json
npm run plan:kotlin-fixture
npm run plan:kotlin-fixture:json
npm run plan:item:example
npm run plan:changed
npm run plan:changed-sinceDerive advisory execution hints while leaving the plan artifact unchanged:
node ./src/cli/index.js hints ./examples/node-vitest-basic --item add-test:src/authService.ts
node ./src/cli/index.js hints-projects ./examples/polyglot-workspace --format jsonThe installing CLI or agent host remains responsible for model choice, budgets, permissions, context loading, and subagent lifecycle.
Explain one audited target by stable target ID:
npm run explain:exampleRank test candidates without generating tests:
npm run rank:exampleAnalyze existing test placement from audit evidence:
npm run placement:example
npm run placement:example:json
npm run placement:from-audit:exampleExercise the MCP-style tool surface:
npm run mcp:tools
npm run mcp:analyze:example
npm run mcp:adapters
npm run mcp:detect-rules
npm run mcp:detect:example
npm run mcp:audit-projects:example
npm run mcp:summarize-projects:example
npm run mcp:rank-projects:example
npm run mcp:plan-projects:example
npm run mcp:findings-projects:example
npm run mcp:placement-projects:example
npm run mcp:placement-split:example
npm run mcp:stats-projects:example
npm run mcp:audit:example
npm run mcp:audit:kotlin-fixture
npm run mcp:placement:example
npm run mcp:audit:envelope
npm run mcp:stdio
npm run mcp:smokeGenerate a plan from an existing audit JSON file:
npm run plan:from-audit:exampleRun the auditor regression tests:
npm test
npm run alpha:check
npm run release:checkFind and rank active public repositories for real-world adapter validation:
npm run validation:repos -- --profile react
npm run validation:repos -- --profile workspace --limit 10
npm run validation:repos -- --profile swift,gradle,maven --format jsonThe finder uses authenticated GitHub repository search, verifies exact ecosystem markers in root manifests, and ranks candidates using maintenance recency, stars, repository size, lockfiles, CI, and license metadata. Run npm run validation:repos -- --list-profiles for the available profiles and --help for quality-filter options.
Check that every supported adapter has a complete, pinned hardening corpus:
npm run corpus:check
npm run corpus:scorecard
npm run corpus:measure -- --case python-asyncer --checkout /path/to/pinned/asyncer
npm run corpus:measure -- --case python-django --checkout /path/to/pinned/django --profile-phases
npm run csharp:performance:check
npm run javascript:performance:check
npm run python:performance:check
npm run kotlin:performance:check
npm run rust:performance:check
npm run swift:performance:check
npm run go:performance:check
npm run ruby:performance:check
npm run php:performance:checkThe versioned evals/validation-corpus.json manifest records one conventional library or service, one framework-heavy application, and one difficult ownership graph per adapter cohort. Every supported adapter must have a complete cohort; a registered experimental adapter may be added only with all three roles. Each record carries the shared detection, ownership, command, evidence, ranking, stability, and performance scorecard. The 33 current pins span ten supported adapters and experimental Dart, with all 231 bounded scorecard areas passing. Dart live validation also records native upstream suite results and remaining limits. A reviewed command may be null when the adapter correctly withholds unsafe execution. Cases may also carry bounded adapter audit options, such as an explicit Go build target, so repeated measurements remain host-independent.
corpus:scorecard renders the review contract for humans. It reports review completeness separately from the pass rate among reviewed checks and keeps PASS, FAIL, and PENDING visible for every area. Use npm run corpus:scorecard -- --format json for the deterministic validation-scorecard/v1 view. These are validation-review results, not a repository-quality rating.
corpus:measure verifies the checkout's exact pinned Git SHA, runs the selected adapter at least three times, rejects canonical audit drift, and reports the raw durations, median duration, evidence-link count, and normalized audit digest used to update the scorecard. For the exact Python and Swift pins, --profile-phases defaults to five runs and additionally reports ordered samples and medians for traversal/text reading, project/build ownership, source discovery/indexing, test parsing/indexing, and evidence/classification/artifact assembly. These development timings are callback-only and never enter audit/v1, CLI/MCP audit output, or local MCP diagnostics.
Each adapter performance check separately runs a generated 400-source/200-test project, verifies its candidate and evidence counts, and enforces a broad cross-platform regression ceiling. The Rust gate includes one additional skipped src/lib.rs module-wiring target required to declare the 400 behavioral modules. These synthetic gates complement the recorded per-repository corpus distributions.
Use alpha:check for the adapter-support milestone. release:check additionally covers packaging and installed-binary readiness.
The CI workflow keeps one stable Linux pr-gate: documentation-only changes run focused contract tests, normal changes run npm run alpha:check, and distribution-sensitive changes run npm run release:check. Windows runs only for runtime and portability changes; macOS runs only for Swift-sensitive changes. A merge to master runs the complete release gate on Linux, while manual dispatch runs the full release gate on all three operating systems.
The tests include golden audit and plan snapshots under evals/expected, driven by evals/fixtures.json, plus shared adapter-conformance checks for deterministic JSON, portable paths, evidence semantics, and downstream artifact agreement.
JSON schemas and the signal registry for versioned artifacts live under schemas/.
Refresh snapshots after intentional audit behavior changes:
npm run eval:check
npm run eval:summary
npm run eval:test
npm run eval:updateCheck model-consistency scenario locked fields against deterministic tool results:
npm run model-consistency:check
npm run model-consistency:json
npm run model-consistency:json -- --profile local-small
npm run model-consistency:compare -- baseline-summary.json candidate-summary.json
npm run model-consistency:statsNode 20 or newer is required for the CLI. The default smoke check is portable across platforms:
npm run smokeIf Node is not available yet, the repository still includes a PowerShell smoke check:
powershell -ExecutionPolicy Bypass -File ./scripts/smoke.ps1Check package contents before publishing:
npm run pack:check
npm run bin:check
npm run installed-package:check
npm run distribution:check
npm run release:checkdistribution:check validates packaging and MCP metadata preparation. The stricter distribution:check:publish verifies that the public npm and MCP Registry identities are aligned before a release. See Distribution.
src/
core/
audit-model.ts
audit-phase-timing.js
plan-execution-hints.js
plan-execution-hints.ts
repository-text-files.js
report.js
report.ts
diagnostics/
diagnostics.js
adapters/
csharp/
audit.js
javascript/
audit.js
audit.ts
kotlin/
audit.js
python/
audit.js
rust/
audit.js
swift/
audit.js
cli/
index.js
examples/
csharp-sdk-project-pair/
csharp-sdk-unique-pair/
csharp-sdk-xunit-basic/
node-vitest-basic/
express-supertest/
react-testing-library/
kotlin-junit-basic/
kotlin-gradle-groovy-junit/
kotlin-gradle-module-graph-junit/
kotlin-maven-junit/
kotlin-maven-reactor-junit/
kotlin-maven-wrapper-junit4/
kotlin-gradle-aggregate-kotest/
kotlin-gradle-spock/
kotlin-maven-testng/
python-pytest-service/
python-uv-pytest/
python-poetry-pytest/
rust-cargo-basic/
rust-cargo-workspace-basic/
swift-spm-xctest/
swift-spm-swift-testing/
swift-spm-quick-nimble/
swift-spm-custom-paths/
swift-spm-alternate-roots/
swift-bazel-xctest/
swift-xcode-test-plans/
vapor-service-tests/
vapor-mongodb-boundaries/
evals/
expected/
model-consistency/
schemas/JavaScript/TypeScript, PHP, Python, Ruby, Swift, bounded Kotlin/JVM modules, bounded Go modules, bounded C# SDK project shapes, and bounded Rust Cargo packages are supported adapter proof points. PHP support covers the bounded Composer/PSR-4/PHPUnit ownership, command-withholding, and evidence rules in PHP Alpha Support. Ruby support covers the bounded Bundler/Minitest/RSpec ownership and evidence rules in Ruby Alpha Support. Rust support includes literal repository-contained workspace members, exact package commands, built-in test ownership, literal module graphs, exact test-only module exclusion, direct logical-module imports, inherent associated calls, and exact unconditional crate-root symbol re-exports as defined in Rust Alpha Support. C# support covers one conventional SDK-style test project or one unique literal production/test project edge, including bounded native xUnit MTP-v2 and MSTest.Sdk v4 ownership, exact literal or one-hop root-aliased target membership, one repository-contained direct *.cs compile include, finite target-conditioned package predicates, and a pair amid unrelated projects, with bounded nearest-file build metadata and static central package versions, exact test-project commands, runnable-body-owned direct type calls, bounded concrete-local or immutable test-field receivers, one-hop stable direct-call, receiver-call, or inline out var result assertions, bounded exception assertions, and one same-class private-static test-helper hop while solution ownership remains excluded. Go support includes literal repository-contained go.work members, explicit static build-target selection, bounded standard-library/Testify assertion usage, parser-scoped receiver identity through concrete local and test-helper bindings, and callable-body-owned source evidence as defined in Go Alpha Support. Kotlin/JVM support is limited to conventional Gradle/Maven modules and directly declared aggregate graphs, JUnit, the documented Kotest common-spec and Spock feature variants, or method-level TestNG, and standard source sets as defined in Kotlin/JVM Alpha Support.
Important runtime surfaces:
CLI: src/cli/index.js
MCP tool definitions: src/mcp/tool-definitions.js
stdio MCP SDK server: src/mcp/stdio.js
local invoke harness: src/mcp/invoke.js
release gate: scripts/check-release-readiness.js
Derive advisory test-placement findings across an existing project-audits/v1 artifact while preserving project identity. Use this for multiple audited projects; use analyze_test_placement for one audit/v1 artifact. Does not rescan the repository, execute tests, or create, move, or modify files.
| Name | Required | Description | Default |
|---|---|---|---|
| projectAudits | Yes | The project-audits/v1 object returned by audit_projects; pass the artifact itself, not a file path. |
| Name | Required | Description |
|---|---|---|
| findings | Yes | |
| auditCoverage | No | |
| schemaVersion | Yes | |
| failedProjects | No | |
| failedProjectCount | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false. The description adds useful behavioral context beyond those annotations: findings are advisory, project identity is preserved, and the tool does not rescan the repository or execute tests.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core action, followed by the sibling routing rule and then explicit non-goals. It is compact and every sentence contributes useful selection or invocation context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the output schema, complete parameter documentation, and rich annotations, the description supplies what remains necessary: scope, sibling differentiation, artifact expectations, and non-goals. An agent has enough information to select and invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and the sole parameter is already clearly documented as the project-audits/v1 object returned by audit_projects, not a file path. The description reinforces that the artifact is existing and can cover multiple audited projects, but it does not add parameter details beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: derive advisory test-placement findings across an existing project-audits/v1 artifact. It also explicitly distinguishes itself from the sibling analyze_test_placement by scope: multiple audited projects versus one audit/v1 artifact.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives an explicit routing rule: use this for multiple audited projects, use analyze_test_placement for one audit/v1 artifact. It also states what the tool does not do, which prevents incorrect invocation for rescanning, test execution, or file mutation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Start here for an unfamiliar repository or a general test-architecture review. Detect and audit all project roots once, then return the complete deterministic summary, blockers, findings, ranking, plan, execution hints, verification commands, and stats. Prefer this over audit_repo unless one project root and adapter were explicitly selected.
| Name | Required | Description | Default |
|---|---|---|---|
| goTarget | No | ||
| repoRoot | Yes | Repository root path. | |
| changedPaths | No | Optional repository-relative source paths to limit target selection inside detected projects. | |
| excludeProjectRoots | No | Optional exact project roots or subtree patterns such as examples/** to exclude before analysis. |
| Name | Required | Description |
|---|---|---|
| root | Yes | |
| stats | Yes | |
| summary | Yes | |
| findings | Yes | |
| testPlan | Yes | |
| auditSummary | Yes | |
| projectAudits | Yes | |
| schemaVersion | Yes | |
| executionHints | Yes | |
| candidateRanking | Yes | |
| verificationCommands | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish that this is a read-only, idempotent, non-destructive, closed-world operation. The description adds useful behavioral context beyond those annotations by saying it detects and audits all project roots once, produces deterministic output, and returns blockers, findings, ranking, plan, execution hints, verification commands, and stats. It does not discuss runtime cost or result-size considerations, which keeps it from a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences and front-loads the key guidance: start here for an unfamiliar repository or general review. The remaining sentences efficiently cover scope, output breadth, and sibling differentiation without waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that an output schema exists and annotations cover the safety profile, the description is complete enough for an agent to choose and invoke the tool correctly. It establishes the starting-point use case, the full-repository scope, the deterministic output bundle, and the exception that routes the agent to audit_repo.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 75% description coverage and documents most parameters, including repoRoot, changedPaths, excludeProjectRoots, and the nested goTarget fields. The description itself does not explain any of those parameters or how changedPaths, excludeProjectRoots, or goTarget affect analysis, so it adds little parameter meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description gives a specific verb and resource: it detects and audits all project roots for a repository and returns a broad deterministic analysis bundle. It also directly distinguishes itself from the sibling audit_repo by explaining that analyze_repository is the general starting point unless a single project root and adapter were explicitly selected.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly says when to use the tool: for an unfamiliar repository or a general test-architecture review. It also names the alternative, audit_repo, and states the condition under which that alternative should be chosen instead.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Derive advisory test-placement findings from an existing single-project audit/v1 artifact. Use this for one audited project; use analyze_project_test_placement for a project-audits/v1 artifact. Does not rescan the repository, execute tests, or create, move, or modify files.
| Name | Required | Description | Default |
|---|---|---|---|
| audit | Yes | The audit/v1 object returned by audit_repo or contained in projectAudits.audits[].audit; pass the artifact itself, not a file path. | |
| owner | No | Optional owner label for the audited project. Defaults to audit.profile.root. |
| Name | Required | Description |
|---|---|---|
| findings | Yes | |
| auditCoverage | No | |
| schemaVersion | Yes | |
| failedProjects | No | |
| failedProjectCount | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, non-destructive, closed-world, so the safety profile is covered. The description adds meaningful negative behavior: it derives from an existing artifact rather than rescanning or executing tests, which prevents an agent from expecting fresh results. It stops short of describing the advisory output structure, though an output schema exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences: scope first, sibling routing second, exclusions third. No filler and every clause carries routing or scope information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, the description needn't explain return values, and it covers input provenance, scope, and side-effect exclusions. Minor gap: it doesn't clarify what 'advisory findings' contain or how owner affects output, but the schema and output schema fill that in.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and already documents both parameters, including the crucial 'pass the artifact itself, not a file path' note. The description adds no parameter detail beyond the schema, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb ('derive advisory test-placement findings') and resource ('single-project audit/v1 artifact'), and explicitly distinguishes itself from the sibling analyze_project_test_placement by artifact type. An agent can pick between the two without opening either schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It states the selection condition ('for one audited project') and names the alternative tool with the exact condition that selects it ('project-audits/v1 artifact'). Exclusions ('does not rescan, execute tests, or create/move/modify files') further bound usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return raw per-project audit artifacts for all detected supported roots, report unsupported roots, and list roots whose adapter failed in failedProjects. Use when a downstream specialist tool needs project-audits/v1; for a complete first-pass review, prefer analyze_repository.
| Name | Required | Description | Default |
|---|---|---|---|
| goTarget | No | ||
| repoRoot | Yes | Repository root path. | |
| changedPaths | No | Optional repository-relative source paths to limit target selection inside detected projects. | |
| excludeProjectRoots | No | Optional exact project roots or subtree patterns such as examples/** to exclude before auditing detected projects. |
| Name | Required | Description |
|---|---|---|
| root | Yes | |
| audits | Yes | |
| summary | Yes | |
| schemaVersion | Yes | |
| failedProjects | No | |
| skippedProjects | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds real value beyond that: what the output contains (raw per-project artifacts), how unsupported roots are surfaced, and the named failedProjects field for adapter failures. It stops short of describing error semantics or partial-failure behavior in more detail.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, zero filler, with the output content front-loaded and the routing guidance second. The failedProjects reference is compact and precise rather than verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be enumerated, and the description is complete on scope, failure reporting, and tool selection. The minor gap is that nothing explains how repoRoot interacts with excludeProjectRoots or changedPaths at a behavioral level, but the structured fields largely carry that.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 75%, with documented descriptions for goTarget sub-fields, changedPaths, and excludeProjectRoots. The description adds no parameter guidance at all, so it neither compensates for the remaining gap nor enriches the schema; baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Return raw per-project audit artifacts for all detected supported roots') plus secondary outputs (unsupported roots, failedProjects). It also distinguishes itself from the closest sibling by naming analyze_repository as the broader first-pass tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly names the selecting condition ('when a downstream specialist tool needs project-audits/v1') and the alternative with the condition that favors it ('for a complete first-pass review, prefer analyze_repository'). An agent can route between the two without inspecting either schema.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Audit one explicitly selected project root and return audit/v1. Use only when the caller selected a single adapter or project boundary; adapterId defaults to javascript. For an unfamiliar or complete repository review, use analyze_repository.
| Name | Required | Description | Default |
|---|---|---|---|
| goTarget | No | ||
| repoRoot | Yes | Repository root path. | |
| adapterId | No | Optional adapter id. Defaults to javascript. | |
| changedPaths | No | Optional repository-relative source paths to limit target selection. |
| Name | Required | Description |
|---|---|---|
| risks | Yes | |
| profile | Yes | |
| skipped | Yes | |
| recommended | Yes | |
| schemaVersion | Yes | |
| coveredButRisky | Yes | |
| untestedCandidates | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so the safety profile is covered. The description adds meaningful context beyond that: the output contract version (audit/v1), the default adapter (javascript), and the single-boundary scoping constraint that explains why results may be incomplete for unfamiliar repos. It stops short of noting runtime characteristics such as cost or rate limits, so not a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short sentences, front-loaded with the core action, then the constraint, then the routing alternative. No filler and no repetition of schema detail beyond one default value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With annotations and an output schema present, the description needn't explain return values or safety, and it covers scope and sibling routing well. The only gap is that a nested goTarget object and changedPaths exist without narrative explanation, though the schema documents both.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 75% and the nested goTarget object is fully documented in the schema, so the schema carries most of the burden. The description only restates the adapterId default, which the schema already says, and says nothing about changedPaths (target-selection limiting) or goTarget's build-constraint purpose. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ("Audit one explicitly selected project root") plus the return contract (audit/v1), so the agent knows exactly what comes back. It also names the sibling it is not — analyze_repository — making the distinction from the many other analyze_* tools unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives an explicit positive condition ("Use only when the caller selected a single adapter or project boundary") and an explicit exclusion plus named alternative ("For an unfamiliar or complete repository review, use analyze_repository"). Both the when and the when-not are stated, not inferred.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Collect concise top findings from an existing project-audits/v1 artifact. analyze_repository already includes this result.
| Name | Required | Description | Default |
|---|---|---|---|
| projectAudits | Yes | A project-audits/v1 artifact. |
| Name | Required | Description |
|---|---|---|
| root | Yes | |
| summary | Yes | |
| findings | Yes | |
| schemaVersion | Yes | |
| failedProjects | No | |
| unsupportedProjects | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description adds genuinely useful context beyond them: this consumes a pre-existing artifact rather than re-analyzing, and its output is a subset of analyze_repository's result. No pagination or size characteristics are mentioned, but an output schema exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, zero filler, with the action and its scope front-loaded. The redundancy warning follows immediately and is the single most decision-relevant fact for an agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Return values need not be explained given the output schema, and the description covers what the tool consumes and why it might be skipped. A brief note on when an agent would prefer this over re-running analyze_repository (e.g., artifact already in hand, cost avoidance) would close the remaining gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the single parameter is documented as 'A project-audits/v1 artifact.' The description's phrase 'existing project-audits/v1 artifact' reinforces that the input must be a previously produced artifact object, not an identifier, but adds no format or structure detail beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: 'Collect concise top findings from an existing project-audits/v1 artifact.' The artifact version is named, which scopes the input precisely. It does not fully differentiate from the many sibling audit tools (audit_projects, summarize_project_audits), though it does distinguish itself from analyze_repository.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
'analyze_repository already includes this result' is an explicit when-not signal that steers an agent away from redundant calls. It implies the use case (extract findings from an artifact you already hold) without stating it outright, and names no other alternative among the audit siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Aggregate coverage, counts, risk and signal distributions, frameworks, and adapter usage from an existing project-audits/v1 artifact. Use this for separate reporting or comparisons; analyze_repository already includes the same stats. Returns project-stats/v1 without rescanning the repository, executing tests, or writing files.
| Name | Required | Description | Default |
|---|---|---|---|
| projectAudits | Yes | The project-audits/v1 object returned by audit_projects; pass the artifact itself, not a file path. |
| Name | Required | Description |
|---|---|---|
| root | Yes | |
| counts | Yes | |
| summary | Yes | |
| adapters | Yes | |
| sourceFiles | Yes | |
| distributions | Yes | |
| schemaVersion | Yes | |
| failedProjects | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, and non-destructive, so the safety profile is covered; the description adds real value beyond that by disclosing that no repository rescan, test execution, or file writing occurs and that the output is project-stats/v1. It does not describe failure modes or input validation behavior, keeping it just short of a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, each doing distinct work: what it aggregates, how to decide to use it, and what it does not do. The purpose is front-loaded and there is no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be explained, and the description still names the output format (project-stats/v1). For a one-parameter read-only aggregation tool, nothing an agent needs in order to invoke it correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With a single parameter at 100% schema description coverage, the schema already documents that the project-audits/v1 object itself must be passed rather than a file path. The description adds no parameter-level detail beyond what the schema provides, so the 3 baseline applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource ('Aggregate coverage, counts, risk and signal distributions, frameworks, and adapter usage from an existing project-audits/v1 artifact') and names the input artifact version. It explicitly separates itself from the closest sibling, analyze_repository, which 'already includes the same stats,' so an agent can distinguish the two without inspecting schemas.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It states exactly when to use this tool ('separate reporting or comparisons') and when not to bother ('analyze_repository already includes the same stats'), naming the alternative explicitly. The agent needs no inference to choose.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Discover project roots, support status, and matching adapters without auditing source targets. Use this when project boundaries are needed before a specialized workflow; use analyze_repository for a complete review. Reads local repository markers and returns project-detection/v1 without executing tests or writing files.
| Name | Required | Description | Default |
|---|---|---|---|
| repoRoot | Yes | Readable repository directory whose project markers should be inspected. | |
| excludeProjectRoots | No | Optional exact project roots or subtree patterns such as examples/** to exclude before returning detected projects. |
| Name | Required | Description |
|---|---|---|
| root | Yes | |
| summary | Yes | |
| projects | Yes | |
| schemaVersion | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, openWorldHint=false, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context by saying it reads local repository markers, returns project-detection/v1, and neither audits source targets nor executes tests or writes files.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three tight sentences with the core purpose front-loaded, followed by routing guidance and behavioral scope. Every sentence contributes useful information without repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With rich annotations, 100% schema coverage, and an output schema, the description supplies the remaining context an agent needs: scope, alternative, return contract name, and confirmation that no tests or files are touched.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so repoRoot and excludeProjectRoots are already fully documented in the schema. The description does not add parameter-specific syntax or format details beyond that, which is the baseline expectation when schema coverage is complete.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description gives a specific verb-resource pair: discovering project roots, support status, and matching adapters. It explicitly contrasts with auditing source targets and names analyze_repository as the full-review alternative, so an agent can distinguish it from siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It states when to use the tool: when project boundaries are needed before a specialized workflow. It also names the alternative analyze_repository for a complete review, making the routing decision explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Explain the evidence, risk, testability, and recommendation for one target in an existing audit/v1 artifact. Use this after audit_repo or audit_projects when one target needs detail beyond the audit summary. Returns target-explanation/v1 without rescanning the repository, executing tests, or writing files.
| Name | Required | Description | Default |
|---|---|---|---|
| audit | Yes | The audit/v1 object returned by audit_repo or contained in projectAudits.audits[].audit; pass the artifact itself, not a file path. | |
| targetId | Yes | Exact stable id from an audit target in untestedCandidates, coveredButRisky, recommended, or skipped. |
| Name | Required | Description |
|---|---|---|
| kind | Yes | |
| path | Yes | |
| risk | Yes | |
| target | Yes | |
| signals | Yes | |
| category | Yes | |
| targetId | Yes | |
| rationale | Yes | |
| testLevel | Yes | |
| testability | Yes | |
| schemaVersion | Yes | |
| recommendation | Yes | |
| maintenanceCost | Yes | |
| existingTestPaths | Yes | |
| riskReductionScore | Yes | |
| existingTestEvidence | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful context: it derives results without rescanning the repository, executing tests, or writing files, which tells the agent the passed artifact is the sole input and no repo access is needed. It also names the return schema (target-explanation/v1).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, front-loaded with purpose and followed by usage and behavioral constraints; there is no filler. The final sentence does pack several distinct claims (no rescan, no tests, no writes, output type) into one line, but nothing is wasted.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema declared and annotations covering safety, the description needn't explain return values, and it names the return schema anyway. Combined with 100% schema coverage and explicit prerequisites, an agent has everything needed to call it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and the schema descriptions are already precise about passing the audit object itself rather than a file path and about pulling targetId from specific audit arrays. The description adds only light reinforcement ('existing audit/v1 artifact', 'one target'), so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb (explain) and a precise resource with explicit sub-areas (evidence, risk, testability, recommendation) scoped to one target in an existing audit/v1 artifact. It clearly distinguishes itself from the audit-producing siblings by operating on an already-existing artifact rather than performing an audit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It states exactly when to reach for it: after audit_repo or audit_projects, when one target needs detail beyond the summary. The 'one target' phrasing implicitly excludes bulk use, and the named prerequisites leave nothing to infer.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate a project-aware plan from an existing project-audits/v1 artifact. analyze_repository already includes this result.
| Name | Required | Description | Default |
|---|---|---|---|
| projectAudits | Yes | A project-audits/v1 artifact. |
| Name | Required | Description |
|---|---|---|
| root | Yes | |
| items | Yes | |
| summary | Yes | |
| projectPlans | Yes | |
| schemaVersion | Yes | |
| failedProjects | No | |
| unsupportedProjects | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already declare the operation as read-only, idempotent, non-destructive, and closed-world. The description adds useful behavioral context by warning that analyze_repository already contains this result, but it does not describe what the generated plan contains or how invalid artifacts are handled.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loads the action and source artifact, and uses the second sentence efficiently to prevent redundant use after analyze_repository. There is no unnecessary wording.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the rich annotations, complete schema coverage, and the presence of an output schema, the description is nearly complete for a one-parameter read-only tool. It could be stronger if it clarified how this tool differs from the sibling generate_test_plan.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema fully documents the single projectAudits parameter as a project-audits/v1 artifact, and the description reinforces that it must be an existing artifact. No additional parameter semantics beyond the schema are provided, which is appropriate at the baseline for 100% schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: generating a project-aware plan from a project-audits/v1 artifact. It also distinguishes the tool from analyze_repository by noting that analyze_repository already includes this result, though it does not clarify its relationship to the sibling generate_test_plan.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It implies when the tool is relevant by specifying that it operates on an existing project-audits/v1 artifact and by warning that analyze_repository already includes this result. However, it does not explicitly state when to choose this tool over generate_test_plan or other plan-related siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return a structured deferred result. This tool does not generate or write test code while native generation remains disabled.
| Name | Required | Description | Default |
|---|---|---|---|
| planItemId | Yes | Stable plan item id selected for future generation. |
| Name | Required | Description |
|---|---|---|
| reason | Yes | |
| status | Yes | |
| nextSteps | Yes | |
| planItemId | Yes | |
| schemaVersion | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable context by explicitly stating that no code is generated or written despite the tool name, which prevents misuse; it does not explain the deferred result's structure, but an output schema exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences with no wasted words. The most important constraint comes first and the no-generation caveat is front-loaded immediately after.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema, complete parameter coverage, and annotations covering safety, the description provides enough context to prevent an agent from expecting actual generation. It does not explain what happens if native generation is enabled, but the tool title and description strongly imply a deferred-only state.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and the single parameter planItemId is already documented as a stable plan item id selected for future generation. The description does not add further meaning beyond the schema, so the baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific behavior: it returns a structured deferred result and explicitly does not generate or write test code while native generation is disabled. This clarifies the tool's apparent purpose despite the name 'generate_selected_test', though it does not directly differentiate itself from sibling generation tools beyond the disabled-mode caveat.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'while native generation remains disabled' implies the tool is intended for a deferred/no-op scenario, but it does not explicitly say when to use this instead of generate_test_plan or other generation siblings. Usage is implied rather than directed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create a deterministic plan/v1 from an existing single-project audit/v1 artifact. Use this after audit_repo, optionally selecting one exact plan item; use generate_project_test_plan for multiple audited projects. Does not rescan the repository, execute tests, or generate or write test code.
| Name | Required | Description | Default |
|---|---|---|---|
| audit | Yes | The audit/v1 object returned by audit_repo or contained in projectAudits.audits[].audit; pass the artifact itself, not a file path. | |
| itemId | No | Optional exact plan item id to return; omit it to return the complete deterministic plan. |
| Name | Required | Description |
|---|---|---|
| items | Yes | |
| summary | Yes | |
| blockers | Yes | |
| schemaVersion | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false. The description adds meaningful behavioral context beyond those annotations: the plan is deterministic, it operates on an existing artifact, and it explicitly does not rescan, execute, generate, or write test code.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core action and artifact source, then follows with usage routing and exclusions. Every sentence carries useful information, with no wasted text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has annotations and an output schema, so the description need not explain return values in detail. It still covers the artifact source, optional item selection, sibling routing, and key non-behaviors, leaving no major ambiguity for invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and both parameters are already documented well in the input schema, including passing the audit artifact itself rather than a file path. The description reinforces optional exact item selection but does not add substantial semantics beyond the schema, so the high-coverage baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and output format: 'Create a deterministic plan/v1 from an existing single-project audit/v1 artifact.' It also explicitly distinguishes this tool from the multi-project sibling generate_project_test_plan, so an agent can tell which tool applies without opening the schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It says to use this tool 'after audit_repo' and points to generate_project_test_plan for multiple audited projects. It also clarifies exclusions: it does not rescan the repository, execute tests, or generate or write test code.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Validate and return an existing audit/v1 artifact unchanged; this does not scan a repository. Use audit_repo or analyze_repository for repository discovery.
| Name | Required | Description | Default |
|---|---|---|---|
| audit | Yes | An audit/v1 artifact. |
| Name | Required | Description |
|---|---|---|
| risks | Yes | |
| profile | Yes | |
| skipped | Yes | |
| recommended | Yes | |
| schemaVersion | Yes | |
| coveredButRisky | Yes | |
| untestedCandidates | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, and non-destructive, so the safety profile is covered. The description adds real behavioral context beyond that: the artifact is validated, returned unchanged, and no scanning occurs. It does not describe validation failure behavior, but the output schema likely covers the response shape.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, zero filler, with the core action stated first and the routing guidance second. Every clause earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With rich annotations and an output schema, the description needs only to establish what the tool does and what it does not do, both of which it does. Minor gap: nothing about what 'validate' checks or what happens on an invalid artifact, though the output schema may handle that.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the single parameter's description ('An audit/v1 artifact') is already in the schema. The description restates the artifact concept but adds no format, version, or validation-requirement details beyond what the schema provides, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (validate and return) and resource (existing audit/v1 artifact) with the explicit qualifier 'unchanged'. It directly distinguishes itself from audit_repo and analyze_repository, which superficially sound similar.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly names the negative case ('this does not scan a repository') and routes the agent to two named alternatives for repository discovery. An agent can choose correctly without opening any schema.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Derive provider-neutral execution, context, parallel-safety, and repository-reasoning hints from a plan without invoking models or subagents.
| Name | Required | Description | Default |
|---|---|---|---|
| plan | Yes | A plan/v1 or project-test-plan/v1 artifact. | |
| itemId | No | Optional stable plan item or project item id to select. |
| Name | Required | Description |
|---|---|---|
| items | Yes | |
| source | Yes | |
| summary | Yes | |
| schemaVersion | Yes | |
| failedProjects | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds one genuinely useful trait beyond them — no model or subagent invocation — but says nothing about cost, determinism, or what happens to plan items that can't be resolved.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with no filler; the exclusions clause is placed where it matters. It is dense but every element (verb, source, hint categories, non-invocation constraint) carries information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists and annotations cover safety, so return values and side effects need no explanation. However, for a tool that consumes a nested plan artifact and optionally narrows by itemId, the description never explains the relationship between 'plan' and 'itemId' or when hints are needed, leaving real gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so both 'plan' and 'itemId' are already documented in the schema. The description adds no syntax, format, or scoping detail for either parameter, which is acceptable at this coverage level but earns no extra credit.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('Derive') and resource ('hints from a plan'), and enumerates the hint categories (execution, context, parallel-safety, repository-reasoning). It distinguishes itself from the sibling set, which are generators/auditors rather than hint extractors, though the term 'hints' stays somewhat abstract.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when-to-use or when-not-to-use guidance, and no alternatives named among the many sibling plan tools. The phrase 'without invoking models or subagents' implies a cheap pre-execution step, but the agent must infer that policy.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List registered language adapters available to audit repositories.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| adapters | Yes | |
| schemaVersion | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=false and destructiveHint=false, so the safety profile is fully covered elsewhere. The description adds only the narrow nuance that the list is limited to *registered* adapters, and says nothing about ordering, filtering, or whether the registry can change between calls.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with no filler and no repetition of the title. It is efficient, though on the thin side — one more clause on when to reach for it would have cost little.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Complexity is low (no params, output schema present, safety covered by annotations), so little is required. Still, the description never explains what an 'adapter' represents in this system or how the returned list relates to the sibling audit tools, leaving the agent to guess the follow-up action.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so the baseline is 4. The description correctly implies no input is needed and does not invent filtering options that the empty schema cannot honor.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description gives a specific verb+resource: 'List registered language adapters', with the added qualifier that these are the adapters 'available to audit repositories'. That is clearly distinct from the analysis/audit siblings, which operate on repositories rather than on the adapter registry. It stops short of naming a sibling alternative, but the resource is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: the phrase 'available to audit repositories' hints this is a discovery/prerequisite call before auditing, but there is no explicit when-to-use, no exclusion, and no pointer to analyze_repository or audit_repo as the downstream step. An agent can infer the purpose but is given no routing guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List deterministic project marker rules and ignored directories used during project detection.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| markers | Yes | |
| fallbackRules | No | |
| schemaVersion | Yes | |
| ignoredDirectories | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds only that the payload consists of marker rules and ignored directories — genuinely useful content context, but no disclosure of rule mutability, precedence, or whether results are configuration-derived.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One sentence, zero waste, and the two returned data categories are front-loaded. Nothing could be trimmed without losing information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-param, read-only tool with an output schema and rich annotations, the description is nearly sufficient — it says what data is returned. It stops short of explaining how the rules relate to detect_projects' output, which would help an agent chain calls.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Zero parameters, so there is nothing to disambiguate; schema coverage is 100% and additionalProperties is false. Baseline of 4 applies for a parameterless tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (List) and a concrete resource: deterministic project marker rules plus ignored directories used in project detection. An agent knows exactly what data comes back, though the description never names a sibling (e.g., detect_projects) to differentiate it explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'used during project detection' implies this is an explanatory/debugging companion to detect_projects, but the description never states when to call it or when to prefer it over detect_projects/analyze_repository. Usage is inferable rather than specified.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Rank candidates from an existing project-audits/v1 artifact while preserving project identity. analyze_repository already includes this result.
| Name | Required | Description | Default |
|---|---|---|---|
| projectAudits | Yes | A project-audits/v1 artifact. |
| Name | Required | Description |
|---|---|---|
| root | Yes | |
| summary | Yes | |
| candidates | Yes | |
| schemaVersion | Yes | |
| failedProjects | No | |
| unsupportedProjects | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds only 'preserving project identity', a small piece of behavioral context. No mention of ordering guarantees, cost, or what the ranking produces, though an output schema exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences with zero waste; the operation and its alternative are both front-loaded. Nothing could be cut without losing information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Annotations are rich and an output schema exists, so return values need not be described. However, for a ranking tool the description never characterizes the ordering or what 'preserving project identity' means in practice, which is material context an agent would want. Adequate but thin given the tool's purpose.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There is a single parameter with 100% schema coverage and a nested project-audits/v1 object. The description reinforces that the input must be an existing v1 artifact, but adds no structural or format detail beyond what the schema already states. Baseline 3 is appropriate since the schema does the work.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Rank candidates') and narrows the input to 'an existing project-audits/v1 artifact', which separates it from the broader audit family. It also explicitly notes that analyze_repository already includes this result, so an agent can distinguish the two. It never explains what 'rank' means (which criteria or ordering), leaving the core operation partially opaque.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The clause 'Rank candidates from an existing project-audits/v1 artifact' plus 'analyze_repository already includes this result' effectively tells an agent to prefer analyze_repository and only call this when an artifact is already in hand. It stops short of stating explicit exclusions (e.g., what to do if no artifact exists or how it differs from rank_test_candidates).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Rank testable audit targets by risk reduction and maintenance cost.
| Name | Required | Description | Default |
|---|---|---|---|
| audit | Yes | An audit/v1 artifact. |
| Name | Required | Description |
|---|---|---|
| summary | Yes | |
| blockers | Yes | |
| candidates | Yes | |
| schemaVersion | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so safety behavior needs no restating. The description contributes the non-obvious ranking criteria, but says nothing about ordering, tie-breaking, or what happens with an empty/incomplete audit — and no output schema discussion is needed, so this is a modest add.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with zero filler; the ranking criteria are stated right after the action. Nothing in it is redundant.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, return values need not be explained, but for a tool consuming a deeply nested audit artifact spawned from audit_projects, the description should at least hint at the required input provenance. As written it is adequate but thin for a nested-object tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and there is only one parameter, an opaque nested object described only as "An audit/v1 artifact." The description does not clarify what shape of audit is expected or which upstream tool produces it, so it neither helps nor harms beyond the schema baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description gives a specific verb ("Rank"), a specific resource ("testable audit targets"), and even the ranking criteria (risk reduction, maintenance cost). What it lacks is differentiation from the near-identical sibling rank_project_candidates, leaving the agent to guess which ranking tool applies.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no statement of when to call this versus rank_project_candidates, generate_test_plan, or explain_target, and no prerequisites such as where the required audit artifact should come from. Usage must be inferred entirely from the tool name and sibling list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Summarize an existing project-audits/v1 artifact. Use only when a compact coverage view is needed separately; analyze_repository already includes this result.
| Name | Required | Description | Default |
|---|---|---|---|
| projectAudits | Yes | A project-audits/v1 artifact. |
| Name | Required | Description |
|---|---|---|
| root | Yes | |
| summary | Yes | |
| projects | Yes | |
| schemaVersion | Yes | |
| failedProjects | No | |
| unsupportedProjects | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so the safety profile is covered. The description adds the non-obvious behavioral fact that this is a redundant view of analyze_repository's output, which prevents unnecessary calls. It does not state whether the artifact must have been produced by a prior audit run, but the return shape is covered by the output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the action and immediately followed by the routing caveat. Nothing is wasted and no filler precedes the useful information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Output schema exists so return values need no explanation, and the required nested object is described. The only missing context is where an agent obtains a project-audits/v1 artifact (presumably audit_projects), which would close the loop on a single-parameter tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the single parameter is required and documented as 'A project-audits/v1 artifact.' The description reinforces that it must be an existing artifact, but adds no format, provenance, or example detail beyond the schema. Baseline 3 applies with a fully documented single parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (Summarize) and resource (an existing project-audits/v1 artifact), and explicitly names the sibling (analyze_repository) that already covers this result. An agent can distinguish it from analyze_repository and audit_projects without opening any schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives an explicit gating condition ('Use only when a compact coverage view is needed separately') and names the alternative that already contains the result. This is a when-to-use / when-not-to-use pair, exactly what routing needs.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.1.0analyze_project_test_placement8 fields changedOutput schema / $idRemoved value: -"test-placement-findings-v1.schema.json"Output schema / $schemaRemoved value: -"https://json-schema.org/draft/2020-12/schema"Output schema / descriptionAdded value: +"Top-level shape of this artifact. The complete contract is schemas/test-placement-findings-v1.schema.json in the published package."Output schema / properties / auditCoverageAdded value: +{
+ "enum": [
+ "partial",
+ "none"
+ ]
+}Output schema / properties / failedProjectCountAdded value: +{
+ "type": "integer"
+}Output schema / properties / failedProjectsAdded value: +{
+ "type": "array"
+}Output schema / properties / findings / itemsRemoved value: -{
- "additionalProperties": false,
- "properties": {
- "action": {
- "enum": [
- "move",
- "split",
- "keep"
- ]
- },
- "currentOwner": {
- "minLength": 1,
- "type": "string"
- },
- "evidence": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "minItems": 1,
- "type": "array"
- },
- "id": {
- "minLength": 1,
- "type": "string"
- },
- "reason": {
- "minLength": 1,
- "type": "string"
- },
- "suggestedOwner": {
- "minLength": 1,
- "type": "string"
- },
- "testFile": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "id",
- "testFile",
- "currentOwner",
- "suggestedOwner",
- "action",
- "reason",
- "evidence"
- ],
- "type": "object"
-}Output schema / titleRemoved value: -"Test Placement Findings Artifact"analyze_repository24 fields changedOutput schema / $defsRemoved value: -{
- "auditSummary": {
- "additionalProperties": true,
- "properties": {
- "schemaVersion": {
- "const": "project-audit-summary/v1"
- }
- },
- "required": [
- "schemaVersion"
- ],
- "type": "object"
- },
- "candidateRanking": {
- "additionalProperties": true,
- "properties": {
- "schemaVersion": {
- "const": "project-candidate-ranking/v1"
- }
- },
- "required": [
- "schemaVersion"
- ],
- "type": "object"
- },
- "executionHints": {
- "additionalProperties": true,
- "properties": {
- "schemaVersion": {
- "const": "plan-execution-hints/v1"
- }
- },
- "required": [
- "schemaVersion"
- ],
- "type": "object"
- },
- "findings": {
- "additionalProperties": true,
- "properties": {
- "schemaVersion": {
- "const": "project-findings/v1"
- }
- },
- "required": [
- "schemaVersion"
- ],
- "type": "object"
- },
- "projectAudits": {
- "additionalProperties": true,
- "properties": {
- "schemaVersion": {
- "const": "project-audits/v1"
- }
- },
- "required": [
- "schemaVersion"
- ],
- "type": "object"
- },
- "stats": {
- "additionalProperties": true,
- "properties": {
- "schemaVersion": {
- "const": "project-stats/v1"
- }
- },
- "required": [
- "schemaVersion"
- ],
- "type": "object"
- },
- "testPlan": {
- "additionalProperties": true,
- "properties": {
- "schemaVersion": {
- "const": "project-test-plan/v1"
- }
- },
- "required": [
- "schemaVersion"
- ],
- "type": "object"
- }
-}Output schema / $idRemoved value: -"repository-analysis-v1.schema.json"Output schema / $schemaRemoved value: -"https://json-schema.org/draft/2020-12/schema"Output schema / descriptionAdded value: +"Top-level shape of this artifact. The complete contract is schemas/repository-analysis-v1.schema.json in the published package."Output schema / properties / auditSummary / $refRemoved value: -"#/$defs/auditSummary"Output schema / properties / auditSummary / typeAdded value: +"object"Output schema / properties / candidateRanking / $refRemoved value: -"#/$defs/candidateRanking"Output schema / properties / candidateRanking / typeAdded value: +"object"Output schema / properties / executionHints / $refRemoved value: -"#/$defs/executionHints"Output schema / properties / executionHints / typeAdded value: +"object"Output schema / properties / findings / $refRemoved value: -"#/$defs/findings"Output schema / properties / findings / typeAdded value: +"object"Output schema / properties / projectAudits / $refRemoved value: -"#/$defs/projectAudits"Output schema / properties / projectAudits / typeAdded value: +"object"Output schema / properties / root / minLengthRemoved value: -1Output schema / properties / stats / $refRemoved value: -"#/$defs/stats"Output schema / properties / stats / typeAdded value: +"object"Output schema / properties / summary / additionalPropertiesRemoved value: -falseOutput schema / properties / summary / propertiesRemoved value: -{
- "auditCoverage": {
- "enum": [
- "complete",
- "partial",
- "none"
- ]
- },
- "auditedProjectCount": {
- "minimum": 0,
- "type": "integer"
- },
- "blockerCount": {
- "minimum": 0,
- "type": "integer"
- },
- "candidateCount": {
- "minimum": 0,
- "type": "integer"
- },
- "findingCount": {
- "minimum": 0,
- "type": "integer"
- },
- "planItemCount": {
- "minimum": 0,
- "type": "integer"
- },
- "projectCount": {
- "minimum": 0,
- "type": "integer"
- },
- "unsupportedProjectCount": {
- "minimum": 0,
- "type": "integer"
- },
- "verificationCommandCount": {
- "minimum": 0,
- "type": "integer"
- }
-}Output schema / properties / summary / requiredRemoved value: -[
- "projectCount",
- "auditedProjectCount",
- "unsupportedProjectCount",
- "auditCoverage",
- "blockerCount",
- "findingCount",
- "candidateCount",
- "planItemCount",
- "verificationCommandCount"
-]Output schema / properties / testPlan / $refRemoved value: -"#/$defs/testPlan"Output schema / properties / testPlan / typeAdded value: +"object"Output schema / properties / verificationCommands / itemsRemoved value: -{
- "additionalProperties": false,
- "properties": {
- "command": {
- "minLength": 1,
- "type": "string"
- },
- "projectCount": {
- "minimum": 1,
- "type": "integer"
- }
- },
- "required": [
- "command",
- "projectCount"
- ],
- "type": "object"
-}Output schema / titleRemoved value: -"Repository Analysis Artifact"analyze_test_placement8 fields changedOutput schema / $idRemoved value: -"test-placement-findings-v1.schema.json"Output schema / $schemaRemoved value: -"https://json-schema.org/draft/2020-12/schema"Output schema / descriptionAdded value: +"Top-level shape of this artifact. The complete contract is schemas/test-placement-findings-v1.schema.json in the published package."Output schema / properties / auditCoverageAdded value: +{
+ "enum": [
+ "partial",
+ "none"
+ ]
+}Output schema / properties / failedProjectCountAdded value: +{
+ "type": "integer"
+}Output schema / properties / failedProjectsAdded value: +{
+ "type": "array"
+}Output schema / properties / findings / itemsRemoved value: -{
- "additionalProperties": false,
- "properties": {
- "action": {
- "enum": [
- "move",
- "split",
- "keep"
- ]
- },
- "currentOwner": {
- "minLength": 1,
- "type": "string"
- },
- "evidence": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "minItems": 1,
- "type": "array"
- },
- "id": {
- "minLength": 1,
- "type": "string"
- },
- "reason": {
- "minLength": 1,
- "type": "string"
- },
- "suggestedOwner": {
- "minLength": 1,
- "type": "string"
- },
- "testFile": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "id",
- "testFile",
- "currentOwner",
- "suggestedOwner",
- "action",
- "reason",
- "evidence"
- ],
- "type": "object"
-}Output schema / titleRemoved value: -"Test Placement Findings Artifact"audit_projects11 fields changedOutput schema / $idRemoved value: -"project-audits-v1.schema.json"Output schema / $schemaRemoved value: -"https://json-schema.org/draft/2020-12/schema"Output schema / descriptionAdded value: +"Top-level shape of this artifact. The complete contract is schemas/project-audits-v1.schema.json in the published package."Output schema / properties / audits / itemsRemoved value: -{
- "additionalProperties": false,
- "properties": {
- "adapterId": {
- "minLength": 1,
- "type": "string"
- },
- "audit": {
- "additionalProperties": true,
- "properties": {
- "coveredButRisky": {
- "type": "array"
- },
- "profile": {
- "type": "object"
- },
- "risks": {
- "type": "array"
- },
- "schemaVersion": {
- "const": "audit/v1"
- },
- "skipped": {
- "type": "array"
- },
- "untestedCandidates": {
- "type": "array"
- }
- },
- "required": [
- "schemaVersion",
- "profile",
- "untestedCandidates",
- "coveredButRisky",
- "skipped",
- "risks"
- ],
- "type": "object"
- },
- "projectId": {
- "minLength": 1,
- "type": "string"
- },
- "projectRoot": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "projectId",
- "projectRoot",
- "adapterId",
- "audit"
- ],
- "type": "object"
-}Output schema / properties / failedProjectsAdded value: +{
+ "type": "array"
+}Output schema / properties / root / minLengthRemoved value: -1Output schema / properties / skippedProjects / itemsRemoved value: -{
- "additionalProperties": false,
- "properties": {
- "adapterMatches": {
- "items": {
- "additionalProperties": false,
- "properties": {
- "adapterId": {
- "minLength": 1,
- "type": "string"
- },
- "matchedEcosystems": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "matchedLanguages": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "maturity": {
- "enum": [
- "supported",
- "experimental",
- "planned"
- ]
- }
- },
- "required": [
- "adapterId",
- "maturity",
- "matchedEcosystems",
- "matchedLanguages"
- ],
- "type": "object"
- },
- "type": "array"
- },
- "ecosystems": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "languages": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "projectId": {
- "minLength": 1,
- "type": "string"
- },
- "projectRoot": {
- "minLength": 1,
- "type": "string"
- },
- "reason": {
- "minLength": 1,
- "type": "string"
- },
- "supportStatusReason": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "projectId",
- "projectRoot",
- "reason",
- "ecosystems",
- "languages",
- "adapterMatches",
- "supportStatusReason"
- ],
- "type": "object"
-}Output schema / properties / summary / additionalPropertiesRemoved value: -falseOutput schema / properties / summary / propertiesRemoved value: -{
- "auditedProjectCount": {
- "minimum": 0,
- "type": "integer"
- },
- "projectCount": {
- "minimum": 0,
- "type": "integer"
- },
- "skippedProjectCount": {
- "minimum": 0,
- "type": "integer"
- }
-}Output schema / properties / summary / requiredRemoved value: -[
- "projectCount",
- "auditedProjectCount",
- "skippedProjectCount"
-]Output schema / titleRemoved value: -"Project Audits Artifact"audit_repo13 fields changedOutput schema / $defsRemoved value: -{
- "auditTarget": {
- "additionalProperties": false,
- "properties": {
- "existingTestEvidence": {
- "items": {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "enum": [
- "filename-convention",
- "direct-relative-import",
- "referenced-relative-reexport",
- "tsconfig-path-import",
- "package-entry-import",
- "bounded-dependency",
- "browser-route-match",
- "csharp-symbol-reference",
- "csharp-test-helper",
- "swift-symbol-reference",
- "python-module-import",
- "python-package-reexport",
- "python-pytest-fixture",
- "python-test-client-route",
- "jvm-symbol-reference",
- "go-symbol-reference",
- "go-source-dependency",
- "rust-symbol-reference",
- "ruby-constant-reference",
- "php-symbol-reference",
- "elixir-module-reference"
- ]
- },
- "strength": {
- "enum": [
- "naming",
- "direct",
- "referenced",
- "indirect"
- ]
- },
- "testPath": {
- "type": "string"
- },
- "usage": {
- "enum": [
- "called",
- "asserted"
- ]
- },
- "viaUsage": {
- "enum": [
- "called",
- "asserted"
- ]
- }
- },
- "required": [
- "testPath",
- "kind",
- "strength"
- ],
- "type": "object"
- },
- "type": "array"
- },
- "existingTestPaths": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "id": {
- "type": "string"
- },
- "kind": {
- "type": "string"
- },
- "maintenanceCost": {
- "maximum": 10,
- "minimum": 0,
- "type": "integer"
- },
- "name": {
- "type": "string"
- },
- "path": {
- "type": "string"
- },
- "reasons": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "recommendedTestLevel": {
- "enum": [
- "unit",
- "integration",
- "component",
- "ui",
- "none"
- ]
- },
- "risk": {
- "enum": [
- "low",
- "medium",
- "high"
- ]
- },
- "riskReductionScore": {
- "maximum": 10,
- "minimum": 0,
- "type": "integer"
- },
- "signals": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "testability": {
- "enum": [
- "low",
- "medium",
- "high"
- ]
- }
- },
- "required": [
- "name",
- "id",
- "path",
- "kind",
- "signals",
- "risk",
- "testability",
- "recommendedTestLevel",
- "riskReductionScore",
- "maintenanceCost",
- "reasons",
- "existingTestPaths"
- ],
- "type": "object"
- },
- "skippedTarget": {
- "additionalProperties": false,
- "properties": {
- "id": {
- "type": "string"
- },
- "kind": {
- "type": "string"
- },
- "maintenanceCost": {
- "maximum": 10,
- "minimum": 0,
- "type": "integer"
- },
- "name": {
- "type": "string"
- },
- "path": {
- "type": "string"
- },
- "preferredCoveragePath": {
- "type": "string"
- },
- "reason": {
- "type": "string"
- },
- "riskReductionScore": {
- "maximum": 10,
- "minimum": 0,
- "type": "integer"
- },
- "signals": {
- "items": {
- "type": "string"
- },
- "type": "array"
- }
- },
- "required": [
- "name",
- "id",
- "path",
- "kind",
- "signals",
- "riskReductionScore",
- "maintenanceCost",
- "reason"
- ],
- "type": "object"
- }
-}Output schema / $idRemoved value: -"https://repo-test-architect.local/schemas/audit-v1.schema.json"Output schema / $schemaRemoved value: -"https://json-schema.org/draft/2020-12/schema"Output schema / descriptionAdded value: +"Top-level shape of this artifact. The complete contract is schemas/audit-v1.schema.json in the published package."Output schema / properties / coveredButRisky / itemsRemoved value: -{
- "$ref": "#/$defs/auditTarget"
-}Output schema / properties / profile / additionalPropertiesRemoved value: -falseOutput schema / properties / profile / propertiesRemoved value: -{
- "architectures": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "blockers": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "confidence": {
- "enum": [
- "low",
- "medium",
- "high"
- ]
- },
- "detectedConventions": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "existingTestLocations": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "languages": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "packageManagers": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "root": {
- "type": "string"
- },
- "setupSignals": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "testCommand": {
- "type": "string"
- },
- "testFrameworks": {
- "items": {
- "type": "string"
- },
- "type": "array"
- }
-}Output schema / properties / profile / requiredRemoved value: -[
- "root",
- "languages",
- "packageManagers",
- "testFrameworks",
- "architectures",
- "detectedConventions",
- "existingTestLocations",
- "setupSignals",
- "confidence",
- "blockers"
-]Output schema / properties / recommended / itemsRemoved value: -{
- "$ref": "#/$defs/auditTarget"
-}Output schema / properties / risks / itemsRemoved value: -{
- "type": "string"
-}Output schema / properties / skipped / itemsRemoved value: -{
- "$ref": "#/$defs/skippedTarget"
-}Output schema / properties / untestedCandidates / itemsRemoved value: -{
- "$ref": "#/$defs/auditTarget"
-}Output schema / titleRemoved value: -"Repo Test Architect Audit"collect_project_findings11 fields changedOutput schema / $idRemoved value: -"project-findings-v1.schema.json"Output schema / $schemaRemoved value: -"https://json-schema.org/draft/2020-12/schema"Output schema / descriptionAdded value: +"Top-level shape of this artifact. The complete contract is schemas/project-findings-v1.schema.json in the published package."Output schema / properties / failedProjectsAdded value: +{
+ "type": "array"
+}Output schema / properties / findings / itemsRemoved value: -{
- "additionalProperties": false,
- "properties": {
- "action": {
- "enum": [
- "move",
- "split",
- "keep"
- ]
- },
- "adapterId": {
- "minLength": 1,
- "type": "string"
- },
- "category": {
- "enum": [
- "missing-coverage",
- "weak-existing-coverage",
- "misplaced-coverage",
- "low-value-direct-test",
- "blocked-project"
- ]
- },
- "currentOwner": {
- "minLength": 1,
- "type": "string"
- },
- "evidence": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "existingTestPaths": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "id": {
- "minLength": 1,
- "type": "string"
- },
- "kind": {
- "minLength": 1,
- "type": "string"
- },
- "path": {
- "minLength": 1,
- "type": "string"
- },
- "priority": {
- "type": "integer"
- },
- "projectId": {
- "minLength": 1,
- "type": "string"
- },
- "projectRoot": {
- "minLength": 1,
- "type": "string"
- },
- "rationale": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "severity": {
- "enum": [
- "high",
- "medium",
- "low"
- ]
- },
- "suggestedOwner": {
- "minLength": 1,
- "type": "string"
- },
- "target": {
- "minLength": 1,
- "type": "string"
- },
- "targetId": {
- "minLength": 1,
- "type": "string"
- },
- "testFile": {
- "minLength": 1,
- "type": "string"
- },
- "testLevel": {
- "enum": [
- "unit",
- "integration",
- "component",
- "ui",
- "none"
- ]
- },
- "title": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "id",
- "category",
- "severity",
- "priority",
- "projectId",
- "projectRoot",
- "title",
- "rationale",
- "evidence",
- "existingTestPaths"
- ],
- "type": "object"
-}Output schema / properties / root / minLengthRemoved value: -1Output schema / properties / summary / additionalPropertiesRemoved value: -falseOutput schema / properties / summary / propertiesRemoved value: -{
- "auditCoverage": {
- "enum": [
- "complete",
- "partial",
- "none"
- ]
- },
- "auditedProjectCount": {
- "minimum": 0,
- "type": "integer"
- },
- "blockedProjectCount": {
- "minimum": 0,
- "type": "integer"
- },
- "categoryCounts": {
- "additionalProperties": false,
- "properties": {
- "blocked-project": {
- "minimum": 0,
- "type": "integer"
- },
- "low-value-direct-test": {
- "minimum": 0,
- "type": "integer"
- },
- "misplaced-coverage": {
- "minimum": 0,
- "type": "integer"
- },
- "missing-coverage": {
- "minimum": 0,
- "type": "integer"
- },
- "weak-existing-coverage": {
- "minimum": 0,
- "type": "integer"
- }
- },
- "required": [
- "missing-coverage",
- "weak-existing-coverage",
- "misplaced-coverage",
- "low-value-direct-test",
- "blocked-project"
- ],
- "type": "object"
- },
- "displayedFindingCount": {
- "minimum": 0,
- "type": "integer"
- },
- "findingCount": {
- "minimum": 0,
- "type": "integer"
- },
- "highSeverityCount": {
- "minimum": 0,
- "type": "integer"
- },
- "maxFindings": {
- "minimum": 1,
- "type": "integer"
- },
- "placementFindingCount": {
- "minimum": 0,
- "type": "integer"
- },
- "projectCount": {
- "minimum": 0,
- "type": "integer"
- },
- "unsupportedProjectCount": {
- "minimum": 0,
- "type": "integer"
- },
- "unsupportedReasons": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array",
- "uniqueItems": true
- }
-}Output schema / properties / summary / requiredRemoved value: -[
- "projectCount",
- "auditedProjectCount",
- "unsupportedProjectCount",
- "auditCoverage",
- "unsupportedReasons",
- "findingCount",
- "displayedFindingCount",
- "maxFindings",
- "highSeverityCount",
- "placementFindingCount",
- "blockedProjectCount",
- "categoryCounts"
-]Output schema / properties / unsupportedProjects / itemsRemoved value: -{
- "additionalProperties": true,
- "properties": {
- "adapterMatches": {
- "type": "array"
- },
- "ecosystems": {
- "type": "array"
- },
- "languages": {
- "type": "array"
- },
- "projectId": {
- "minLength": 1,
- "type": "string"
- },
- "projectRoot": {
- "minLength": 1,
- "type": "string"
- },
- "reason": {
- "minLength": 1,
- "type": "string"
- },
- "supportStatusReason": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "projectId",
- "projectRoot",
- "reason",
- "ecosystems",
- "languages",
- "adapterMatches",
- "supportStatusReason"
- ],
- "type": "object"
-}Output schema / titleRemoved value: -"Project Findings Artifact"collect_project_stats20 fields changedOutput schema / $defsRemoved value: -{
- "countRecord": {
- "additionalProperties": {
- "minimum": 0,
- "type": "integer"
- },
- "type": "object"
- }
-}Output schema / $idRemoved value: -"project-stats-v1.schema.json"Output schema / $schemaRemoved value: -"https://json-schema.org/draft/2020-12/schema"Output schema / descriptionAdded value: +"Top-level shape of this artifact. The complete contract is schemas/project-stats-v1.schema.json in the published package."Output schema / properties / adapters / itemsRemoved value: -{
- "additionalProperties": false,
- "properties": {
- "adapterId": {
- "minLength": 1,
- "type": "string"
- },
- "projectCount": {
- "minimum": 0,
- "type": "integer"
- }
- },
- "required": [
- "adapterId",
- "projectCount"
- ],
- "type": "object"
-}Output schema / properties / counts / additionalPropertiesRemoved value: -falseOutput schema / properties / counts / propertiesRemoved value: -{
- "blockerCount": {
- "minimum": 0,
- "type": "integer"
- },
- "coveredButRiskyCount": {
- "minimum": 0,
- "type": "integer"
- },
- "riskCount": {
- "minimum": 0,
- "type": "integer"
- },
- "skippedTargetCount": {
- "minimum": 0,
- "type": "integer"
- },
- "untestedCandidateCount": {
- "minimum": 0,
- "type": "integer"
- }
-}Output schema / properties / counts / requiredRemoved value: -[
- "untestedCandidateCount",
- "coveredButRiskyCount",
- "skippedTargetCount",
- "riskCount",
- "blockerCount"
-]Output schema / properties / distributions / additionalPropertiesRemoved value: -falseOutput schema / properties / distributions / propertiesRemoved value: -{
- "confidence": {
- "$ref": "#/$defs/countRecord"
- },
- "evidenceKinds": {
- "$ref": "#/$defs/countRecord"
- },
- "evidenceStrengths": {
- "$ref": "#/$defs/countRecord"
- },
- "evidenceUsage": {
- "$ref": "#/$defs/countRecord"
- },
- "evidenceViaUsage": {
- "$ref": "#/$defs/countRecord"
- },
- "riskLevels": {
- "$ref": "#/$defs/countRecord"
- },
- "signals": {
- "$ref": "#/$defs/countRecord"
- },
- "targetKinds": {
- "$ref": "#/$defs/countRecord"
- },
- "testCommands": {
- "$ref": "#/$defs/countRecord"
- },
- "testFrameworks": {
- "$ref": "#/$defs/countRecord"
- }
-}Output schema / properties / distributions / requiredRemoved value: -[
- "confidence",
- "testFrameworks",
- "testCommands",
- "targetKinds",
- "riskLevels",
- "signals",
- "evidenceStrengths",
- "evidenceKinds",
- "evidenceUsage",
- "evidenceViaUsage"
-]Output schema / properties / failedProjectsAdded value: +{
+ "type": "array"
+}Output schema / properties / root / minLengthRemoved value: -1Output schema / properties / sourceFiles / additionalPropertiesRemoved value: -falseOutput schema / properties / sourceFiles / propertiesRemoved value: -{
- "audited": {
- "minimum": 0,
- "type": "integer"
- },
- "byLanguage": {
- "additionalProperties": {
- "additionalProperties": false,
- "properties": {
- "audited": {
- "minimum": 0,
- "type": "integer"
- },
- "total": {
- "minimum": 0,
- "type": "integer"
- },
- "unsupported": {
- "minimum": 0,
- "type": "integer"
- }
- },
- "required": [
- "total",
- "audited",
- "unsupported"
- ],
- "type": "object"
- },
- "type": "object"
- },
- "total": {
- "minimum": 0,
- "type": "integer"
- },
- "unsupported": {
- "minimum": 0,
- "type": "integer"
- }
-}Output schema / properties / sourceFiles / requiredRemoved value: -[
- "total",
- "audited",
- "unsupported",
- "byLanguage"
-]Output schema / properties / summary / additionalPropertiesRemoved value: -falseOutput schema / properties / summary / propertiesRemoved value: -{
- "auditCoverage": {
- "enum": [
- "complete",
- "partial",
- "none"
- ]
- },
- "auditedProjectCount": {
- "minimum": 0,
- "type": "integer"
- },
- "projectCount": {
- "minimum": 0,
- "type": "integer"
- },
- "unsupportedProjectCount": {
- "minimum": 0,
- "type": "integer"
- }
-}Output schema / properties / summary / requiredRemoved value: -[
- "projectCount",
- "auditedProjectCount",
- "unsupportedProjectCount",
- "auditCoverage"
-]Output schema / titleRemoved value: -"Project Stats Artifact"detect_projects9 fields changedOutput schema / $idRemoved value: -"project-detection-v1.schema.json"Output schema / $schemaRemoved value: -"https://json-schema.org/draft/2020-12/schema"Output schema / descriptionAdded value: +"Top-level shape of this artifact. The complete contract is schemas/project-detection-v1.schema.json in the published package."Output schema / properties / projects / itemsRemoved value: -{
- "additionalProperties": false,
- "properties": {
- "absoluteRoot": {
- "minLength": 1,
- "type": "string"
- },
- "adapterIds": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "adapterMatches": {
- "items": {
- "additionalProperties": false,
- "properties": {
- "adapterId": {
- "minLength": 1,
- "type": "string"
- },
- "matchedEcosystems": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "matchedLanguages": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "maturity": {
- "enum": [
- "supported",
- "experimental",
- "planned"
- ]
- }
- },
- "required": [
- "adapterId",
- "maturity",
- "matchedEcosystems",
- "matchedLanguages"
- ],
- "type": "object"
- },
- "type": "array"
- },
- "ecosystems": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "id": {
- "minLength": 1,
- "type": "string"
- },
- "languages": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "markerFiles": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "minItems": 1,
- "type": "array"
- },
- "root": {
- "minLength": 1,
- "type": "string"
- },
- "supportStatusReason": {
- "minLength": 1,
- "type": "string"
- },
- "supported": {
- "type": "boolean"
- }
- },
- "required": [
- "id",
- "root",
- "absoluteRoot",
- "ecosystems",
- "languages",
- "markerFiles",
- "adapterIds",
- "adapterMatches",
- "supported",
- "supportStatusReason"
- ],
- "type": "object"
-}Output schema / properties / root / minLengthRemoved value: -1Output schema / properties / summary / additionalPropertiesRemoved value: -falseOutput schema / properties / summary / propertiesRemoved value: -{
- "projectCount": {
- "minimum": 0,
- "type": "integer"
- },
- "supportedProjectCount": {
- "minimum": 0,
- "type": "integer"
- },
- "unsupportedProjectCount": {
- "minimum": 0,
- "type": "integer"
- }
-}Output schema / properties / summary / requiredRemoved value: -[
- "projectCount",
- "supportedProjectCount",
- "unsupportedProjectCount"
-]Output schema / titleRemoved value: -"Project Detection Artifact"explain_target12 fields changedOutput schema / $idRemoved value: -"https://repo-test-architect.local/schemas/target-explanation-v1.schema.json"Output schema / $schemaRemoved value: -"https://json-schema.org/draft/2020-12/schema"Output schema / descriptionAdded value: +"Top-level shape of this artifact. The complete contract is schemas/target-explanation-v1.schema.json in the published package."Output schema / properties / existingTestEvidence / itemsRemoved value: -{
- "additionalProperties": false,
- "properties": {
- "kind": {
- "type": "string"
- },
- "strength": {
- "enum": [
- "naming",
- "direct",
- "referenced",
- "indirect"
- ]
- },
- "testPath": {
- "type": "string"
- },
- "usage": {
- "enum": [
- "called",
- "asserted"
- ]
- },
- "viaUsage": {
- "enum": [
- "called",
- "asserted"
- ]
- }
- },
- "required": [
- "testPath",
- "kind",
- "strength"
- ],
- "type": "object"
-}Output schema / properties / existingTestPaths / itemsRemoved value: -{
- "type": "string"
-}Output schema / properties / maintenanceCost / maximumRemoved value: -10Output schema / properties / maintenanceCost / minimumRemoved value: -0Output schema / properties / rationale / itemsRemoved value: -{
- "type": "string"
-}Output schema / properties / riskReductionScore / maximumRemoved value: -10Output schema / properties / riskReductionScore / minimumRemoved value: -0Output schema / properties / signals / itemsRemoved value: -{
- "type": "string"
-}Output schema / titleRemoved value: -"Repo Test Architect Target Explanation"generate_project_test_plan12 fields changedOutput schema / $idRemoved value: -"project-test-plan-v1.schema.json"Output schema / $schemaRemoved value: -"https://json-schema.org/draft/2020-12/schema"Output schema / descriptionAdded value: +"Top-level shape of this artifact. The complete contract is schemas/project-test-plan-v1.schema.json in the published package."Output schema / properties / failedProjectsAdded value: +{
+ "type": "array"
+}Output schema / properties / items / itemsRemoved value: -{
- "additionalProperties": false,
- "properties": {
- "action": {
- "enum": [
- "add-test",
- "extend-test",
- "defer"
- ]
- },
- "adapterId": {
- "minLength": 1,
- "type": "string"
- },
- "existingTestEvidence": {
- "items": {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "type": "string"
- },
- "strength": {
- "enum": [
- "naming",
- "direct",
- "referenced",
- "indirect"
- ]
- },
- "testPath": {
- "type": "string"
- },
- "usage": {
- "enum": [
- "called",
- "asserted"
- ]
- },
- "viaUsage": {
- "enum": [
- "called",
- "asserted"
- ]
- }
- },
- "required": [
- "testPath",
- "kind",
- "strength"
- ],
- "type": "object"
- },
- "type": "array"
- },
- "existingTestPaths": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "id": {
- "minLength": 1,
- "type": "string"
- },
- "maintenanceCost": {
- "maximum": 10,
- "minimum": 0,
- "type": "integer"
- },
- "path": {
- "minLength": 1,
- "type": "string"
- },
- "priority": {
- "type": "integer"
- },
- "projectId": {
- "minLength": 1,
- "type": "string"
- },
- "projectItemId": {
- "minLength": 1,
- "type": "string"
- },
- "projectRoot": {
- "minLength": 1,
- "type": "string"
- },
- "rationale": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "riskReductionScore": {
- "maximum": 10,
- "minimum": 0,
- "type": "integer"
- },
- "sourceSignals": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "target": {
- "minLength": 1,
- "type": "string"
- },
- "targetId": {
- "minLength": 1,
- "type": "string"
- },
- "testLevel": {
- "enum": [
- "unit",
- "integration",
- "component",
- "ui",
- "none"
- ]
- }
- },
- "required": [
- "projectId",
- "projectRoot",
- "adapterId",
- "projectItemId",
- "id",
- "action",
- "targetId",
- "target",
- "path",
- "testLevel",
- "priority",
- "riskReductionScore",
- "maintenanceCost",
- "rationale",
- "sourceSignals",
- "existingTestPaths"
- ],
- "type": "object"
-}Output schema / properties / projectPlans / itemsRemoved value: -{
- "additionalProperties": false,
- "properties": {
- "adapterId": {
- "minLength": 1,
- "type": "string"
- },
- "plan": {
- "additionalProperties": true,
- "properties": {
- "blockers": {
- "type": "array"
- },
- "items": {
- "type": "array"
- },
- "schemaVersion": {
- "const": "plan/v1"
- },
- "summary": {
- "type": "object"
- }
- },
- "required": [
- "schemaVersion",
- "summary",
- "blockers",
- "items"
- ],
- "type": "object"
- },
- "projectId": {
- "minLength": 1,
- "type": "string"
- },
- "projectRoot": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "projectId",
- "projectRoot",
- "adapterId",
- "plan"
- ],
- "type": "object"
-}Output schema / properties / root / minLengthRemoved value: -1Output schema / properties / summary / additionalPropertiesRemoved value: -falseOutput schema / properties / summary / propertiesRemoved value: -{
- "addTestCount": {
- "minimum": 0,
- "type": "integer"
- },
- "auditCoverage": {
- "enum": [
- "complete",
- "partial",
- "none"
- ]
- },
- "deferredCount": {
- "minimum": 0,
- "type": "integer"
- },
- "extendTestCount": {
- "minimum": 0,
- "type": "integer"
- },
- "itemCount": {
- "minimum": 0,
- "type": "integer"
- },
- "plannedProjectCount": {
- "minimum": 0,
- "type": "integer"
- },
- "projectCount": {
- "minimum": 0,
- "type": "integer"
- },
- "unsupportedProjectCount": {
- "minimum": 0,
- "type": "integer"
- },
- "unsupportedReasons": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array",
- "uniqueItems": true
- }
-}Output schema / properties / summary / requiredRemoved value: -[
- "projectCount",
- "plannedProjectCount",
- "unsupportedProjectCount",
- "auditCoverage",
- "unsupportedReasons",
- "addTestCount",
- "extendTestCount",
- "deferredCount",
- "itemCount"
-]Output schema / properties / unsupportedProjects / itemsRemoved value: -{
- "additionalProperties": false,
- "properties": {
- "adapterMatches": {
- "items": {
- "additionalProperties": false,
- "properties": {
- "adapterId": {
- "minLength": 1,
- "type": "string"
- },
- "matchedEcosystems": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "matchedLanguages": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "maturity": {
- "enum": [
- "supported",
- "experimental",
- "planned"
- ]
- }
- },
- "required": [
- "adapterId",
- "maturity",
- "matchedEcosystems",
- "matchedLanguages"
- ],
- "type": "object"
- },
- "type": "array"
- },
- "ecosystems": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "languages": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "projectId": {
- "minLength": 1,
- "type": "string"
- },
- "projectRoot": {
- "minLength": 1,
- "type": "string"
- },
- "reason": {
- "minLength": 1,
- "type": "string"
- },
- "supportStatusReason": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "projectId",
- "projectRoot",
- "reason",
- "ecosystems",
- "languages",
- "adapterMatches",
- "supportStatusReason"
- ],
- "type": "object"
-}Output schema / titleRemoved value: -"Project Test Plan Artifact"generate_selected_test5 fields changedOutput schema / $idRemoved value: -"https://repo-test-architect.local/schemas/generation-deferred-v1.schema.json"Output schema / $schemaRemoved value: -"https://json-schema.org/draft/2020-12/schema"Output schema / descriptionAdded value: +"Top-level shape of this artifact. The complete contract is schemas/generation-deferred-v1.schema.json in the published package."Output schema / properties / nextSteps / itemsRemoved value: -{
- "type": "string"
-}Output schema / titleRemoved value: -"Repo Test Architect Generation Deferred"generate_test_plan9 fields changedOutput schema / $idRemoved value: -"https://repo-test-architect.local/schemas/plan-v1.schema.json"Output schema / $schemaRemoved value: -"https://json-schema.org/draft/2020-12/schema"Output schema / descriptionAdded value: +"Top-level shape of this artifact. The complete contract is schemas/plan-v1.schema.json in the published package."Output schema / properties / blockers / itemsRemoved value: -{
- "type": "string"
-}Output schema / properties / items / itemsRemoved value: -{
- "additionalProperties": false,
- "properties": {
- "action": {
- "enum": [
- "add-test",
- "extend-test",
- "defer"
- ]
- },
- "existingTestEvidence": {
- "items": {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "type": "string"
- },
- "strength": {
- "enum": [
- "naming",
- "direct",
- "referenced",
- "indirect"
- ]
- },
- "testPath": {
- "type": "string"
- },
- "usage": {
- "enum": [
- "called",
- "asserted"
- ]
- },
- "viaUsage": {
- "enum": [
- "called",
- "asserted"
- ]
- }
- },
- "required": [
- "testPath",
- "kind",
- "strength"
- ],
- "type": "object"
- },
- "type": "array"
- },
- "existingTestPaths": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "id": {
- "type": "string"
- },
- "maintenanceCost": {
- "maximum": 10,
- "minimum": 0,
- "type": "integer"
- },
- "path": {
- "type": "string"
- },
- "priority": {
- "type": "integer"
- },
- "rationale": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "riskReductionScore": {
- "maximum": 10,
- "minimum": 0,
- "type": "integer"
- },
- "sourceSignals": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "target": {
- "type": "string"
- },
- "targetId": {
- "type": "string"
- },
- "testLevel": {
- "enum": [
- "unit",
- "integration",
- "component",
- "ui",
- "none"
- ]
- }
- },
- "required": [
- "id",
- "action",
- "targetId",
- "target",
- "path",
- "testLevel",
- "priority",
- "riskReductionScore",
- "maintenanceCost",
- "rationale",
- "sourceSignals",
- "existingTestPaths"
- ],
- "type": "object"
-}Output schema / properties / summary / additionalPropertiesRemoved value: -falseOutput schema / properties / summary / propertiesRemoved value: -{
- "addTestCount": {
- "minimum": 0,
- "type": "integer"
- },
- "blockerCount": {
- "minimum": 0,
- "type": "integer"
- },
- "confidence": {
- "enum": [
- "low",
- "medium",
- "high"
- ]
- },
- "deferredCount": {
- "minimum": 0,
- "type": "integer"
- },
- "extendTestCount": {
- "minimum": 0,
- "type": "integer"
- },
- "verificationCommand": {
- "type": "string"
- }
-}Output schema / properties / summary / requiredRemoved value: -[
- "confidence",
- "blockerCount",
- "addTestCount",
- "extendTestCount",
- "deferredCount"
-]Output schema / titleRemoved value: -"Repo Test Architect Test Plan"get_audit_graph13 fields changedOutput schema / $defsRemoved value: -{
- "auditTarget": {
- "additionalProperties": false,
- "properties": {
- "existingTestEvidence": {
- "items": {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "enum": [
- "filename-convention",
- "direct-relative-import",
- "referenced-relative-reexport",
- "tsconfig-path-import",
- "package-entry-import",
- "bounded-dependency",
- "browser-route-match",
- "csharp-symbol-reference",
- "csharp-test-helper",
- "swift-symbol-reference",
- "python-module-import",
- "python-package-reexport",
- "python-pytest-fixture",
- "python-test-client-route",
- "jvm-symbol-reference",
- "go-symbol-reference",
- "go-source-dependency",
- "rust-symbol-reference",
- "ruby-constant-reference",
- "php-symbol-reference",
- "elixir-module-reference"
- ]
- },
- "strength": {
- "enum": [
- "naming",
- "direct",
- "referenced",
- "indirect"
- ]
- },
- "testPath": {
- "type": "string"
- },
- "usage": {
- "enum": [
- "called",
- "asserted"
- ]
- },
- "viaUsage": {
- "enum": [
- "called",
- "asserted"
- ]
- }
- },
- "required": [
- "testPath",
- "kind",
- "strength"
- ],
- "type": "object"
- },
- "type": "array"
- },
- "existingTestPaths": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "id": {
- "type": "string"
- },
- "kind": {
- "type": "string"
- },
- "maintenanceCost": {
- "maximum": 10,
- "minimum": 0,
- "type": "integer"
- },
- "name": {
- "type": "string"
- },
- "path": {
- "type": "string"
- },
- "reasons": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "recommendedTestLevel": {
- "enum": [
- "unit",
- "integration",
- "component",
- "ui",
- "none"
- ]
- },
- "risk": {
- "enum": [
- "low",
- "medium",
- "high"
- ]
- },
- "riskReductionScore": {
- "maximum": 10,
- "minimum": 0,
- "type": "integer"
- },
- "signals": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "testability": {
- "enum": [
- "low",
- "medium",
- "high"
- ]
- }
- },
- "required": [
- "name",
- "id",
- "path",
- "kind",
- "signals",
- "risk",
- "testability",
- "recommendedTestLevel",
- "riskReductionScore",
- "maintenanceCost",
- "reasons",
- "existingTestPaths"
- ],
- "type": "object"
- },
- "skippedTarget": {
- "additionalProperties": false,
- "properties": {
- "id": {
- "type": "string"
- },
- "kind": {
- "type": "string"
- },
- "maintenanceCost": {
- "maximum": 10,
- "minimum": 0,
- "type": "integer"
- },
- "name": {
- "type": "string"
- },
- "path": {
- "type": "string"
- },
- "preferredCoveragePath": {
- "type": "string"
- },
- "reason": {
- "type": "string"
- },
- "riskReductionScore": {
- "maximum": 10,
- "minimum": 0,
- "type": "integer"
- },
- "signals": {
- "items": {
- "type": "string"
- },
- "type": "array"
- }
- },
- "required": [
- "name",
- "id",
- "path",
- "kind",
- "signals",
- "riskReductionScore",
- "maintenanceCost",
- "reason"
- ],
- "type": "object"
- }
-}Output schema / $idRemoved value: -"https://repo-test-architect.local/schemas/audit-v1.schema.json"Output schema / $schemaRemoved value: -"https://json-schema.org/draft/2020-12/schema"Output schema / descriptionAdded value: +"Top-level shape of this artifact. The complete contract is schemas/audit-v1.schema.json in the published package."Output schema / properties / coveredButRisky / itemsRemoved value: -{
- "$ref": "#/$defs/auditTarget"
-}Output schema / properties / profile / additionalPropertiesRemoved value: -falseOutput schema / properties / profile / propertiesRemoved value: -{
- "architectures": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "blockers": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "confidence": {
- "enum": [
- "low",
- "medium",
- "high"
- ]
- },
- "detectedConventions": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "existingTestLocations": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "languages": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "packageManagers": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "root": {
- "type": "string"
- },
- "setupSignals": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "testCommand": {
- "type": "string"
- },
- "testFrameworks": {
- "items": {
- "type": "string"
- },
- "type": "array"
- }
-}Output schema / properties / profile / requiredRemoved value: -[
- "root",
- "languages",
- "packageManagers",
- "testFrameworks",
- "architectures",
- "detectedConventions",
- "existingTestLocations",
- "setupSignals",
- "confidence",
- "blockers"
-]Output schema / properties / recommended / itemsRemoved value: -{
- "$ref": "#/$defs/auditTarget"
-}Output schema / properties / risks / itemsRemoved value: -{
- "type": "string"
-}Output schema / properties / skipped / itemsRemoved value: -{
- "$ref": "#/$defs/skippedTarget"
-}Output schema / properties / untestedCandidates / itemsRemoved value: -{
- "$ref": "#/$defs/auditTarget"
-}Output schema / titleRemoved value: -"Repo Test Architect Audit"get_plan_execution_hints12 fields changedOutput schema / $idRemoved value: -"https://repo-test-architect.local/schemas/plan-execution-hints-v1.schema.json"Output schema / $schemaRemoved value: -"https://json-schema.org/draft/2020-12/schema"Output schema / descriptionAdded value: +"Top-level shape of this artifact. The complete contract is schemas/plan-execution-hints-v1.schema.json in the published package."Output schema / properties / failedProjectsAdded value: +{
+ "type": "array"
+}Output schema / properties / items / itemsRemoved value: -{
- "additionalProperties": false,
- "properties": {
- "action": {
- "enum": [
- "add-test",
- "extend-test",
- "defer"
- ]
- },
- "adapterId": {
- "minLength": 1,
- "type": "string"
- },
- "complexity": {
- "enum": [
- "low",
- "medium",
- "high"
- ]
- },
- "contextScope": {
- "additionalProperties": false,
- "properties": {
- "includeBuildConfiguration": {
- "type": "boolean"
- },
- "includeRepositoryInstructions": {
- "const": true
- },
- "mode": {
- "enum": [
- "target-only",
- "target-and-tests",
- "project-boundary"
- ]
- },
- "paths": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "minItems": 1,
- "type": "array",
- "uniqueItems": true
- }
- },
- "required": [
- "mode",
- "paths",
- "includeBuildConfiguration",
- "includeRepositoryInstructions"
- ],
- "type": "object"
- },
- "parallelizable": {
- "type": "boolean"
- },
- "path": {
- "minLength": 1,
- "type": "string"
- },
- "planItemId": {
- "minLength": 1,
- "type": "string"
- },
- "projectId": {
- "minLength": 1,
- "type": "string"
- },
- "projectRoot": {
- "minLength": 1,
- "type": "string"
- },
- "reasons": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "minItems": 1,
- "type": "array"
- },
- "recommendedAgentRole": {
- "enum": [
- "implementation",
- "repository-reasoning",
- "review"
- ]
- },
- "requiresRepositoryReasoning": {
- "type": "boolean"
- },
- "target": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "planItemId",
- "action",
- "target",
- "path",
- "complexity",
- "contextScope",
- "parallelizable",
- "recommendedAgentRole",
- "requiresRepositoryReasoning",
- "reasons"
- ],
- "type": "object"
-}Output schema / properties / source / additionalPropertiesRemoved value: -falseOutput schema / properties / source / propertiesRemoved value: -{
- "itemCount": {
- "minimum": 0,
- "type": "integer"
- },
- "root": {
- "minLength": 1,
- "type": "string"
- },
- "schemaVersion": {
- "enum": [
- "plan/v1",
- "project-test-plan/v1"
- ]
- }
-}Output schema / properties / source / requiredRemoved value: -[
- "schemaVersion",
- "itemCount"
-]Output schema / properties / summary / additionalPropertiesRemoved value: -falseOutput schema / properties / summary / propertiesRemoved value: -{
- "highComplexityCount": {
- "minimum": 0,
- "type": "integer"
- },
- "itemCount": {
- "minimum": 0,
- "type": "integer"
- },
- "lowComplexityCount": {
- "minimum": 0,
- "type": "integer"
- },
- "mediumComplexityCount": {
- "minimum": 0,
- "type": "integer"
- },
- "parallelizableCount": {
- "minimum": 0,
- "type": "integer"
- },
- "repositoryReasoningCount": {
- "minimum": 0,
- "type": "integer"
- }
-}Output schema / properties / summary / requiredRemoved value: -[
- "itemCount",
- "lowComplexityCount",
- "mediumComplexityCount",
- "highComplexityCount",
- "parallelizableCount",
- "repositoryReasoningCount"
-]Output schema / titleRemoved value: -"Repo Test Architect Plan Execution Hints"list_adapters5 fields changedOutput schema / $idRemoved value: -"adapter-registry-v1.schema.json"Output schema / $schemaRemoved value: -"https://json-schema.org/draft/2020-12/schema"Output schema / descriptionAdded value: +"Top-level shape of this artifact. The complete contract is schemas/adapter-registry-v1.schema.json in the published package."Output schema / properties / adapters / itemsRemoved value: -{
- "additionalProperties": false,
- "properties": {
- "ecosystems": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "minItems": 1,
- "type": "array"
- },
- "emittedArtifacts": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "minItems": 1,
- "type": "array"
- },
- "id": {
- "minLength": 1,
- "type": "string"
- },
- "languages": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "minItems": 1,
- "type": "array"
- },
- "maturity": {
- "enum": [
- "supported",
- "experimental",
- "planned"
- ]
- },
- "supportedProjectTypes": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "supportedTestFrameworks": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- }
- },
- "required": [
- "id",
- "ecosystems",
- "languages",
- "maturity",
- "supportedTestFrameworks",
- "supportedProjectTypes",
- "emittedArtifacts"
- ],
- "type": "object"
-}Output schema / titleRemoved value: -"Adapter Registry Artifact"list_project_detection_rules8 fields changedOutput schema / $idRemoved value: -"project-detection-rules-v1.schema.json"Output schema / $schemaRemoved value: -"https://json-schema.org/draft/2020-12/schema"Output schema / descriptionAdded value: +"Top-level shape of this artifact. The complete contract is schemas/project-detection-rules-v1.schema.json in the published package."Output schema / properties / fallbackRules / itemsRemoved value: -{
- "minLength": 1,
- "type": "string"
-}Output schema / properties / ignoredDirectories / itemsRemoved value: -{
- "minLength": 1,
- "type": "string"
-}Output schema / properties / markers / itemsRemoved value: -{
- "additionalProperties": false,
- "oneOf": [
- {
- "required": [
- "fileName"
- ]
- },
- {
- "required": [
- "extension"
- ]
- },
- {
- "required": [
- "directoryExtension"
- ]
- }
- ],
- "properties": {
- "directoryExtension": {
- "minLength": 1,
- "type": "string"
- },
- "ecosystem": {
- "minLength": 1,
- "type": "string"
- },
- "extension": {
- "minLength": 1,
- "type": "string"
- },
- "fileName": {
- "minLength": 1,
- "type": "string"
- },
- "languages": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "minItems": 1,
- "type": "array"
- }
- },
- "required": [
- "ecosystem",
- "languages"
- ],
- "type": "object"
-}Output schema / properties / markers / minItemsRemoved value: -1Output schema / titleRemoved value: -"Project Detection Rules Artifact"rank_project_candidates11 fields changedOutput schema / $idRemoved value: -"project-candidate-ranking-v1.schema.json"Output schema / $schemaRemoved value: -"https://json-schema.org/draft/2020-12/schema"Output schema / descriptionAdded value: +"Top-level shape of this artifact. The complete contract is schemas/project-candidate-ranking-v1.schema.json in the published package."Output schema / properties / candidates / itemsRemoved value: -{
- "additionalProperties": false,
- "properties": {
- "adapterId": {
- "minLength": 1,
- "type": "string"
- },
- "category": {
- "enum": [
- "untested",
- "covered-but-risky"
- ]
- },
- "existingTestEvidence": {
- "items": {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "type": "string"
- },
- "strength": {
- "enum": [
- "naming",
- "direct",
- "referenced",
- "indirect"
- ]
- },
- "testPath": {
- "type": "string"
- },
- "usage": {
- "enum": [
- "called",
- "asserted"
- ]
- },
- "viaUsage": {
- "enum": [
- "called",
- "asserted"
- ]
- }
- },
- "required": [
- "testPath",
- "kind",
- "strength"
- ],
- "type": "object"
- },
- "type": "array"
- },
- "existingTestPaths": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "kind": {
- "minLength": 1,
- "type": "string"
- },
- "maintenanceCost": {
- "maximum": 10,
- "minimum": 0,
- "type": "integer"
- },
- "path": {
- "minLength": 1,
- "type": "string"
- },
- "priority": {
- "type": "integer"
- },
- "projectId": {
- "minLength": 1,
- "type": "string"
- },
- "projectRoot": {
- "minLength": 1,
- "type": "string"
- },
- "projectTargetId": {
- "minLength": 1,
- "type": "string"
- },
- "rationale": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "riskReductionScore": {
- "maximum": 10,
- "minimum": 0,
- "type": "integer"
- },
- "signals": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "target": {
- "minLength": 1,
- "type": "string"
- },
- "targetId": {
- "minLength": 1,
- "type": "string"
- },
- "testLevel": {
- "enum": [
- "unit",
- "integration",
- "component",
- "ui",
- "none"
- ]
- }
- },
- "required": [
- "projectId",
- "projectRoot",
- "adapterId",
- "projectTargetId",
- "targetId",
- "target",
- "path",
- "category",
- "kind",
- "testLevel",
- "priority",
- "riskReductionScore",
- "maintenanceCost",
- "signals",
- "rationale",
- "existingTestPaths"
- ],
- "type": "object"
-}Output schema / properties / failedProjectsAdded value: +{
+ "type": "array"
+}Output schema / properties / root / minLengthRemoved value: -1Output schema / properties / summary / additionalPropertiesRemoved value: -falseOutput schema / properties / summary / propertiesRemoved value: -{
- "auditCoverage": {
- "enum": [
- "complete",
- "partial",
- "none"
- ]
- },
- "auditedProjectCount": {
- "minimum": 0,
- "type": "integer"
- },
- "candidateCount": {
- "minimum": 0,
- "type": "integer"
- },
- "projectCount": {
- "minimum": 0,
- "type": "integer"
- },
- "unsupportedProjectCount": {
- "minimum": 0,
- "type": "integer"
- },
- "unsupportedReasons": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array",
- "uniqueItems": true
- }
-}Output schema / properties / summary / requiredRemoved value: -[
- "projectCount",
- "auditedProjectCount",
- "unsupportedProjectCount",
- "auditCoverage",
- "unsupportedReasons",
- "candidateCount"
-]Output schema / properties / unsupportedProjects / itemsRemoved value: -{
- "additionalProperties": false,
- "properties": {
- "adapterMatches": {
- "items": {
- "additionalProperties": false,
- "properties": {
- "adapterId": {
- "minLength": 1,
- "type": "string"
- },
- "matchedEcosystems": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "matchedLanguages": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "maturity": {
- "enum": [
- "supported",
- "experimental",
- "planned"
- ]
- }
- },
- "required": [
- "adapterId",
- "maturity",
- "matchedEcosystems",
- "matchedLanguages"
- ],
- "type": "object"
- },
- "type": "array"
- },
- "ecosystems": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "languages": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "projectId": {
- "minLength": 1,
- "type": "string"
- },
- "projectRoot": {
- "minLength": 1,
- "type": "string"
- },
- "reason": {
- "minLength": 1,
- "type": "string"
- },
- "supportStatusReason": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "projectId",
- "projectRoot",
- "reason",
- "ecosystems",
- "languages",
- "adapterMatches",
- "supportStatusReason"
- ],
- "type": "object"
-}Output schema / titleRemoved value: -"Project Candidate Ranking Artifact"rank_test_candidates9 fields changedOutput schema / $idRemoved value: -"https://repo-test-architect.local/schemas/candidate-ranking-v1.schema.json"Output schema / $schemaRemoved value: -"https://json-schema.org/draft/2020-12/schema"Output schema / descriptionAdded value: +"Top-level shape of this artifact. The complete contract is schemas/candidate-ranking-v1.schema.json in the published package."Output schema / properties / blockers / itemsRemoved value: -{
- "type": "string"
-}Output schema / properties / candidates / itemsRemoved value: -{
- "additionalProperties": false,
- "properties": {
- "category": {
- "enum": [
- "untested",
- "covered-but-risky"
- ]
- },
- "existingTestEvidence": {
- "items": {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "type": "string"
- },
- "strength": {
- "enum": [
- "naming",
- "direct",
- "referenced",
- "indirect"
- ]
- },
- "testPath": {
- "type": "string"
- },
- "usage": {
- "enum": [
- "called",
- "asserted"
- ]
- },
- "viaUsage": {
- "enum": [
- "called",
- "asserted"
- ]
- }
- },
- "required": [
- "testPath",
- "kind",
- "strength"
- ],
- "type": "object"
- },
- "type": "array"
- },
- "existingTestPaths": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "kind": {
- "type": "string"
- },
- "maintenanceCost": {
- "maximum": 10,
- "minimum": 0,
- "type": "integer"
- },
- "path": {
- "type": "string"
- },
- "priority": {
- "type": "integer"
- },
- "rationale": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "riskReductionScore": {
- "maximum": 10,
- "minimum": 0,
- "type": "integer"
- },
- "signals": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "target": {
- "type": "string"
- },
- "targetId": {
- "type": "string"
- },
- "testLevel": {
- "enum": [
- "unit",
- "integration",
- "component",
- "ui",
- "none"
- ]
- }
- },
- "required": [
- "targetId",
- "target",
- "path",
- "category",
- "kind",
- "testLevel",
- "priority",
- "riskReductionScore",
- "maintenanceCost",
- "signals",
- "rationale",
- "existingTestPaths"
- ],
- "type": "object"
-}Output schema / properties / summary / additionalPropertiesRemoved value: -falseOutput schema / properties / summary / propertiesRemoved value: -{
- "blockerCount": {
- "minimum": 0,
- "type": "integer"
- },
- "candidateCount": {
- "minimum": 0,
- "type": "integer"
- },
- "confidence": {
- "enum": [
- "low",
- "medium",
- "high"
- ]
- },
- "verificationCommand": {
- "type": "string"
- }
-}Output schema / properties / summary / requiredRemoved value: -[
- "confidence",
- "candidateCount",
- "blockerCount"
-]Output schema / titleRemoved value: -"Repo Test Architect Candidate Ranking"summarize_project_audits11 fields changedOutput schema / $idRemoved value: -"project-audit-summary-v1.schema.json"Output schema / $schemaRemoved value: -"https://json-schema.org/draft/2020-12/schema"Output schema / descriptionAdded value: +"Top-level shape of this artifact. The complete contract is schemas/project-audit-summary-v1.schema.json in the published package."Output schema / properties / failedProjectsAdded value: +{
+ "type": "array"
+}Output schema / properties / projects / itemsRemoved value: -{
- "additionalProperties": false,
- "properties": {
- "adapterId": {
- "minLength": 1,
- "type": "string"
- },
- "confidence": {
- "minLength": 1,
- "type": "string"
- },
- "coveredButRiskyCount": {
- "minimum": 0,
- "type": "integer"
- },
- "projectId": {
- "minLength": 1,
- "type": "string"
- },
- "projectRoot": {
- "minLength": 1,
- "type": "string"
- },
- "riskCount": {
- "minimum": 0,
- "type": "integer"
- },
- "skippedTargetCount": {
- "minimum": 0,
- "type": "integer"
- },
- "testCommand": {
- "type": "string"
- },
- "topCandidateIds": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "untestedCandidateCount": {
- "minimum": 0,
- "type": "integer"
- }
- },
- "required": [
- "projectId",
- "projectRoot",
- "adapterId",
- "confidence",
- "untestedCandidateCount",
- "coveredButRiskyCount",
- "skippedTargetCount",
- "riskCount",
- "topCandidateIds"
- ],
- "type": "object"
-}Output schema / properties / root / minLengthRemoved value: -1Output schema / properties / summary / additionalPropertiesRemoved value: -falseOutput schema / properties / summary / propertiesRemoved value: -{
- "auditCoverage": {
- "enum": [
- "complete",
- "partial",
- "none"
- ]
- },
- "auditedProjectCount": {
- "minimum": 0,
- "type": "integer"
- },
- "coveredButRiskyCount": {
- "minimum": 0,
- "type": "integer"
- },
- "projectCount": {
- "minimum": 0,
- "type": "integer"
- },
- "riskCount": {
- "minimum": 0,
- "type": "integer"
- },
- "skippedTargetCount": {
- "minimum": 0,
- "type": "integer"
- },
- "unsupportedProjectCount": {
- "minimum": 0,
- "type": "integer"
- },
- "unsupportedReasons": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array",
- "uniqueItems": true
- },
- "untestedCandidateCount": {
- "minimum": 0,
- "type": "integer"
- }
-}Output schema / properties / summary / requiredRemoved value: -[
- "projectCount",
- "auditedProjectCount",
- "unsupportedProjectCount",
- "auditCoverage",
- "unsupportedReasons",
- "untestedCandidateCount",
- "coveredButRiskyCount",
- "skippedTargetCount",
- "riskCount"
-]Output schema / properties / unsupportedProjects / itemsRemoved value: -{
- "additionalProperties": false,
- "properties": {
- "adapterMatches": {
- "items": {
- "additionalProperties": false,
- "properties": {
- "adapterId": {
- "minLength": 1,
- "type": "string"
- },
- "matchedEcosystems": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "matchedLanguages": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "maturity": {
- "enum": [
- "supported",
- "experimental",
- "planned"
- ]
- }
- },
- "required": [
- "adapterId",
- "maturity",
- "matchedEcosystems",
- "matchedLanguages"
- ],
- "type": "object"
- },
- "type": "array"
- },
- "ecosystems": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "languages": {
- "items": {
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "projectId": {
- "minLength": 1,
- "type": "string"
- },
- "projectRoot": {
- "minLength": 1,
- "type": "string"
- },
- "reason": {
- "minLength": 1,
- "type": "string"
- },
- "supportStatusReason": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "projectId",
- "projectRoot",
- "reason",
- "ecosystems",
- "languages",
- "adapterMatches",
- "supportStatusReason"
- ],
- "type": "object"
-}Output schema / titleRemoved value: -"Project Audit Summary Artifact"v1.0.0analyze_project_test_placement2 fields changedInput schema / properties / projectAudits / descriptionPrevious value: -"A project-audits/v1 artifact."New value: +"The project-audits/v1 object returned by audit_projects; pass the artifact itself, not a file path."Output schema / (root)Previous value: -nullNew value: +{
+ "$id": "test-placement-findings-v1.schema.json",
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "additionalProperties": false,
+ "properties": {
+ "findings": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "action": {
+ "enum": [
+ "move",
+ "split",
+ "keep"
+ ]
+ },
+ "currentOwner": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "evidence": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "minItems": 1,
+ "type": "array"
+ },
+ "id": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "suggestedOwner": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "testFile": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "id",
+ "testFile",
+ "currentOwner",
+ "suggestedOwner",
+ "action",
+ "reason",
+ "evidence"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "schemaVersion": {
+ "const": "test-placement-findings/v1"
+ }
+ },
+ "required": [
+ "schemaVersion",
+ "findings"
+ ],
+ "title": "Test Placement Findings Artifact",
+ "type": "object"
+}analyze_repository1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$defs": {
+ "auditSummary": {
+ "additionalProperties": true,
+ "properties": {
+ "schemaVersion": {
+ "const": "project-audit-summary/v1"
+ }
+ },
+ "required": [
+ "schemaVersion"
+ ],
+ "type": "object"
+ },
+ "candidateRanking": {
+ "additionalProperties": true,
+ "properties": {
+ "schemaVersion": {
+ "const": "project-candidate-ranking/v1"
+ }
+ },
+ "required": [
+ "schemaVersion"
+ ],
+ "type": "object"
+ },
+ "executionHints": {
+ "additionalProperties": true,
+ "properties": {
+ "schemaVersion": {
+ "const": "plan-execution-hints/v1"
+ }
+ },
+ "required": [
+ "schemaVersion"
+ ],
+ "type": "object"
+ },
+ "findings": {
+ "additionalProperties": true,
+ "properties": {
+ "schemaVersion": {
+ "const": "project-findings/v1"
+ }
+ },
+ "required": [
+ "schemaVersion"
+ ],
+ "type": "object"
+ },
+ "projectAudits": {
+ "additionalProperties": true,
+ "properties": {
+ "schemaVersion": {
+ "const": "project-audits/v1"
+ }
+ },
+ "required": [
+ "schemaVersion"
+ ],
+ "type": "object"
+ },
+ "stats": {
+ "additionalProperties": true,
+ "properties": {
+ "schemaVersion": {
+ "const": "project-stats/v1"
+ }
+ },
+ "required": [
+ "schemaVersion"
+ ],
+ "type": "object"
+ },
+ "testPlan": {
+ "additionalProperties": true,
+ "properties": {
+ "schemaVersion": {
+ "const": "project-test-plan/v1"
+ }
+ },
+ "required": [
+ "schemaVersion"
+ ],
+ "type": "object"
+ }
+ },
+ "$id": "repository-analysis-v1.schema.json",
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "additionalProperties": false,
+ "properties": {
+ "auditSummary": {
+ "$ref": "#/$defs/auditSummary"
+ },
+ "candidateRanking": {
+ "$ref": "#/$defs/candidateRanking"
+ },
+ "executionHints": {
+ "$ref": "#/$defs/executionHints"
+ },
+ "findings": {
+ "$ref": "#/$defs/findings"
+ },
+ "projectAudits": {
+ "$ref": "#/$defs/projectAudits"
+ },
+ "root": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "schemaVersion": {
+ "const": "repository-analysis/v1"
+ },
+ "stats": {
+ "$ref": "#/$defs/stats"
+ },
+ "summary": {
+ "additionalProperties": false,
+ "properties": {
+ "auditCoverage": {
+ "enum": [
+ "complete",
+ "partial",
+ "none"
+ ]
+ },
+ "auditedProjectCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "blockerCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "candidateCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "findingCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "planItemCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "projectCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "unsupportedProjectCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "verificationCommandCount": {
+ "minimum": 0,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "projectCount",
+ "auditedProjectCount",
+ "unsupportedProjectCount",
+ "auditCoverage",
+ "blockerCount",
+ "findingCount",
+ "candidateCount",
+ "planItemCount",
+ "verificationCommandCount"
+ ],
+ "type": "object"
+ },
+ "testPlan": {
+ "$ref": "#/$defs/testPlan"
+ },
+ "verificationCommands": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "command": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "projectCount": {
+ "minimum": 1,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "command",
+ "projectCount"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "schemaVersion",
+ "root",
+ "summary",
+ "verificationCommands",
+ "projectAudits",
+ "auditSummary",
+ "findings",
+ "candidateRanking",
+ "testPlan",
+ "executionHints",
+ "stats"
+ ],
+ "title": "Repository Analysis Artifact",
+ "type": "object"
+}analyze_test_placement2 fields changedInput schema / properties / audit / descriptionPrevious value: -"An audit/v1 artifact."New value: +"The audit/v1 object returned by audit_repo or contained in projectAudits.audits[].audit; pass the artifact itself, not a file path."Output schema / (root)Previous value: -nullNew value: +{
+ "$id": "test-placement-findings-v1.schema.json",
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "additionalProperties": false,
+ "properties": {
+ "findings": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "action": {
+ "enum": [
+ "move",
+ "split",
+ "keep"
+ ]
+ },
+ "currentOwner": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "evidence": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "minItems": 1,
+ "type": "array"
+ },
+ "id": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "suggestedOwner": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "testFile": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "id",
+ "testFile",
+ "currentOwner",
+ "suggestedOwner",
+ "action",
+ "reason",
+ "evidence"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "schemaVersion": {
+ "const": "test-placement-findings/v1"
+ }
+ },
+ "required": [
+ "schemaVersion",
+ "findings"
+ ],
+ "title": "Test Placement Findings Artifact",
+ "type": "object"
+}audit_projects1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$id": "project-audits-v1.schema.json",
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "additionalProperties": false,
+ "properties": {
+ "audits": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "adapterId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "audit": {
+ "additionalProperties": true,
+ "properties": {
+ "coveredButRisky": {
+ "type": "array"
+ },
+ "profile": {
+ "type": "object"
+ },
+ "risks": {
+ "type": "array"
+ },
+ "schemaVersion": {
+ "const": "audit/v1"
+ },
+ "skipped": {
+ "type": "array"
+ },
+ "untestedCandidates": {
+ "type": "array"
+ }
+ },
+ "required": [
+ "schemaVersion",
+ "profile",
+ "untestedCandidates",
+ "coveredButRisky",
+ "skipped",
+ "risks"
+ ],
+ "type": "object"
+ },
+ "projectId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "projectRoot": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "projectId",
+ "projectRoot",
+ "adapterId",
+ "audit"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "root": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "schemaVersion": {
+ "const": "project-audits/v1"
+ },
+ "skippedProjects": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "adapterMatches": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "adapterId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "matchedEcosystems": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "matchedLanguages": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "maturity": {
+ "enum": [
+ "supported",
+ "experimental",
+ "planned"
+ ]
+ }
+ },
+ "required": [
+ "adapterId",
+ "maturity",
+ "matchedEcosystems",
+ "matchedLanguages"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "ecosystems": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "languages": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "projectId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "projectRoot": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "supportStatusReason": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "projectId",
+ "projectRoot",
+ "reason",
+ "ecosystems",
+ "languages",
+ "adapterMatches",
+ "supportStatusReason"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "summary": {
+ "additionalProperties": false,
+ "properties": {
+ "auditedProjectCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "projectCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "skippedProjectCount": {
+ "minimum": 0,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "projectCount",
+ "auditedProjectCount",
+ "skippedProjectCount"
+ ],
+ "type": "object"
+ }
+ },
+ "required": [
+ "schemaVersion",
+ "root",
+ "summary",
+ "audits",
+ "skippedProjects"
+ ],
+ "title": "Project Audits Artifact",
+ "type": "object"
+}audit_repo1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$defs": {
+ "auditTarget": {
+ "additionalProperties": false,
+ "properties": {
+ "existingTestEvidence": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "kind": {
+ "enum": [
+ "filename-convention",
+ "direct-relative-import",
+ "referenced-relative-reexport",
+ "tsconfig-path-import",
+ "package-entry-import",
+ "bounded-dependency",
+ "browser-route-match",
+ "csharp-symbol-reference",
+ "csharp-test-helper",
+ "swift-symbol-reference",
+ "python-module-import",
+ "python-package-reexport",
+ "python-pytest-fixture",
+ "python-test-client-route",
+ "jvm-symbol-reference",
+ "go-symbol-reference",
+ "go-source-dependency",
+ "rust-symbol-reference",
+ "ruby-constant-reference",
+ "php-symbol-reference",
+ "elixir-module-reference"
+ ]
+ },
+ "strength": {
+ "enum": [
+ "naming",
+ "direct",
+ "referenced",
+ "indirect"
+ ]
+ },
+ "testPath": {
+ "type": "string"
+ },
+ "usage": {
+ "enum": [
+ "called",
+ "asserted"
+ ]
+ },
+ "viaUsage": {
+ "enum": [
+ "called",
+ "asserted"
+ ]
+ }
+ },
+ "required": [
+ "testPath",
+ "kind",
+ "strength"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "existingTestPaths": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "id": {
+ "type": "string"
+ },
+ "kind": {
+ "type": "string"
+ },
+ "maintenanceCost": {
+ "maximum": 10,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "name": {
+ "type": "string"
+ },
+ "path": {
+ "type": "string"
+ },
+ "reasons": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "recommendedTestLevel": {
+ "enum": [
+ "unit",
+ "integration",
+ "component",
+ "ui",
+ "none"
+ ]
+ },
+ "risk": {
+ "enum": [
+ "low",
+ "medium",
+ "high"
+ ]
+ },
+ "riskReductionScore": {
+ "maximum": 10,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "signals": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "testability": {
+ "enum": [
+ "low",
+ "medium",
+ "high"
+ ]
+ }
+ },
+ "required": [
+ "name",
+ "id",
+ "path",
+ "kind",
+ "signals",
+ "risk",
+ "testability",
+ "recommendedTestLevel",
+ "riskReductionScore",
+ "maintenanceCost",
+ "reasons",
+ "existingTestPaths"
+ ],
+ "type": "object"
+ },
+ "skippedTarget": {
+ "additionalProperties": false,
+ "properties": {
+ "id": {
+ "type": "string"
+ },
+ "kind": {
+ "type": "string"
+ },
+ "maintenanceCost": {
+ "maximum": 10,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "name": {
+ "type": "string"
+ },
+ "path": {
+ "type": "string"
+ },
+ "preferredCoveragePath": {
+ "type": "string"
+ },
+ "reason": {
+ "type": "string"
+ },
+ "riskReductionScore": {
+ "maximum": 10,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "signals": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "name",
+ "id",
+ "path",
+ "kind",
+ "signals",
+ "riskReductionScore",
+ "maintenanceCost",
+ "reason"
+ ],
+ "type": "object"
+ }
+ },
+ "$id": "https://repo-test-architect.local/schemas/audit-v1.schema.json",
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "additionalProperties": false,
+ "properties": {
+ "coveredButRisky": {
+ "items": {
+ "$ref": "#/$defs/auditTarget"
+ },
+ "type": "array"
+ },
+ "profile": {
+ "additionalProperties": false,
+ "properties": {
+ "architectures": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "blockers": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "confidence": {
+ "enum": [
+ "low",
+ "medium",
+ "high"
+ ]
+ },
+ "detectedConventions": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "existingTestLocations": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "languages": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "packageManagers": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "root": {
+ "type": "string"
+ },
+ "setupSignals": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "testCommand": {
+ "type": "string"
+ },
+ "testFrameworks": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "root",
+ "languages",
+ "packageManagers",
+ "testFrameworks",
+ "architectures",
+ "detectedConventions",
+ "existingTestLocations",
+ "setupSignals",
+ "confidence",
+ "blockers"
+ ],
+ "type": "object"
+ },
+ "recommended": {
+ "items": {
+ "$ref": "#/$defs/auditTarget"
+ },
+ "type": "array"
+ },
+ "risks": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "schemaVersion": {
+ "const": "audit/v1"
+ },
+ "skipped": {
+ "items": {
+ "$ref": "#/$defs/skippedTarget"
+ },
+ "type": "array"
+ },
+ "untestedCandidates": {
+ "items": {
+ "$ref": "#/$defs/auditTarget"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "schemaVersion",
+ "profile",
+ "untestedCandidates",
+ "coveredButRisky",
+ "recommended",
+ "skipped",
+ "risks"
+ ],
+ "title": "Repo Test Architect Audit",
+ "type": "object"
+}collect_project_findings1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$id": "project-findings-v1.schema.json",
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "additionalProperties": false,
+ "properties": {
+ "findings": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "action": {
+ "enum": [
+ "move",
+ "split",
+ "keep"
+ ]
+ },
+ "adapterId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "category": {
+ "enum": [
+ "missing-coverage",
+ "weak-existing-coverage",
+ "misplaced-coverage",
+ "low-value-direct-test",
+ "blocked-project"
+ ]
+ },
+ "currentOwner": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "evidence": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "existingTestPaths": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "id": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "kind": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "path": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "priority": {
+ "type": "integer"
+ },
+ "projectId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "projectRoot": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "rationale": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "severity": {
+ "enum": [
+ "high",
+ "medium",
+ "low"
+ ]
+ },
+ "suggestedOwner": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "target": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "targetId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "testFile": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "testLevel": {
+ "enum": [
+ "unit",
+ "integration",
+ "component",
+ "ui",
+ "none"
+ ]
+ },
+ "title": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "id",
+ "category",
+ "severity",
+ "priority",
+ "projectId",
+ "projectRoot",
+ "title",
+ "rationale",
+ "evidence",
+ "existingTestPaths"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "root": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "schemaVersion": {
+ "const": "project-findings/v1"
+ },
+ "summary": {
+ "additionalProperties": false,
+ "properties": {
+ "auditCoverage": {
+ "enum": [
+ "complete",
+ "partial",
+ "none"
+ ]
+ },
+ "auditedProjectCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "blockedProjectCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "categoryCounts": {
+ "additionalProperties": false,
+ "properties": {
+ "blocked-project": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "low-value-direct-test": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "misplaced-coverage": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "missing-coverage": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "weak-existing-coverage": {
+ "minimum": 0,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "missing-coverage",
+ "weak-existing-coverage",
+ "misplaced-coverage",
+ "low-value-direct-test",
+ "blocked-project"
+ ],
+ "type": "object"
+ },
+ "displayedFindingCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "findingCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "highSeverityCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "maxFindings": {
+ "minimum": 1,
+ "type": "integer"
+ },
+ "placementFindingCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "projectCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "unsupportedProjectCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "unsupportedReasons": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array",
+ "uniqueItems": true
+ }
+ },
+ "required": [
+ "projectCount",
+ "auditedProjectCount",
+ "unsupportedProjectCount",
+ "auditCoverage",
+ "unsupportedReasons",
+ "findingCount",
+ "displayedFindingCount",
+ "maxFindings",
+ "highSeverityCount",
+ "placementFindingCount",
+ "blockedProjectCount",
+ "categoryCounts"
+ ],
+ "type": "object"
+ },
+ "unsupportedProjects": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "adapterMatches": {
+ "type": "array"
+ },
+ "ecosystems": {
+ "type": "array"
+ },
+ "languages": {
+ "type": "array"
+ },
+ "projectId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "projectRoot": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "supportStatusReason": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "projectId",
+ "projectRoot",
+ "reason",
+ "ecosystems",
+ "languages",
+ "adapterMatches",
+ "supportStatusReason"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "schemaVersion",
+ "root",
+ "summary",
+ "findings",
+ "unsupportedProjects"
+ ],
+ "title": "Project Findings Artifact",
+ "type": "object"
+}collect_project_stats2 fields changedInput schema / properties / projectAudits / descriptionPrevious value: -"A project-audits/v1 artifact."New value: +"The project-audits/v1 object returned by audit_projects; pass the artifact itself, not a file path."Output schema / (root)Previous value: -nullNew value: +{
+ "$defs": {
+ "countRecord": {
+ "additionalProperties": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "type": "object"
+ }
+ },
+ "$id": "project-stats-v1.schema.json",
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "additionalProperties": false,
+ "properties": {
+ "adapters": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "adapterId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "projectCount": {
+ "minimum": 0,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "adapterId",
+ "projectCount"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "counts": {
+ "additionalProperties": false,
+ "properties": {
+ "blockerCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "coveredButRiskyCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "riskCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "skippedTargetCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "untestedCandidateCount": {
+ "minimum": 0,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "untestedCandidateCount",
+ "coveredButRiskyCount",
+ "skippedTargetCount",
+ "riskCount",
+ "blockerCount"
+ ],
+ "type": "object"
+ },
+ "distributions": {
+ "additionalProperties": false,
+ "properties": {
+ "confidence": {
+ "$ref": "#/$defs/countRecord"
+ },
+ "evidenceKinds": {
+ "$ref": "#/$defs/countRecord"
+ },
+ "evidenceStrengths": {
+ "$ref": "#/$defs/countRecord"
+ },
+ "evidenceUsage": {
+ "$ref": "#/$defs/countRecord"
+ },
+ "evidenceViaUsage": {
+ "$ref": "#/$defs/countRecord"
+ },
+ "riskLevels": {
+ "$ref": "#/$defs/countRecord"
+ },
+ "signals": {
+ "$ref": "#/$defs/countRecord"
+ },
+ "targetKinds": {
+ "$ref": "#/$defs/countRecord"
+ },
+ "testCommands": {
+ "$ref": "#/$defs/countRecord"
+ },
+ "testFrameworks": {
+ "$ref": "#/$defs/countRecord"
+ }
+ },
+ "required": [
+ "confidence",
+ "testFrameworks",
+ "testCommands",
+ "targetKinds",
+ "riskLevels",
+ "signals",
+ "evidenceStrengths",
+ "evidenceKinds",
+ "evidenceUsage",
+ "evidenceViaUsage"
+ ],
+ "type": "object"
+ },
+ "root": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "schemaVersion": {
+ "const": "project-stats/v1"
+ },
+ "sourceFiles": {
+ "additionalProperties": false,
+ "properties": {
+ "audited": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "byLanguage": {
+ "additionalProperties": {
+ "additionalProperties": false,
+ "properties": {
+ "audited": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "total": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "unsupported": {
+ "minimum": 0,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "total",
+ "audited",
+ "unsupported"
+ ],
+ "type": "object"
+ },
+ "type": "object"
+ },
+ "total": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "unsupported": {
+ "minimum": 0,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "total",
+ "audited",
+ "unsupported",
+ "byLanguage"
+ ],
+ "type": "object"
+ },
+ "summary": {
+ "additionalProperties": false,
+ "properties": {
+ "auditCoverage": {
+ "enum": [
+ "complete",
+ "partial",
+ "none"
+ ]
+ },
+ "auditedProjectCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "projectCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "unsupportedProjectCount": {
+ "minimum": 0,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "projectCount",
+ "auditedProjectCount",
+ "unsupportedProjectCount",
+ "auditCoverage"
+ ],
+ "type": "object"
+ }
+ },
+ "required": [
+ "schemaVersion",
+ "root",
+ "summary",
+ "sourceFiles",
+ "counts",
+ "distributions",
+ "adapters"
+ ],
+ "title": "Project Stats Artifact",
+ "type": "object"
+}detect_projects2 fields changedInput schema / properties / repoRoot / descriptionPrevious value: -"Repository root path."New value: +"Readable repository directory whose project markers should be inspected."Output schema / (root)Previous value: -nullNew value: +{
+ "$id": "project-detection-v1.schema.json",
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "additionalProperties": false,
+ "properties": {
+ "projects": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "absoluteRoot": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "adapterIds": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "adapterMatches": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "adapterId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "matchedEcosystems": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "matchedLanguages": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "maturity": {
+ "enum": [
+ "supported",
+ "experimental",
+ "planned"
+ ]
+ }
+ },
+ "required": [
+ "adapterId",
+ "maturity",
+ "matchedEcosystems",
+ "matchedLanguages"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "ecosystems": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "id": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "languages": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "markerFiles": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "minItems": 1,
+ "type": "array"
+ },
+ "root": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "supportStatusReason": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "supported": {
+ "type": "boolean"
+ }
+ },
+ "required": [
+ "id",
+ "root",
+ "absoluteRoot",
+ "ecosystems",
+ "languages",
+ "markerFiles",
+ "adapterIds",
+ "adapterMatches",
+ "supported",
+ "supportStatusReason"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "root": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "schemaVersion": {
+ "const": "project-detection/v1"
+ },
+ "summary": {
+ "additionalProperties": false,
+ "properties": {
+ "projectCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "supportedProjectCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "unsupportedProjectCount": {
+ "minimum": 0,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "projectCount",
+ "supportedProjectCount",
+ "unsupportedProjectCount"
+ ],
+ "type": "object"
+ }
+ },
+ "required": [
+ "schemaVersion",
+ "root",
+ "projects",
+ "summary"
+ ],
+ "title": "Project Detection Artifact",
+ "type": "object"
+}explain_target3 fields changedInput schema / properties / audit / descriptionPrevious value: -"An audit/v1 artifact."New value: +"The audit/v1 object returned by audit_repo or contained in projectAudits.audits[].audit; pass the artifact itself, not a file path."Input schema / properties / targetId / descriptionPrevious value: -"Stable audit target id."New value: +"Exact stable id from an audit target in untestedCandidates, coveredButRisky, recommended, or skipped."Output schema / (root)Previous value: -nullNew value: +{
+ "$id": "https://repo-test-architect.local/schemas/target-explanation-v1.schema.json",
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "additionalProperties": false,
+ "properties": {
+ "category": {
+ "enum": [
+ "untestedCandidates",
+ "coveredButRisky",
+ "skipped"
+ ]
+ },
+ "existingTestEvidence": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "kind": {
+ "type": "string"
+ },
+ "strength": {
+ "enum": [
+ "naming",
+ "direct",
+ "referenced",
+ "indirect"
+ ]
+ },
+ "testPath": {
+ "type": "string"
+ },
+ "usage": {
+ "enum": [
+ "called",
+ "asserted"
+ ]
+ },
+ "viaUsage": {
+ "enum": [
+ "called",
+ "asserted"
+ ]
+ }
+ },
+ "required": [
+ "testPath",
+ "kind",
+ "strength"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "existingTestPaths": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "kind": {
+ "type": "string"
+ },
+ "maintenanceCost": {
+ "maximum": 10,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "path": {
+ "type": "string"
+ },
+ "rationale": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "recommendation": {
+ "enum": [
+ "test",
+ "defer"
+ ]
+ },
+ "risk": {
+ "enum": [
+ "low",
+ "medium",
+ "high"
+ ]
+ },
+ "riskReductionScore": {
+ "maximum": 10,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "schemaVersion": {
+ "const": "target-explanation/v1"
+ },
+ "signals": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "target": {
+ "type": "string"
+ },
+ "targetId": {
+ "type": "string"
+ },
+ "testLevel": {
+ "enum": [
+ "unit",
+ "integration",
+ "component",
+ "ui",
+ "none"
+ ]
+ },
+ "testability": {
+ "enum": [
+ "low",
+ "medium",
+ "high"
+ ]
+ }
+ },
+ "required": [
+ "schemaVersion",
+ "targetId",
+ "target",
+ "path",
+ "category",
+ "kind",
+ "recommendation",
+ "testLevel",
+ "risk",
+ "testability",
+ "riskReductionScore",
+ "maintenanceCost",
+ "signals",
+ "rationale",
+ "existingTestPaths"
+ ],
+ "title": "Repo Test Architect Target Explanation",
+ "type": "object"
+}generate_project_test_plan1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$id": "project-test-plan-v1.schema.json",
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "additionalProperties": false,
+ "properties": {
+ "items": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "action": {
+ "enum": [
+ "add-test",
+ "extend-test",
+ "defer"
+ ]
+ },
+ "adapterId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "existingTestEvidence": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "kind": {
+ "type": "string"
+ },
+ "strength": {
+ "enum": [
+ "naming",
+ "direct",
+ "referenced",
+ "indirect"
+ ]
+ },
+ "testPath": {
+ "type": "string"
+ },
+ "usage": {
+ "enum": [
+ "called",
+ "asserted"
+ ]
+ },
+ "viaUsage": {
+ "enum": [
+ "called",
+ "asserted"
+ ]
+ }
+ },
+ "required": [
+ "testPath",
+ "kind",
+ "strength"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "existingTestPaths": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "id": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "maintenanceCost": {
+ "maximum": 10,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "path": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "priority": {
+ "type": "integer"
+ },
+ "projectId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "projectItemId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "projectRoot": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "rationale": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "riskReductionScore": {
+ "maximum": 10,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "sourceSignals": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "target": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "targetId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "testLevel": {
+ "enum": [
+ "unit",
+ "integration",
+ "component",
+ "ui",
+ "none"
+ ]
+ }
+ },
+ "required": [
+ "projectId",
+ "projectRoot",
+ "adapterId",
+ "projectItemId",
+ "id",
+ "action",
+ "targetId",
+ "target",
+ "path",
+ "testLevel",
+ "priority",
+ "riskReductionScore",
+ "maintenanceCost",
+ "rationale",
+ "sourceSignals",
+ "existingTestPaths"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "projectPlans": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "adapterId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "plan": {
+ "additionalProperties": true,
+ "properties": {
+ "blockers": {
+ "type": "array"
+ },
+ "items": {
+ "type": "array"
+ },
+ "schemaVersion": {
+ "const": "plan/v1"
+ },
+ "summary": {
+ "type": "object"
+ }
+ },
+ "required": [
+ "schemaVersion",
+ "summary",
+ "blockers",
+ "items"
+ ],
+ "type": "object"
+ },
+ "projectId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "projectRoot": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "projectId",
+ "projectRoot",
+ "adapterId",
+ "plan"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "root": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "schemaVersion": {
+ "const": "project-test-plan/v1"
+ },
+ "summary": {
+ "additionalProperties": false,
+ "properties": {
+ "addTestCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "auditCoverage": {
+ "enum": [
+ "complete",
+ "partial",
+ "none"
+ ]
+ },
+ "deferredCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "extendTestCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "itemCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "plannedProjectCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "projectCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "unsupportedProjectCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "unsupportedReasons": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array",
+ "uniqueItems": true
+ }
+ },
+ "required": [
+ "projectCount",
+ "plannedProjectCount",
+ "unsupportedProjectCount",
+ "auditCoverage",
+ "unsupportedReasons",
+ "addTestCount",
+ "extendTestCount",
+ "deferredCount",
+ "itemCount"
+ ],
+ "type": "object"
+ },
+ "unsupportedProjects": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "adapterMatches": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "adapterId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "matchedEcosystems": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "matchedLanguages": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "maturity": {
+ "enum": [
+ "supported",
+ "experimental",
+ "planned"
+ ]
+ }
+ },
+ "required": [
+ "adapterId",
+ "maturity",
+ "matchedEcosystems",
+ "matchedLanguages"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "ecosystems": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "languages": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "projectId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "projectRoot": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "supportStatusReason": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "projectId",
+ "projectRoot",
+ "reason",
+ "ecosystems",
+ "languages",
+ "adapterMatches",
+ "supportStatusReason"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "schemaVersion",
+ "root",
+ "summary",
+ "unsupportedProjects",
+ "projectPlans",
+ "items"
+ ],
+ "title": "Project Test Plan Artifact",
+ "type": "object"
+}generate_selected_test1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$id": "https://repo-test-architect.local/schemas/generation-deferred-v1.schema.json",
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "additionalProperties": false,
+ "properties": {
+ "nextSteps": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "planItemId": {
+ "type": "string"
+ },
+ "reason": {
+ "type": "string"
+ },
+ "schemaVersion": {
+ "const": "generation-deferred/v1"
+ },
+ "status": {
+ "const": "deferred"
+ }
+ },
+ "required": [
+ "schemaVersion",
+ "planItemId",
+ "status",
+ "reason",
+ "nextSteps"
+ ],
+ "title": "Repo Test Architect Generation Deferred",
+ "type": "object"
+}generate_test_plan3 fields changedInput schema / properties / audit / descriptionPrevious value: -"An audit/v1 artifact."New value: +"The audit/v1 object returned by audit_repo or contained in projectAudits.audits[].audit; pass the artifact itself, not a file path."Input schema / properties / itemId / descriptionPrevious value: -"Optional stable plan item id to select."New value: +"Optional exact plan item id to return; omit it to return the complete deterministic plan."Output schema / (root)Previous value: -nullNew value: +{
+ "$id": "https://repo-test-architect.local/schemas/plan-v1.schema.json",
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "additionalProperties": false,
+ "properties": {
+ "blockers": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "items": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "action": {
+ "enum": [
+ "add-test",
+ "extend-test",
+ "defer"
+ ]
+ },
+ "existingTestEvidence": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "kind": {
+ "type": "string"
+ },
+ "strength": {
+ "enum": [
+ "naming",
+ "direct",
+ "referenced",
+ "indirect"
+ ]
+ },
+ "testPath": {
+ "type": "string"
+ },
+ "usage": {
+ "enum": [
+ "called",
+ "asserted"
+ ]
+ },
+ "viaUsage": {
+ "enum": [
+ "called",
+ "asserted"
+ ]
+ }
+ },
+ "required": [
+ "testPath",
+ "kind",
+ "strength"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "existingTestPaths": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "id": {
+ "type": "string"
+ },
+ "maintenanceCost": {
+ "maximum": 10,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "path": {
+ "type": "string"
+ },
+ "priority": {
+ "type": "integer"
+ },
+ "rationale": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "riskReductionScore": {
+ "maximum": 10,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "sourceSignals": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "target": {
+ "type": "string"
+ },
+ "targetId": {
+ "type": "string"
+ },
+ "testLevel": {
+ "enum": [
+ "unit",
+ "integration",
+ "component",
+ "ui",
+ "none"
+ ]
+ }
+ },
+ "required": [
+ "id",
+ "action",
+ "targetId",
+ "target",
+ "path",
+ "testLevel",
+ "priority",
+ "riskReductionScore",
+ "maintenanceCost",
+ "rationale",
+ "sourceSignals",
+ "existingTestPaths"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "schemaVersion": {
+ "const": "plan/v1"
+ },
+ "summary": {
+ "additionalProperties": false,
+ "properties": {
+ "addTestCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "blockerCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "confidence": {
+ "enum": [
+ "low",
+ "medium",
+ "high"
+ ]
+ },
+ "deferredCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "extendTestCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "verificationCommand": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "confidence",
+ "blockerCount",
+ "addTestCount",
+ "extendTestCount",
+ "deferredCount"
+ ],
+ "type": "object"
+ }
+ },
+ "required": [
+ "schemaVersion",
+ "summary",
+ "blockers",
+ "items"
+ ],
+ "title": "Repo Test Architect Test Plan",
+ "type": "object"
+}get_audit_graph1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$defs": {
+ "auditTarget": {
+ "additionalProperties": false,
+ "properties": {
+ "existingTestEvidence": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "kind": {
+ "enum": [
+ "filename-convention",
+ "direct-relative-import",
+ "referenced-relative-reexport",
+ "tsconfig-path-import",
+ "package-entry-import",
+ "bounded-dependency",
+ "browser-route-match",
+ "csharp-symbol-reference",
+ "csharp-test-helper",
+ "swift-symbol-reference",
+ "python-module-import",
+ "python-package-reexport",
+ "python-pytest-fixture",
+ "python-test-client-route",
+ "jvm-symbol-reference",
+ "go-symbol-reference",
+ "go-source-dependency",
+ "rust-symbol-reference",
+ "ruby-constant-reference",
+ "php-symbol-reference",
+ "elixir-module-reference"
+ ]
+ },
+ "strength": {
+ "enum": [
+ "naming",
+ "direct",
+ "referenced",
+ "indirect"
+ ]
+ },
+ "testPath": {
+ "type": "string"
+ },
+ "usage": {
+ "enum": [
+ "called",
+ "asserted"
+ ]
+ },
+ "viaUsage": {
+ "enum": [
+ "called",
+ "asserted"
+ ]
+ }
+ },
+ "required": [
+ "testPath",
+ "kind",
+ "strength"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "existingTestPaths": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "id": {
+ "type": "string"
+ },
+ "kind": {
+ "type": "string"
+ },
+ "maintenanceCost": {
+ "maximum": 10,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "name": {
+ "type": "string"
+ },
+ "path": {
+ "type": "string"
+ },
+ "reasons": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "recommendedTestLevel": {
+ "enum": [
+ "unit",
+ "integration",
+ "component",
+ "ui",
+ "none"
+ ]
+ },
+ "risk": {
+ "enum": [
+ "low",
+ "medium",
+ "high"
+ ]
+ },
+ "riskReductionScore": {
+ "maximum": 10,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "signals": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "testability": {
+ "enum": [
+ "low",
+ "medium",
+ "high"
+ ]
+ }
+ },
+ "required": [
+ "name",
+ "id",
+ "path",
+ "kind",
+ "signals",
+ "risk",
+ "testability",
+ "recommendedTestLevel",
+ "riskReductionScore",
+ "maintenanceCost",
+ "reasons",
+ "existingTestPaths"
+ ],
+ "type": "object"
+ },
+ "skippedTarget": {
+ "additionalProperties": false,
+ "properties": {
+ "id": {
+ "type": "string"
+ },
+ "kind": {
+ "type": "string"
+ },
+ "maintenanceCost": {
+ "maximum": 10,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "name": {
+ "type": "string"
+ },
+ "path": {
+ "type": "string"
+ },
+ "preferredCoveragePath": {
+ "type": "string"
+ },
+ "reason": {
+ "type": "string"
+ },
+ "riskReductionScore": {
+ "maximum": 10,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "signals": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "name",
+ "id",
+ "path",
+ "kind",
+ "signals",
+ "riskReductionScore",
+ "maintenanceCost",
+ "reason"
+ ],
+ "type": "object"
+ }
+ },
+ "$id": "https://repo-test-architect.local/schemas/audit-v1.schema.json",
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "additionalProperties": false,
+ "properties": {
+ "coveredButRisky": {
+ "items": {
+ "$ref": "#/$defs/auditTarget"
+ },
+ "type": "array"
+ },
+ "profile": {
+ "additionalProperties": false,
+ "properties": {
+ "architectures": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "blockers": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "confidence": {
+ "enum": [
+ "low",
+ "medium",
+ "high"
+ ]
+ },
+ "detectedConventions": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "existingTestLocations": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "languages": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "packageManagers": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "root": {
+ "type": "string"
+ },
+ "setupSignals": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "testCommand": {
+ "type": "string"
+ },
+ "testFrameworks": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "root",
+ "languages",
+ "packageManagers",
+ "testFrameworks",
+ "architectures",
+ "detectedConventions",
+ "existingTestLocations",
+ "setupSignals",
+ "confidence",
+ "blockers"
+ ],
+ "type": "object"
+ },
+ "recommended": {
+ "items": {
+ "$ref": "#/$defs/auditTarget"
+ },
+ "type": "array"
+ },
+ "risks": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "schemaVersion": {
+ "const": "audit/v1"
+ },
+ "skipped": {
+ "items": {
+ "$ref": "#/$defs/skippedTarget"
+ },
+ "type": "array"
+ },
+ "untestedCandidates": {
+ "items": {
+ "$ref": "#/$defs/auditTarget"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "schemaVersion",
+ "profile",
+ "untestedCandidates",
+ "coveredButRisky",
+ "recommended",
+ "skipped",
+ "risks"
+ ],
+ "title": "Repo Test Architect Audit",
+ "type": "object"
+}get_plan_execution_hints1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$id": "https://repo-test-architect.local/schemas/plan-execution-hints-v1.schema.json",
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "additionalProperties": false,
+ "properties": {
+ "items": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "action": {
+ "enum": [
+ "add-test",
+ "extend-test",
+ "defer"
+ ]
+ },
+ "adapterId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "complexity": {
+ "enum": [
+ "low",
+ "medium",
+ "high"
+ ]
+ },
+ "contextScope": {
+ "additionalProperties": false,
+ "properties": {
+ "includeBuildConfiguration": {
+ "type": "boolean"
+ },
+ "includeRepositoryInstructions": {
+ "const": true
+ },
+ "mode": {
+ "enum": [
+ "target-only",
+ "target-and-tests",
+ "project-boundary"
+ ]
+ },
+ "paths": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "minItems": 1,
+ "type": "array",
+ "uniqueItems": true
+ }
+ },
+ "required": [
+ "mode",
+ "paths",
+ "includeBuildConfiguration",
+ "includeRepositoryInstructions"
+ ],
+ "type": "object"
+ },
+ "parallelizable": {
+ "type": "boolean"
+ },
+ "path": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "planItemId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "projectId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "projectRoot": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reasons": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "minItems": 1,
+ "type": "array"
+ },
+ "recommendedAgentRole": {
+ "enum": [
+ "implementation",
+ "repository-reasoning",
+ "review"
+ ]
+ },
+ "requiresRepositoryReasoning": {
+ "type": "boolean"
+ },
+ "target": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "planItemId",
+ "action",
+ "target",
+ "path",
+ "complexity",
+ "contextScope",
+ "parallelizable",
+ "recommendedAgentRole",
+ "requiresRepositoryReasoning",
+ "reasons"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "schemaVersion": {
+ "const": "plan-execution-hints/v1"
+ },
+ "source": {
+ "additionalProperties": false,
+ "properties": {
+ "itemCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "root": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "schemaVersion": {
+ "enum": [
+ "plan/v1",
+ "project-test-plan/v1"
+ ]
+ }
+ },
+ "required": [
+ "schemaVersion",
+ "itemCount"
+ ],
+ "type": "object"
+ },
+ "summary": {
+ "additionalProperties": false,
+ "properties": {
+ "highComplexityCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "itemCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "lowComplexityCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "mediumComplexityCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "parallelizableCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "repositoryReasoningCount": {
+ "minimum": 0,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "itemCount",
+ "lowComplexityCount",
+ "mediumComplexityCount",
+ "highComplexityCount",
+ "parallelizableCount",
+ "repositoryReasoningCount"
+ ],
+ "type": "object"
+ }
+ },
+ "required": [
+ "schemaVersion",
+ "source",
+ "summary",
+ "items"
+ ],
+ "title": "Repo Test Architect Plan Execution Hints",
+ "type": "object"
+}list_adapters1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$id": "adapter-registry-v1.schema.json",
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "additionalProperties": false,
+ "properties": {
+ "adapters": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "ecosystems": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "minItems": 1,
+ "type": "array"
+ },
+ "emittedArtifacts": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "minItems": 1,
+ "type": "array"
+ },
+ "id": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "languages": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "minItems": 1,
+ "type": "array"
+ },
+ "maturity": {
+ "enum": [
+ "supported",
+ "experimental",
+ "planned"
+ ]
+ },
+ "supportedProjectTypes": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "supportedTestFrameworks": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "id",
+ "ecosystems",
+ "languages",
+ "maturity",
+ "supportedTestFrameworks",
+ "supportedProjectTypes",
+ "emittedArtifacts"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "schemaVersion": {
+ "const": "adapter-registry/v1"
+ }
+ },
+ "required": [
+ "schemaVersion",
+ "adapters"
+ ],
+ "title": "Adapter Registry Artifact",
+ "type": "object"
+}list_project_detection_rules1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$id": "project-detection-rules-v1.schema.json",
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "additionalProperties": false,
+ "properties": {
+ "fallbackRules": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "ignoredDirectories": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "markers": {
+ "items": {
+ "additionalProperties": false,
+ "oneOf": [
+ {
+ "required": [
+ "fileName"
+ ]
+ },
+ {
+ "required": [
+ "extension"
+ ]
+ },
+ {
+ "required": [
+ "directoryExtension"
+ ]
+ }
+ ],
+ "properties": {
+ "directoryExtension": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "ecosystem": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "extension": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "fileName": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "languages": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "minItems": 1,
+ "type": "array"
+ }
+ },
+ "required": [
+ "ecosystem",
+ "languages"
+ ],
+ "type": "object"
+ },
+ "minItems": 1,
+ "type": "array"
+ },
+ "schemaVersion": {
+ "const": "project-detection-rules/v1"
+ }
+ },
+ "required": [
+ "schemaVersion",
+ "markers",
+ "ignoredDirectories"
+ ],
+ "title": "Project Detection Rules Artifact",
+ "type": "object"
+}rank_project_candidates1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$id": "project-candidate-ranking-v1.schema.json",
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "additionalProperties": false,
+ "properties": {
+ "candidates": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "adapterId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "category": {
+ "enum": [
+ "untested",
+ "covered-but-risky"
+ ]
+ },
+ "existingTestEvidence": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "kind": {
+ "type": "string"
+ },
+ "strength": {
+ "enum": [
+ "naming",
+ "direct",
+ "referenced",
+ "indirect"
+ ]
+ },
+ "testPath": {
+ "type": "string"
+ },
+ "usage": {
+ "enum": [
+ "called",
+ "asserted"
+ ]
+ },
+ "viaUsage": {
+ "enum": [
+ "called",
+ "asserted"
+ ]
+ }
+ },
+ "required": [
+ "testPath",
+ "kind",
+ "strength"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "existingTestPaths": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "kind": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "maintenanceCost": {
+ "maximum": 10,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "path": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "priority": {
+ "type": "integer"
+ },
+ "projectId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "projectRoot": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "projectTargetId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "rationale": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "riskReductionScore": {
+ "maximum": 10,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "signals": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "target": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "targetId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "testLevel": {
+ "enum": [
+ "unit",
+ "integration",
+ "component",
+ "ui",
+ "none"
+ ]
+ }
+ },
+ "required": [
+ "projectId",
+ "projectRoot",
+ "adapterId",
+ "projectTargetId",
+ "targetId",
+ "target",
+ "path",
+ "category",
+ "kind",
+ "testLevel",
+ "priority",
+ "riskReductionScore",
+ "maintenanceCost",
+ "signals",
+ "rationale",
+ "existingTestPaths"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "root": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "schemaVersion": {
+ "const": "project-candidate-ranking/v1"
+ },
+ "summary": {
+ "additionalProperties": false,
+ "properties": {
+ "auditCoverage": {
+ "enum": [
+ "complete",
+ "partial",
+ "none"
+ ]
+ },
+ "auditedProjectCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "candidateCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "projectCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "unsupportedProjectCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "unsupportedReasons": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array",
+ "uniqueItems": true
+ }
+ },
+ "required": [
+ "projectCount",
+ "auditedProjectCount",
+ "unsupportedProjectCount",
+ "auditCoverage",
+ "unsupportedReasons",
+ "candidateCount"
+ ],
+ "type": "object"
+ },
+ "unsupportedProjects": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "adapterMatches": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "adapterId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "matchedEcosystems": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "matchedLanguages": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "maturity": {
+ "enum": [
+ "supported",
+ "experimental",
+ "planned"
+ ]
+ }
+ },
+ "required": [
+ "adapterId",
+ "maturity",
+ "matchedEcosystems",
+ "matchedLanguages"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "ecosystems": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "languages": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "projectId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "projectRoot": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "supportStatusReason": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "projectId",
+ "projectRoot",
+ "reason",
+ "ecosystems",
+ "languages",
+ "adapterMatches",
+ "supportStatusReason"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "schemaVersion",
+ "root",
+ "summary",
+ "unsupportedProjects",
+ "candidates"
+ ],
+ "title": "Project Candidate Ranking Artifact",
+ "type": "object"
+}rank_test_candidates1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$id": "https://repo-test-architect.local/schemas/candidate-ranking-v1.schema.json",
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "additionalProperties": false,
+ "properties": {
+ "blockers": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "candidates": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "category": {
+ "enum": [
+ "untested",
+ "covered-but-risky"
+ ]
+ },
+ "existingTestEvidence": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "kind": {
+ "type": "string"
+ },
+ "strength": {
+ "enum": [
+ "naming",
+ "direct",
+ "referenced",
+ "indirect"
+ ]
+ },
+ "testPath": {
+ "type": "string"
+ },
+ "usage": {
+ "enum": [
+ "called",
+ "asserted"
+ ]
+ },
+ "viaUsage": {
+ "enum": [
+ "called",
+ "asserted"
+ ]
+ }
+ },
+ "required": [
+ "testPath",
+ "kind",
+ "strength"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "existingTestPaths": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "kind": {
+ "type": "string"
+ },
+ "maintenanceCost": {
+ "maximum": 10,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "path": {
+ "type": "string"
+ },
+ "priority": {
+ "type": "integer"
+ },
+ "rationale": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "riskReductionScore": {
+ "maximum": 10,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "signals": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "target": {
+ "type": "string"
+ },
+ "targetId": {
+ "type": "string"
+ },
+ "testLevel": {
+ "enum": [
+ "unit",
+ "integration",
+ "component",
+ "ui",
+ "none"
+ ]
+ }
+ },
+ "required": [
+ "targetId",
+ "target",
+ "path",
+ "category",
+ "kind",
+ "testLevel",
+ "priority",
+ "riskReductionScore",
+ "maintenanceCost",
+ "signals",
+ "rationale",
+ "existingTestPaths"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "schemaVersion": {
+ "const": "candidate-ranking/v1"
+ },
+ "summary": {
+ "additionalProperties": false,
+ "properties": {
+ "blockerCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "candidateCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "confidence": {
+ "enum": [
+ "low",
+ "medium",
+ "high"
+ ]
+ },
+ "verificationCommand": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "confidence",
+ "candidateCount",
+ "blockerCount"
+ ],
+ "type": "object"
+ }
+ },
+ "required": [
+ "schemaVersion",
+ "summary",
+ "blockers",
+ "candidates"
+ ],
+ "title": "Repo Test Architect Candidate Ranking",
+ "type": "object"
+}summarize_project_audits1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$id": "project-audit-summary-v1.schema.json",
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "additionalProperties": false,
+ "properties": {
+ "projects": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "adapterId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "confidence": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "coveredButRiskyCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "projectId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "projectRoot": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "riskCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "skippedTargetCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "testCommand": {
+ "type": "string"
+ },
+ "topCandidateIds": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "untestedCandidateCount": {
+ "minimum": 0,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "projectId",
+ "projectRoot",
+ "adapterId",
+ "confidence",
+ "untestedCandidateCount",
+ "coveredButRiskyCount",
+ "skippedTargetCount",
+ "riskCount",
+ "topCandidateIds"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "root": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "schemaVersion": {
+ "const": "project-audit-summary/v1"
+ },
+ "summary": {
+ "additionalProperties": false,
+ "properties": {
+ "auditCoverage": {
+ "enum": [
+ "complete",
+ "partial",
+ "none"
+ ]
+ },
+ "auditedProjectCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "coveredButRiskyCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "projectCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "riskCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "skippedTargetCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "unsupportedProjectCount": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "unsupportedReasons": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array",
+ "uniqueItems": true
+ },
+ "untestedCandidateCount": {
+ "minimum": 0,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "projectCount",
+ "auditedProjectCount",
+ "unsupportedProjectCount",
+ "auditCoverage",
+ "unsupportedReasons",
+ "untestedCandidateCount",
+ "coveredButRiskyCount",
+ "skippedTargetCount",
+ "riskCount"
+ ],
+ "type": "object"
+ },
+ "unsupportedProjects": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "adapterMatches": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "adapterId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "matchedEcosystems": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "matchedLanguages": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "maturity": {
+ "enum": [
+ "supported",
+ "experimental",
+ "planned"
+ ]
+ }
+ },
+ "required": [
+ "adapterId",
+ "maturity",
+ "matchedEcosystems",
+ "matchedLanguages"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "ecosystems": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "languages": {
+ "items": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "projectId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "projectRoot": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "supportStatusReason": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "projectId",
+ "projectRoot",
+ "reason",
+ "ecosystems",
+ "languages",
+ "adapterMatches",
+ "supportStatusReason"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "schemaVersion",
+ "root",
+ "summary",
+ "projects",
+ "unsupportedProjects"
+ ],
+ "title": "Project Audit Summary Artifact",
+ "type": "object"
+}v0.1.0analyze_project_test_placementanalyze_repositoryanalyze_test_placementaudit_projectsaudit_repocollect_project_findingscollect_project_statsdetect_projectsexplain_targetgenerate_project_test_plangenerate_selected_testgenerate_test_planget_audit_graphget_plan_execution_hintslist_adapterslist_project_detection_rulesrank_project_candidatesrank_test_candidatessummarize_project_auditsScored across 19 tools
The descriptions do distinguish single-project versus multi-project variants, but many tools produce overlapping outputs that analyze_repository already includes, such as summaries, rankings, findings, plans, and stats. This creates avoidable misselection risk despite the explanatory wording.
The tool names use a predictable snake_case verb_noun pattern throughout, with paired single-project and project-level variants named consistently. Minor verb choices like get, generate, collect, and summarize do not break the overall predictability.
At 19 tools, the surface is heavy for an audit and planning server, especially because several operations are redundant wrappers around artifacts already assembled by analyze_repository. The count is not extreme, but it is borderline over-fragmented.
The set covers discovery, auditing, summarization, ranking, planning, placement analysis, stats, and target explanation fairly well. However, generate_selected_test is explicitly deferred and non-functional, leaving a notable dead end in the generation lifecycle.
Enterprise code intelligence for M&A, security audits, and tech debt. Hosted server with 200k free.
Repository knowledge graph MCP server for codebase understanding and debugging.
The Cortex MCP server provides read-only access to real-time engineering context from the Cortex developer portal, allowing AI coding assistants to answer natural language questions about your organization's catalog (microservices, libraries, domains, teams, infrastructure), scorecards (engineering standards and best practices), initiatives (goals and deadlines), and Engineering Intelligence metrics. It includes tools for querying documentation, tracking personal entities, and accessing AI-assisted insights across the entire Cortex ecosystem.
Detects database migration table locks, terraform cost leaks, and OWASP API flaws.
