Same merge gate, third artifact class: turning the classifier on our own MCP server

Findings

2 baseline observations, 2 post-retrofit shifts, 1 pattern-accumulation finding. Each finding cites the exact data from the linter run, the surface affected, and the consumer impact. There is no "breaking" partition on this report because no tool wire signature was modified; the work is a docstring improvement, classified deterministically.

1. baseline statefinding F1
   change type: aggregate_grade C (mean 2.66 across 202 tools)
   surface: all delimit-mcp-server tools (server.py + delegated modules, 202 docstrings classified)

   The pre-retrofit linter run scored 1 tool at A, 16 at B, 145 at C, and 40 at D. The aggregate mean across the six TDQS dimensions was 2.66, which rounds to a C. The Glama public badge state immediately before the retrofit shipped was A-license / C-quality / A-maintenance. The C is the data point this report exists to explain. A C-quality grade does not mean the tools were broken; the wire-shape behavior of every tool was unchanged. It means a Glama scorer reading the docstring alone, without running the tool, could not always tell which tool to pick, what the parameters meant in context, what the side-effect surface was, or when in a session the tool should fire. That gap is what TDQS measures, and the gap is what shipped fixed.

2. baseline statefinding F2
   change type: worst_5_baseline (mean 1.33, all governance namespace)
   surface: delimit_gov_health, delimit_gov_status, delimit_gov_policy, delimit_gov_run, delimit_gov_verify

   The five lowest-scoring tools at baseline all had a per-tool mean of 1.33, the floor of the scoring scale. Every one of them lived in the governance namespace, the namespace that owns the merge gate itself. The pattern is not a coincidence. The gov_* tools were among the earliest tools added to the server and the docstrings were written close to the implementation, when the author had full mental context and did not need the docstring to recover it. By the time TDQS classified them, the docstrings were terse, missing the side-effect contract, missing the disambiguation against neighboring tools, and missing the when-to-use guidance. The retrofit lifted all five into the A or B band by adding the missing dimensions truth-preservingly: nothing was claimed that the implementation did not deliver. The lift was a writing change, not a behavior change.

3. post-retrofit shiftfinding F3
   change type: aggregate_grade A (mean 4.52 across 202 tools)
   surface: all delimit-mcp-server tools after the LED-2109 retrofit

   The post-retrofit linter run scored 139 tools at A, 63 at B, 0 at C, and 0 at D. The aggregate mean rose from 2.66 to 4.52, which rounds to an A. The full per-dimension mean breakdown: side_effects 4.94, conciseness 3.88, coverage 4.11, parameter_semantics 4.47, disambiguation 4.82, when_to_use 4.93. Every C-grade and D-grade tool was lifted at least one full band; the lowest grade in the new distribution is B. The retrofit touched 197 of 202 docstrings; the remaining 5 were already at A on the baseline run and were left untouched. No tool wire signature was modified, no parameter renamed, no return shape changed. The shift is entirely in the docstring layer. A Pro user with the prior server installed locally at ~/.delimit/server/ keeps working exactly as before; the same MCP tool calls, the same return shapes, the same behavior. The retrofit is an additive doc improvement, classified deterministically by the same kind of gate that classifies OpenAPI diffs.

4. pattern accumulationfinding F4
   change type: kernel_application_3 (TDQS linter as inward-facing classifier)
   surface: ai/tdqs_lint.py (the new MCP tool delimit_tdqs_lint, LED-2108) plus 14 commits across 12 retrofit batches (LED-2109)

   The retrofit was driven by a new MCP tool, delimit_tdqs_lint, that classifies each docstring against the six TDQS dimensions deterministically and returns a per-tool grade plus the missing-dimension list. The tool lives at ai/tdqs_lint.py in the delimit-gateway repo, committed as part of PR #134. Once the linter existed, the retrofit ran as 12 batches of docstring edits, each batch ending with a re-run of the linter against the touched namespace and a commit when the namespace lifted. This is the same primitive Delimit ships externally as the merge gate on AI-written code: classify deterministically against a published taxonomy, fail closed on violations, produce a record. Pointed at OpenAPI specs, the primitive is a diff plus semver classifier. Pointed at autonomous-action proposals (the LED-193 daemon), the primitive is a precondition-and-PR gate that never auto-merges. Pointed inward at our own MCP tool definitions, the primitive is the TDQS linter. Same kernel, third artifact class. The classifier is not new; the artifact class is.

5. post-retrofit shiftfinding F5
   change type: test_delta (4539 to 4574, +35, all pass)
   surface: delimit-gateway test suite, pre and post the LED-2108 + LED-2109 work

   The gateway test count moved from 4539 to 4574 across the work, a delta of plus 35. Every test in the new total passes. The 35 added tests cover the new linter module: the per-dimension scorers, the aggregator, the (Pro) test contract preservation that fell out of one of the retrofit batches (commit f663e27), and the regression coverage that pins the post-retrofit grade at A so a future docstring edit cannot silently regress the band. The merge gate that runs on the delimit-gateway repo on every push exercised these tests on PR #134 before merge. A post-merge regression that drops a tool below B will fail the test suite and block the next push. The fail-closed property the merge gate ships externally also runs against the docstring layer of our own MCP tools.

Same kernel, three artifact classes

The Delimit governance kernel is small. It classifies an input against a published taxonomy, applies a fail-closed verdict on violations, and emits a record that any reader can replay. Three artifact classes have now run through it.

1. Merge gate on AI-written code. The product. The classifier is the 27-type OpenAPI diff taxonomy plus a deterministic semver bump rule. The fail-closed point is the breaking-change partition. The record is a signed, replayable attestation per pull request. Reports 1 through 7 in this series exercise this surface against external vendor APIs.
2. LED-193 daemon on autonomous actions. An internal application. The classifier is the per-action precondition contract. The fail-closed point is a precondition mismatch (commit 4a391aa tightened the skipped-versus-failed semantics on this surface). The record is a per-tick PR-only output that never auto-merges. Same primitive, applied to the autonomous-action artifact class.
3. TDQS linter on tool definitions. This report. The classifier is the six-dimension TDQS taxonomy. The fail-closed point is any tool below the threshold band. The record is the per-tool grade plus the aggregate distribution. Same primitive, applied to the MCP tool definition artifact class.

The reading is straight: classify deterministically, fail closed on violations, produce signed evidence, and the same kernel runs against whichever artifact class you point it at. The merge gate is not a feature limited to OpenAPI; the OpenAPI diff is the shipped surface. The kernel underneath is general.

What this report is not

Not a marketing reframe. The product Delimit sells is the merge gate for AI-written code, with a signed, replayable attestation as the productized output. TDQS on our own MCP tool definitions is depth signal, not a new product wedge. The point of writing it up under the same worked-example taxonomy is to make the kernel visible: the same primitive that classifies an OpenAPI diff classifies a docstring, and the same fail-closed verdict that blocks a breaking change blocks a C-graded docstring shipping in the public catalog.

Not a defect claim against Glama, who shipped TDQS publicly and gave the directory a useful new dimension. The C-quality baseline was on us; the docstrings were terse because they were written close to the implementation. The retrofit is the disciplined response: read the public classifier, build our own deterministic implementation of the same taxonomy, run it against our surface, and lift the grade truth-preservingly. Glama's next public scrape of the badge will see whatever its scorer sees on the retrofitted docstrings; that result is independent of this report.

The attestation artifact

A Delimit attestation is a bounded evidence record at a single commit pair. The pre-merge gateway commit on this run is db7c46d (the parent of the merge); the post-merge commit is 2993c6d (the squash-merge of PR #134 onto main). The same Delimit version run against the same two commits produces the same per-tool grade table; that is the replayable property. The attestation does not opine on whether a docstring rewrite is "good writing"; it opines on whether the docstring satisfies each of the six TDQS dimensions deterministically, and it emits the per-tool grade plus the per-dimension breakdown. A clean A is as much an artifact as a fail; a fail with a per-dimension miss inventory is an even denser artifact, because every line is something the docstring author knows to fix.

For the precise list of checks, the explicit out-of-scope list, and the reproducibility guarantee, see the attestation methodology v1. This report is the MCP-tool-definition surface of the same primitive that powers the merge gate for AI-written code.

Reproduce locally

Anyone can re-run the linter against the same two commits and verify the same per-tool grade table comes out. The full command sequence:

# Clone the gateway at the merge commit
git clone https://github.com/delimit-ai/delimit-gateway.git
cd delimit-gateway

# Baseline run (pre-merge parent)
git checkout db7c46d
python -m ai.tdqs_lint --all > /tmp/tdqs-baseline.json

# Post-retrofit run (merge commit)
git checkout 2993c6d
python -m ai.tdqs_lint --all > /tmp/tdqs-postretrofit.json

# Compare aggregate grades
python -c "
import json
b = json.load(open('/tmp/tdqs-baseline.json'))
n = json.load(open('/tmp/tdqs-postretrofit.json'))
print('baseline:', b['aggregate'])
print('postretrofit:', n['aggregate'])
"

If the bytes you get differ from the bytes in this report, that is itself a finding worth reporting; raise it on the Delimit repo and we will look. The two commits above are content-addressed by their SHAs; db7c46d is the parent of the squash-merge of PR #134 (so the linter sees the pre-retrofit docstring state), and 2993c6d is the squash-merge itself (so the linter sees the post-retrofit state). The linter module is at ai/tdqs_lint.py on the merge commit; it is not present on the parent. The baseline-run command above runs the merge-commit copy of the linter against the parent-commit docstrings, which isolates the docstring change from the linter change.