Skip to content

Releases

CodeWitness 1.0.26

Choose a tag to compare

@github-actions github-actions released this 09 Nov 15:04

CodeWitness 1.0.26 removes three pieces of dead code the compiler cannot see and splits the report's densest
method. It exists because a second static analyser — GooseBuckle — was pointed at this repository, and the most
useful result of that exercise was discovering that most of what it reported was wrong: after checking every
finding against the source, 3 of its 144 were genuine defects, 12 were the tool's own false positives (filed in
its journal as GB-86EB2C52, GB-281F773D, GB-4C945B5D and GB-17B09680), and the remainder were design
choices or complexity measures on code that is deliberately long. What landed is what survived that check.

What changed

  • Three dead assignments are gone. PythonDependencyAnalyzer.analyseDependencies built a ProjectInfo it
    never read — the method works from context.projectRoot() — and VerificationEngine.recordDatabase assigned
    each of its two DATABASE_FIXTURE evidence records to a local evidence that neither branch ever read. The
    ledger.add(...) calls stay, because the record is the point and the local never was. This is the shape
    GB-QLT-UNU-001 exists to catch, and it caught one of the two in the engine and missed the other.

  • HtmlReportWriter.appendEnvironment is four methods instead of one. It was 79 lines at cognitive
    complexity 59 and cyclomatic complexity 35 — the highest complexity density in the tree, ahead of
    VerificationEngine.verify's 73 over 388 lines. It is now appendEnvironment (12 lines: resolve the snapshot
    and the run, open the section, make three calls) over appendSnapshot (the toolchain keys and the two
    timestamps, with the run's own clock as the fallback), appendPhases (the phase table, including the phases
    that were skipped) and appendBudget (the limits, the usage, and the warning when a limit truncated the run).
    The two if/else pairs became early returns, so every literal and the emission order are unchanged, and each
    new helper takes two or three parameters — under the threshold of the rule that would otherwise have flagged
    the extraction itself.

  • Measured effect. GooseBuckle 0.2.5 over this tree reports 140 findings where it reported 144: the three
    dead locals and both appendEnvironment complexity findings are gone, and no finding was added. The
    duplication count is unchanged at 69, which is the intended outcome — nothing was rearranged to move a number.

What this does not fix

  • The four long verify methods are untouched. VerificationEngine.verify is 388 lines at cognitive 73 and
    cyclomatic 53; GeneratedTestsStrategy.verify is 201, ExistingTestsStrategy.verify 185 and
    StaticAnalysisStrategy.verify 154. All four are guard-clause sequences, and the obvious extraction trades a
    long-function finding for a seven-parameter helper — the same smell wearing a hat. Decomposing the engine's
    phase method is a change of its own, and it is not a drive-by in a release that is otherwise subtractive.

  • The two files over the project's own 2000-line threshold stay over it: VerificationEngine.java at 2340
    and SqliteVerificationStore.java at 2186. The repository's notes record the engine as decomposed from 1,829
    lines, so this is a documented drift rather than a new one, and it deserves its own slice.

  • 69 cross-adapter duplication findings remain. They are real — CppSourceScan against CSharpSourceScan,
    CppXml against CSharpXml, the mutation testers and the test contexts — but they are a design decision
    across 16 sibling adapters, and the repair is to lift the shared shapes into codewitness-adapter-support,
    not 69 individual edits.

  • 11 GB-QLT-UNU-001 findings remain and are wrong. Each names a local that is used later in the method that
    declares it. They disappear when GooseBuckle fixes GB-86EB2C52; they are not worked around here.

Verified for this release

  • Full reactor suite: 1,785 tests, 0 failures, 0 errors, 0 skipped — the same count as 1.0.25, because both
    changes are behaviour-preserving and neither needed a new test to describe a behaviour that nothing changed.
  • The dead-code guard was proved to fire. Deleting the ledger.add(...) call for the unprepared-database
    record — the call whose local was removed — failed VerificationEngineTest.anUnpreparedDatabaseIsReported at
    line 222 with "…EV-005 [DEPENDENCY_SCAN/INCONCLUSIVE…] ==> expected: but was: ", i.e. the run
    carried no DATABASE_FIXTURE record. The call was restored and the suite is green.
  • The refactor's invariant is asserted, not assumed. HtmlReportWriterTest requires the report's section
    ids, environment among them, and the HTML assertions run over the extracted methods; the emission order and
    every literal were carried across by hand and are byte-identical in source.
  • Self-check against the built jar (./codewitness verify . --requirements selfcheck/requirements.yaml --config selfcheck/codewitness.yaml --no-mutation --max-duration 30m): all seven ground rules VERIFIED,
    1,785 tests executed and passed, 0 findings — five suppressed with their reasons — coverage 71.3% line
    (25,791/36,155) and 59.6% branch, 30 resolved dependencies with 0 advisories from OSV, exit 0 in 1 m 56 s.
    Run CW-2026-11-09-JYY36. selfcheck/README.md quotes this run.
  • ./codewitness version prints codewitness 1.0.26.

Process note

The refactor was aimed at the wrong function first, and a measurement was the reason. GooseBuckle reported
ConfigLoader.parse as spanning 473 lines, which made it the single largest function in the tree and the obvious
place to start. Brace-matching that finding against the source showed the method closes at line 253 and is 129
lines — under the rule's own 150-line threshold — and that 11 of the 15 long-function findings on this tree name
an end line past the function, sometimes the end of the file. Only four were real, and the work moved to
appendEnvironment, which the same tool measures correctly and which has the worst complexity density of
anything it found.

The lesson is the one this project already applies to its own evidence, pointed at somebody else's: "the project's
own tests pass"
is not proof, and neither is another tool's line count. A finding is evidence only after the
thing it describes has been looked at. Checking first cost one brace-matcher; refactoring first would have
rewritten a 129-line method that needed nothing, and the release note would have claimed it was 473 lines long.

Compatibility

  • No CLI command, flag, exit code, report key, SARIF profile, codewitness.yaml key or adapter-SPI change. Every
    change is inside a method body, a private helper or a declaration that nothing read.
  • No public API change: HtmlReportWriter's new methods are private, ConfigLoader is untouched, and both
    edited classes keep their signatures and their behaviour.
  • The rendered report.html is unchanged, section for section and byte for byte — the split moved code, not text.

CodeWitness 1.0.25

Choose a tag to compare

@github-actions github-actions released this 09 Nov 14:28

CodeWitness 1.0.25 gives the MCP server a voice: codewitness mcp now prints one line on standard error as it
starts listening — version, protocol revision and the tools it is about to advertise. A stdio MCP server is silent
by protocol and the harness that spawns it logs nothing when a connection succeeds, so "the server came up" and
"the server never came up" were indistinguishable from the outside. The diagnostics stream is now injected rather
than named, so the test asserts the channel an operator actually reads.

What changed

  • The MCP server announces itself once, on standard error, as it starts listening. The line is
    [codewitness] MCP server ready: 1.0.25, protocol 2025-06-18, 7 tools: version, inspect, test, verify, report, issues, reproduce — the version, the protocol revision the server implements, and the tool list the client is
    about to see. It is written before the first request is read, so it appears in the client's console at the
    moment the process is up rather than at the moment something is first asked of it.

  • The diagnostics stream is a constructor argument, not System.err by name. McpServer gained a
    four-argument constructor taking the stream its banner and its failure notes are written to; the three-argument
    constructor delegates to it with System.err, so existing call sites and tests compile unchanged. The three
    notes that used to reach for System.err — stdin failed, cannot write protocol response, and the stack
    trace of an unexpected tool fault — now go through the same stream. That is what lets the new test read the
    channel the operator reads instead of capturing a global.

  • The tool list in the banner is the list the server advertises. McpTools.toolNames() became
    package-private, so the banner and the unknown-tool error message read one string rather than two copies.

  • Why the server has to be the one to speak. The asymmetry that raised this issue is a difference of
    transport, not of diligence. A harness plugin runs inside the harness process, so its startup console.log
    lands on the harness's own stdout — that is how dsh-file-upload announces the MarkItDown CLI. An MCP server
    is a child process: its stdout is the JSON-RPC channel, where one non-JSON byte ends the session, so it can
    never print there. The harness does not cover the gap either — @deepseek-ai/dsh-mcp-client makes four
    ctx.logger calls and every one sits on an error path, and cordis's logger only fills an in-memory buffer that
    nothing prints. The channel that does reach the operator is stderr, which the MCP SDK's stdio transport
    inherits from the harness by default (stdio: ['pipe', 'pipe', stderr ?? 'inherit']), and which CodeWitness
    already uses for progress and errors.

What this does not fix

  • The banner is not a health check. It is written when the process starts serving, which is before the
    client's initialize and long before any tool runs. A server that starts and then fails on its first tool call
    still announced itself, and one that cannot start at all still says nothing — the second is the honest signal,
    and it is the case the line was added to make visible.

  • It is only as visible as the stderr the client gives it. The MCP standard library inherits the child's
    stderr, so the line reaches the terminal a harness was started from; a client that captures stderr and never
    forwards it will not show the line, and nothing on this side can force that.

  • Only CodeWitness speaks now. The other MCP servers this machine's harness launches — laya, depmcp,
    goosebuckle, rea — are silent for exactly the same reason and are untouched here. Each needs the same one-line
    announcement in its own entry point; that is a change per server, not a change to this one.

  • The tool names in the banner are still hand-maintained. toolNames() is a written-out string, not derived
    from list(). The new test asserts the count and the phrase, so a tool added without touching the string fails
    the suite rather than the banner — but the string is still edited by hand.

Verified for this release

  • Full reactor suite: 1,785 tests, 0 failures, 0 errors, 0 skipped — one more than 1.0.24's 1,784, the new
    McpServerTest.announcesItselfOnStartup.
  • The guard was proved to fire. Routing the banner to the protocol stream instead of the diagnostics stream —
    one line, reverted afterwards — failed all seven McpServerTest cases: the six existing ones with non-JSON output on the MCP stream: [codewitness] MCP server ready: …, and the new one on its first assertion. Restored,
    the class is green again.
  • A real process, not only the unit test: printf initialize | ./codewitness mcp writes exactly one line to
    stderr and exactly one JSON-RPC response to stdout. Standard output staying protocol-only is the invariant the
    whole design rests on, and it is the half a unit test can miss.
  • Self-check against the built jar (./codewitness verify . --requirements selfcheck/requirements.yaml --config selfcheck/codewitness.yaml --no-mutation --max-duration 30m): all seven ground rules VERIFIED,
    1,785 tests executed and passed, 0 findings — five suppressed with their reasons — coverage 71.3% line
    (25,780/36,148) and 59.6% branch, 30 resolved dependencies with 0 advisories from OSV, and exit 0 in
    1 m 49 s. Run CW-2026-11-09-CHKRJ. selfcheck/README.md quotes this run.
  • ./codewitness version prints codewitness 1.0.25.

Process note

The defect was in the transport, and no test could have failed on it: the tool answered every request correctly,
and what was missing was the absence of a request. It surfaced by comparing two servers in one harness and asking
why one spoke — the harness's plugin announced, the harness's MCP server did not. The generalisable lesson is that
a silent success and a missing process look identical unless something says otherwise, and the something has
to be the process itself.

The first fix that suggests itself — patch the harness's MCP client to log every successful connection — is the
wrong one, for three reasons worth writing down: it lives in root-owned installed code, it announces for servers
that never asked to be announced, and it only helps clients that are that harness. A server that says "I am
ready" is portable; a harness that says "your server is ready" is not.

Compatibility

  • No CLI command, flag, exit code contract, report key, SARIF profile, codewitness.yaml key or adapter-SPI
    change. The interface contract frozen at 1.0 is untouched.
  • One new line on standard error at startup. A conforming MCP client reads standard output only, so nothing is
    affected; the MCP specification forbids treating stderr as protocol, and a client that parses it would have to
    tolerate a line it did not ask for.
  • McpServer's three-argument constructor is preserved as an overload, so source compatibility holds for any
    caller outside the class.

CodeWitness 1.0.24

Choose a tag to compare

@github-actions github-actions released this 08 Nov 15:39

CodeWitness 1.0.24 fixes four defects found by pointing the tool at a tree that is not its own — a polyglot
project with a Python front end and a Rust crate in a subdirectory. A crate whose Cargo.toml sits below the
project root is now found and built instead of reported as "no Cargo.toml was found"; one language's build no
longer blocks requirements in the languages that built; and two Python rules stop reporting method definitions
and docstring prose.

What changed

  • A Cargo manifest below the project root is found, and every Cargo command names it. The adapter asked one
    question — Files.isRegularFile(root.resolve("Cargo.toml")) — and Cargo itself resolves no manifest above its
    working directory, so rmath/Cargo.toml was invisible while the crate's .rs files were still detected: a
    Rust project was reported and then refused. Detection now searches a bounded depth (6) below the root, skipping
    target, .git, .codewitness, node_modules, vendor and .cargo — and also fixtures/testdata, because
    a repository's sample crates are inputs to its tests, not code the run verifies. The shallowest manifest wins,
    deterministically (depth, then path). Its directory becomes the build root, and crate name, edition, toolchain,
    src/ and tests/ are read from there. Build, tests, coverage, mutation, generated tests and the dependency
    inventory all run against it via --manifest-path, so a report's commands stay runnable from the project root.
    A tree with several manifests and none at the root is stated rather than glossed over: the report names the
    crate that was built and the manifests that were not part of the run's evidence.

  • One language's build no longer blocks requirements in the languages that built. blockedFor blocked per
    language only when it could attribute a requirement to one — attribution being a requirement id in a source
    file or a declared paths/tests. A requirement written in prose has no language, and the fallback then
    consulted the merged build, so on a tree where Python built and Rust did not, every requirement came back
    BLOCKED — including "The Python front-end suite passes" — while the report's own limitation text said the
    opposite. Such a requirement is now blocked only when nothing in the tree built; with something built it is
    judged on the evidence that exists, and its verdict names the languages it could not draw on and says how to
    have it judged per language next time.

  • A build that was never attempted is no longer merged into a failed build. mergeBuilds forced
    attempted(true) on the merged result and counted a language whose build was never attempted as a failure,
    which is how one run reported build failed with exit code -1 … language(s) whose build failed: [rust] while
    Rust's own per-language note said build not attempted (no Cargo.toml was found). languageSummaries
    compounded it by printing buildAttempted: true for a language whose result said attempted() == false. The
    merged result now reports attempted as any-language-attempted and success over the languages actually
    attempted, each language summary carries its own flag, and the limitation text separates "failed to build"
    from "no build was attempted".

  • CW-PY-SEC-002 no longer fires on a definition named eval. The rule was
    (?<![\w.])eval\s*\(|(?<![\w.])exec\s*\( matched against a raw line: the lookbehind spared self.eval(, but
    in def eval( the character before the name is a space, so a method definition read exactly like a call to
    the builtin. On one project that was nine HIGH security findings and not one call. The name a
    def/async def/class line defines is now blanked before the rule table sees it.

  • CW-PY-BUG-002 no longer fires on docstring prose, and no longer treats is True/is False as defects.
    Three of its five findings on that project were English sentences inside docstrings ("1.0 is 1 and 2.5 is
    5/2", "…a negative is 0") and two were x is False checks. Two separate mistakes: the analyzer matched every
    line of a file with no notion of strings, comments or docstrings — it was the only one of the sixteen that
    did; the others all have a codeOnly view — and the pattern listed True/False as identity-comparison
    literals although is True / is False / is None are the form PEP 8 recommends, and the runtime
    SyntaxWarning it cites applies to numbers and strings. The Python analyzer now tracks string literals and
    comments line by line, including triple-quoted strings across lines, and discards any match that begins
    inside one — for every rule, not just this one. The rule keeps only the literals Python actually warns about,
    and its message says that is None / is True / is False are not reported.

What this does not fix

  • One crate per run, when the tree holds several manifests and none is at the project root. A Cargo
    workspace declared at the root is built as a whole, as Cargo builds it; a tree with sibling crates is not.
    docs/status.md states the limit and the report names the crates that were not built.

  • Requirement → language attribution is unchanged. It still comes from a requirement id appearing in a
    source file, or from a declared paths/tests. The new behaviour makes an unattributed requirement honest —
    it is no longer blocked by a language that is not its own — but it cannot make it attributable. A requirement
    that names its files gets a per-language verdict; one that does not is judged on whatever evidence exists,
    and its verdict says so and says how to fix the mapping.

  • The run-level build summary is still one line for the whole run. It succeeds only when every build that ran
    succeeded. What changed is that a language nobody attempted to build no longer counts as a failure; the
    per-language record, with its own attempted/succeeded pair, is in the language summaries and the evidence
    ledger.

  • The identity rule is now narrower than a style linter. is True / is False are not reported at all. A
    project that wants them flagged should use a linter; CodeWitness reports what Python warns about.

  • The Python rule table is still a line-oriented heuristic table. The string and comment tracking is per
    line and does not attempt a full parse, so a pathological literal — a raw string ending in a backslash, say —
    can still confuse the spans. Every rule in the table gained the same view, so a wrong span suppresses or
    admits a finding rather than crashing the phase.

  • Python existing-test execution still depends on the project interpreter. Whether pytest and coverage.py
    are importable by the interpreter CodeWitness picks decides whether the suite and coverage can be measured;
    that is unchanged and reported per run.

Verified for this release

  • Full reactor suite: 1,784 tests, 0 failures, 0 errors, 0 skipped — 21 more than 1.0.23's 1,763: 14 for the
    Rust manifest work (NestedCrateTest, RustMutationProfileTest, four RustProjectDetectorTest cases) and 7
    for this release's engine and Python rules.
  • Every new guard was proved to fire, each against the pre-fix code and each restored afterwards:
    • Against the pre-fix detector, eight of the new Rust cases fail — including the exact message the defect
      produced, no Cargo.toml was found, so mutants cannot be compiled;
    • against the pre-fix engine, the aggregate-gate case fails with R-001 … status=BLOCKED and the
      never-attempted case fails on both buildAttempted and the merged build's success;
    • against the pre-fix Python rules, three cases fail with the reported findings reproduced exactly —
      def eval(self, text, steps=False): and async def exec(self, text): reported as HIGH security findings,
      if width is False: reported as a defect, and prose in a trailing comment reported twice.
  • Measured on a copy of the project that produced the reports (never its working tree): CW-PY-SEC-002
    went from 9 HIGH findings to 0 and CW-PY-BUG-002 from 5 MEDIUM to 0, while CW-PY-REL-003 (62) and
    CW-PY-TEST-001 (2) were unchanged — the rules that should still fire still do, and a real eval() call,
    x is "literal" and a credential literal are still reported.
  • End to end on a polyglot fixture (Python that builds, a nested Rust crate that does not): before, every
    requirement BLOCKED and the run BLOCKED; after, R-001 VERIFIED from an executed scenario while Rust
    failed, R-002 UNVERIFIED, run PARTIALLY_VERIFIED, exit 0, and the limitation naming Rust as the language
    whose build failed.
  • Self-check against the built jar (./codewitness verify . --requirements selfcheck/requirements.yaml --config selfcheck/codewitness.yaml --no-mutation --max-duration 30m): all seven ground rules VERIFIED,
    1,784 tests executed and passed, 0 findings — five suppressed with their reasons — coverage 71.3% line
    (25,775/36,141) and 59.6% branch, 30 resolved dependencies with 0 advisories from OSV, and exit 0 in
    1 m 50 s. Run CW-2026-11-08-BYFSS. selfcheck/README.md quotes this run.
  • ./codewitness version prints codewitness 1.0.24.
  • Rust end-to-end suite (-Pe2e): 2/2.

Process note

The aggregate-gate defect is worth recording because of how it was found: not by a failing test but by a
report contradicting itself. Run CW-2026-11-08-W1KWN said every requirement was BLOCKED and, in the same
limitation list, that "requirements written in a language that did build were still verified". Both sentences
were produced by the same run, and the wrong one was in the verdicts. A sentence in a report is a claim, and
a claim that is not tested is a claim that drifts
: blockedFor implemented per-language blocking and the
limitation text described it, but nothing exercised the case where a requirement has no language at all, so the
two halves were fr...

Read more

CodeWitness 1.0.23

Choose a tag to compare

@github-actions github-actions released this 08 Nov 12:30

CodeWitness 1.0.23 moves the two CodeQL action pins two patch releases forward — one of which fixes CodeQL
silently dropping alerts — and re-keys the pin guard on the repository, so a bump applied to init and not to
analyze can no longer pass the suite.

What changed

  • Both github/codeql-action pins moved from v4.39.1 to v4.39.3 (commit 33d7b85d). They were at the
    commit of 2026-10-21; two patch releases had shipped since:

    • v4.39.2 (2026-11-03) moves the default CodeQL bundle to 2.27.4, adds a deprecation warning for CodeQL
      2.22.3 and earlier ahead of the next minor release, warns when a workflow is about to run a traced analysis
      on macOS 27 or Xcode 27, and removes the undocumented CODEQL_ACTION_CLEANUP_TRAP_CACHES feature — warning
      if it is still set, and pointing users at trap-caching: false instead.
    • v4.39.3 (2026-11-04) is the one that matters here: "Fixed diff-informed alert filtering incorrectly
      removing alerts in changed files whose paths contain spaces, special characters, or non-ASCII characters."

      A scanner that drops alerts for a subset of changed files is precisely the failure a scanning workflow exists
      to prevent, and it fails silently — the run is green and the alert simply is not there.
  • CiActionPinsTest now keys its consistency assertion on the repository, not on the full action path.
    github/codeql-action/init and github/codeql-action/analyze are two steps of one repository and they must
    move together; keyed on the full reference the test treated them as unrelated actions, so a bump applied to
    one and not the other passed. It now compares the owner/repo prefix and the commit SHA, so a half-applied
    CodeQL bump fails the fast suite and the message names both sides and both line numbers.

  • 1.0.22's release note is corrected, in the file and in the published release body. It claimed the CodeQL
    tags were codeql-bundle-v* rather than semver, and that "no tool proposes their next release". Both were
    wrong, and they are what excused leaving the pins two releases stale. The file records the original wording
    under a ## Correction heading rather than quietly improving itself.

What this does not fix

  • The guard still cannot tell whether a pin is current, only whether it is well-formed. A full-length SHA
    with a consistent comment can be a year old. Currency needs the network and stays Dependabot's job. There is a
    known edge there worth naming: where several tags point at one commit — which is the normal layout for an
    action's moving major tag alongside its release tags — Dependabot can update the SHA and leave the version
    comment behind (dependabot-core#12879). The test
    requires that a comment exists; it cannot verify that the comment names the release the SHA came from, so a
    stale comment would pass it.

  • The failure that produced the stale pins is not fully closed. The dependency scanner that surfaced this
    work returns both CodeQL pins with an "error" and no candidate, because it splits an action reference on its
    final / and looks up a repository named codeql-action/init. Nothing in this release fixes that scanner,
    and the next person to trust its clean report will make the same assumption. The defence here is the audit
    habit, not the test.

  • dtolnay/rust-toolchain is still pinned to the stable tip of 2026-10-01, and that branch has moved since
    (b725eda5, 2026-10-16). Refreshing it is deliberate work of its own: it changes the Rust compiler the fixture
    builds with, which is a behavioural change to the end-to-end suite rather than a pin bump.

  • No behaviour changes. No adapter, phase, verdict rule, report field, budget or exit code is touched. The
    one user-visible difference is the version string in reports.

Verified for this release

  • Full reactor suite: 1,763 tests, 0 failures, 0 errors, 0 skipped. CiActionPinsTest was extended rather
    than added to, so the total is unchanged from 1.0.22.
  • Both assertions were proved to fire, each against a backup of codeql.yml and each restored afterwards:
    • With init left at v4.39.2's commit and analyze at v4.39.3's, the suite fails with codeql.yml:74: github/codeql-action/analyze is pinned to 33d7b85d…, but github/codeql-action/init at codeql.yml:62 pins the same repository to 1fc58d04…. One pipeline, two versions of one repository….
    • With init pinned to the tag v4 instead of a SHA, it fails with codeql.yml:62: github/codeql-action/init@v4 is not pinned to a 40-character commit SHA. A tag or branch can be re-pointed at different code after review….
  • All sixteen pins resolve to a 40-character SHA with a version comment, and every repository is pinned to one
    SHA across all three workflow files.
  • ./codewitness version prints codewitness 1.0.23.
  • Self-check against the built jar (./codewitness verify . --requirements selfcheck/requirements.yaml --config selfcheck/codewitness.yaml --no-mutation --max-duration 30m): all seven ground rules VERIFIED,
    1,763 tests executed and passed, 0 findings — five suppressed with their reasons — coverage 71.2% line
    (25565/35919) and 59.4% branch, 30 resolved dependencies with 0 advisories from OSV, and exit 0 in
    1 m 47 s. Run CW-2026-11-08-ZEQX0. selfcheck/README.md quotes this run.

Process note

This release exists because a question was asked twice. 1.0.22 shipped with the CodeQL pins two patch releases
stale and a note explaining why that was correct, and the explanation was invented to fit a report rather than
produced from one. The dependency scanner returned both pins as "error": … not found with no candidate; that
is a gap in the report, and the note filled the gap with three claims, of which two were false and the third —
that reconciling the pins was "a separate question" — was a decision resting on the two false ones.

The general lesson is not "check the scanner", it is that a non-action needs the same evidence as an action.
An item left undone with no reason is a visible gap. An item left undone with a confident, wrong reason is
invisible: it reads as a considered decision, so the next reader — including the next session — stops looking,
and the wrong reason propagates into a release note that other people read. The two minutes it would have taken
to open /tags on github/codeql-action were skipped in favour of writing a paragraph about it.

Compatibility

  • No CLI command, flag, exit code, report key, SARIF profile, configuration key or adapter-SPI change. A project
    verified by 1.0.22 is verified identically by 1.0.23; only version in the report differs.
  • The workflow's actions move two patch releases forward. This affects what CI runs on this repository, not what
    the tool does to a project it verifies.

CodeWitness 1.0.22

Choose a tag to compare

@github-actions github-actions released this 08 Nov 09:17

CodeWitness 1.0.22 brings the CI workflow's action pins to the releases their own comments name, and stops the
repository from being able to acquire a mutable tag pin — or two versions of one action — without the fast suite
failing.

What changed

  • Four pins were behind the release recorded beside them, and one of them was behind in three files at once.
    Sixteen uses: lines across three workflow files pin twelve distinct actions to a commit SHA; a SHA never moves
    on its own, which is the point of it, so each was resolved deliberately from upstream's tag to its commit:

    Action Was Now
    actions/setup-java v6.1.0 v6.2.0
    actions/setup-python v7.0.0 v7.1.0
    actions/setup-dotnet v6.0.0 v6.1.0
    ruby/setup-ruby v1.329.0 v1.338.0

    setup-java is pinned in ci.yml, codeql.yml and release.yml. All three moved together, because a pipeline
    that builds on v6.1.0 in its CodeQL job and v6.2.0 in its test job is running two versions of one action, and the
    one nobody looked at is the one that did not get reviewed.

    Each tag was resolved to a commit with the GitHub API rather than copied from a report — the same API that a
    dependency scanner read when it offered shivammathur/setup-php an "update" to verbose, which is a tag on that
    repository and not a version of anything.

  • CiActionPinsTest now holds the invariant ci.yml stated only in prose. The workflow's comment block claims
    every action is pinned to a full-length commit SHA rather than a movable tag; that claim had no test behind it,
    and uses: actions/checkout@v4 is exactly the line a hurried "fix the CI" commit writes. The test checks three
    things across every workflow file:

    • every uses: names a 40-character commit SHA — no tag, no branch, no short SHA;
    • every SHA carries a # <release> comment, because .github/dependabot.yml reads that comment to know which
      release a SHA is, and a pin without one quietly stops being tracked;
    • the same action is pinned to one SHA across the whole pipeline.
  • The reactor-root walk-up was extracted rather than copied. PackagingNativeAccessTest already walked up from
    the working directory to find the aggregator POM, because Surefire's working directory is the module directory
    and differs between a full reactor build and ./mvnw -pl codewitness-cli test. The new test needs the same
    walk-up and the same subtle rule that distinguishes the reactor root from a module POM that merely names
    codewitness-parent, so it moved into ReactorRoot and both tests call it.

  • Left alone on purpose. dtolnay/rust-toolchain is a commit at the tip of a moving stable branch with no
    release tag; dependabot.yml says it must be refreshed deliberately, and refreshing it here would move the Rust
    fixture's compiler as a side effect of a housekeeping release. The two github/codeql-action pins were also
    left untouched — see the correction at the end of these notes for why that was wrong.

What this does not fix

  • It does not keep the pins current; it keeps them well-formed. The test asserts the form of a pin, not its
    currency. A pin can be a valid full-length SHA with a correct version comment and still be a year old, and
    noticing that needs the network — which is why it stays Dependabot's job. The mechanism is imperfect in a way
    worth recording: the one open Dependabot pull request covers two of these four actions, and by the time it was
    read its ruby/setup-ruby pin proposed v1.336.0 when v1.338.0 was current. A grouped PR is only as fresh as the
    day it opened.

  • It cannot tell whether a SHA belongs to the repository named beside it, or whether the comment is the release
    that SHA came from.
    Both need upstream, and both are what a bad manual edit gets wrong. The test catches a
    missing comment and a disagreeing pair of pins; it would not have caught a comment reading v6.2.0 beside
    v6.1.0's commit, which is why the four bumps here were resolved from the API rather than hand-typed.

  • A dependency scanner cannot track the two github/codeql-action pins, though Dependabot can. A scanner that
    splits an action reference on its final / reads github/codeql-action/init as a repository named
    codeql-action/init, gets a 404, and drops both init and analyze from its results entirely. That is the
    scanner's defect and not a gap in this repository's coverage: .github/dependabot.yml covers every workflow file
    in / with pattern *, and Dependabot resolves a subpath reference to its repository, so these pins are tracked
    like the rest. The test added here covers their form — well-formed, and one version across the pipeline — but
    it cannot tell whether either pin is current, which is why the pins then went two releases stale. See the
    correction at the end.

  • No behaviour changes. No adapter, phase, verdict rule, report field, budget or exit code is touched. The one
    user-visible difference is the version string in reports.

Verified for this release

  • Full reactor suite: 1,763 tests, 0 failures, 0 errors, 0 skipped across the 22 test modules (up from 1,762;
    CiActionPinsTest is the only addition). PackagingNativeAccessTest still passes after its helper was
    extracted, which is what makes the extraction safe rather than a rewrite.
  • All three assertions were proved to fire, each against a backup of the file and each restored afterwards:
    • Pinning actions/setup-go@v7 in place of its SHA fails with setup-go@v7 is not pinned to a 40-character commit SHA. A tag or branch can be re-pointed at different code after review….
    • Stripping the comment from ruby/setup-ruby@b3aacea… fails with …carries no # <release> comment. Dependabot reads that comment to know which release the SHA is….
    • Leaving codeql.yml at v6.1.0 while ci.yml and release.yml moved to v6.2.0 fails with codeql.yml:51: actions/setup-java is pinned to b843ebf9… here but to 77dd5b2c… elsewhere in .github/workflows. One pipeline, two versions of one action….
  • All sixteen pins in the three workflow files now resolve to a 40-character SHA with a version comment, and
    actions/setup-java resolves to a single SHA across all three.
  • ./codewitness version and java -jar codewitness-cli/target/codewitness.jar version both print
    codewitness 1.0.22.
  • Self-check against the built jar (./codewitness verify . --requirements selfcheck/requirements.yaml --config selfcheck/codewitness.yaml --no-mutation --max-duration 30m): all seven ground rules VERIFIED,
    1,763 tests executed and passed, 0 findings — five suppressed with their reasons — coverage 71.2% line
    (25563/35919) and 59.4% branch, 30 resolved dependencies with 0 advisories from OSV, and exit 0 in
    1 m 45 s. Run CW-2026-11-08-EHFGG. selfcheck/README.md quotes this run.

Process note

This release was found by pointing a dependency-scanner MCP server (depmcp 0.11.0) at the repository rather than
by a human noticing, and the way it went wrong is the useful part. The scanner has no Maven support, so of the
project's 23 POMs it read none: its 21 "dependencies" were the workflow pins, one setuptools constraint, and four
entries that are not dependencies at all — requires-python looked up on PyPI as a package, and the fixtures'
own version = "0.1.0" field matched against a 2014 PyPI package literally named version, which it then
proposed bumping to 0.1.1. That is why the pins here were resolved from the GitHub API by hand and no update plan
was applied: the plan contained two entries that would have broken the repository, and applying it applies every
group at once.

The near-miss is worth recording because the new test caught it: the first pass at this change bumped
actions/setup-java in ci.yml only. The version-comment and SHA assertions both passed, and the pipeline would
have run v6.2.0 for tests and v6.1.0 for CodeQL — a difference invisible in review, in a green build, and in the
report. The third assertion exists because of that mistake.

Compatibility

  • No CLI command, flag, exit code, report key, SARIF profile, configuration key or adapter-SPI change. A project
    verified by 1.0.21 is verified identically by 1.0.22; only version in the report differs.
  • The two new test-visible files are ReactorRoot and CiActionPinsTest, both in codewitness-cli's test tree;
    neither is part of any published artifact.

Correction (added in 1.0.23)

Two statements in this note about github/codeql-action were false, and the pins they excused were two patch
releases out of date at the time of writing. Both are corrected above; the original wording is recorded here so
the record cannot quietly improve.

  • Claimed: "their tags are codeql-bundle-v* rather than semver." Wrong. The action's own tags are
    ordinary semver — v4.39.0, v4.39.1, v4.39.2, v4.39.3. Only the bundle releases use codeql-bundle-v*,
    which is why releases/latest answers codeql-bundle-v2.27.4; that is a reason for a naive resolver to
    stumble, not a reason to stop tracking the pins.
  • Claimed: "github/codeql-action still gets no update proposal from anything." Wrong. Dependabot covers
    every action in every workflow under /, and resolves github/codeql-action/init to its repository. It had
    simply not proposed either release yet.
  • And the pins were stale. Both sat at v4.39.1 (2026-10-21) while v4.39.2 (2026-11-03) and v4.39.3
    (2026-11-04) had shipped. v4.39.3 fixes diff-informed alert filtering incorrectly removing alerts in
    changed files whose paths contain spaces, special characters or non-ASCII characters — for a scanning workflow
    that is not housekeeping.

The mechanism behind the mistake is worth keeping: the dependency scanner returned both pins with an "error"
and no candidate, and the reasoni...

Read more

CodeWitness 1.0.21

Choose a tag to compare

@github-actions github-actions released this 02 Nov 05:28

CodeWitness 1.0.21 stops the shipped jar from prefixing every run with four lines of JDK warning: the
native-access permission the SQLite driver needs now travels with the artifact instead of depending on the
command line that starts it.

What changed

  • The shaded jar's manifest carries Enable-Native-Access: ALL-UNNAMED. The bundled SQLite driver loads
    a native library through JNI, which JDK 24 made a restricted operation (JEP 472). A jar that has not been
    granted native access prints, on the first command that opens a database,

    WARNING: A restricted method in java.lang.System has been called
    WARNING: java.lang.System::load has been called by org.sqlite.SQLiteJDBCLoader in an unnamed module
    WARNING: Use --enable-native-access=ALL-UNNAMED to avoid a warning for callers in this module
    WARNING: Restricted methods will be blocked in a future release unless native access is enabled
    

    and on a later JDK the load is refused outright. codewitness-cli/pom.xml now adds the attribute through
    shade's ManifestResourceTransformer, so it is written into META-INF/MANIFEST.MF at package time. A JVM
    honours a jar-manifest attribute only when the jar is started with -jar; that is exactly how every entry
    point other than the repository's own launcher starts it.

  • Why this was a defect and not a cosmetic wart. The repository's launcher already passes
    --enable-native-access=ALL-UNNAMED, which is why nothing here saw the problem — but the launcher is one
    entry point out of several. java -jar codewitness.jar, an editor or IDE run configuration, a CI step that
    invokes the jar directly, and the installed launcher (whose whole body is exec java -jar …) all printed the
    warning. Two consequences made it worth an artifact-level fix rather than a note:

    • The fourth line is a deadline. Once restricted methods are blocked by default, a jar that relies on the
      caller remembering a flag stops working, and it will look like the storage layer failing rather than a
      packaging oversight.
    • The warning goes to the JVM's stderr — the same stream a mode: process scenario asserts on. A
      requirement that asserts a clean stderr against this tool passed through ./codewitness and failed
      through java -jar, a difference that had nothing to do with what was being verified.
  • The launcher keeps its option, and a test says so. The flag still covers a jar built before this
    release, and dropping it would be a silent regression, so PackagingNativeAccessTest asserts both halves:
    the shade transformer declares <Enable-Native-Access>ALL-UNNAMED</Enable-Native-Access>, and the launcher
    still passes --enable-native-access=ALL-UNNAMED. Nothing at runtime fails if either is removed — the
    warning simply returns, or the old jar stops loading on a future JDK — so the guard is the only thing that
    notices.

  • Documentation states the arrangement. README.md now says the built jar is self-contained and may be
    started with java -jar, that it carries the attribute because of the SQLite driver, and that the launcher
    passes the equivalent option for jars that predate it.

What this does not fix

  • It is not a permission grant to anything but the tool's own class path, and not a security boundary.
    ALL-UNNAMED is the whole of a shaded jar; the tool already documents that its local-process sandbox is a
    resource boundary, not a security boundary, and this changes nothing about that.
  • A project under verification keeps whatever its own build prints. When CodeWitness builds a Java fixture
    through Maven, that child JVM has its own command line; if it loads a native library it will warn in the
    build output CodeWitness captures and reports. That output is reported as observed, deliberately — the tool's
    own reporting is not the place to filter a project's diagnostics.
  • Older JDKs are unchanged. A JDK before 24 ignores an unknown manifest main attribute, so the same jar
    still runs there; it simply had nothing to warn about.

Verified for this release

  • Full reactor suite: 1,762 tests, 0 failures, 0 errors, 0 skipped across the 22 test modules (up from
    1,760; the two new assertions are the only addition).
  • Both guards were proved to fire. With the <manifestEntries> block removed the test fails with
    the shaded jar's manifest must declare <Enable-Native-Access>; …; with the launcher's flag removed it fails
    with …/codewitness must pass --enable-native-access=ALL-UNNAMED to the JVM: …. Both pass after the change.
  • The repackaged jar's manifest reads
    Main-Class: dev.codewitness.cli.Main followed by Enable-Native-Access: ALL-UNNAMED, java -jar codewitness.jar report . run from a project with a database prints no JVM warning, and ./codewitness version prints codewitness 1.0.21.
  • Self-check against the built jar (./codewitness verify . --requirements selfcheck/requirements.yaml --config selfcheck/codewitness.yaml --no-mutation --max-duration 30m): all seven ground rules VERIFIED,
    1,762 tests executed and passed, 0 findings — five suppressed with their reasons — and exit 0 in 1 m 51 s.

Process note

The defect survived because the path that was exercised was the one that hid it. Every local run goes through
./codewitness, which had carried the flag since the toolchain moved to Java 25, so the warning appeared only
to someone who ran the jar directly — in this case from the installed copy in ~/.local, which the launcher
script there starts with a bare java -jar. The lesson generalizes: a fix applied at the call site looks
complete for as long as everyone uses that call site, and the artifact is the thing that gets copied, installed
and invoked by strangers.

Compatibility

  • No CLI, exit-code, report-key, SARIF, configuration-key or adapter-SPI change. One attribute is added to the
    jar manifest; a JDK that does not know it ignores it. A project verified by 1.0.20 is verified identically
    by 1.0.21.

CodeWitness 1.0.20

Choose a tag to compare

@github-actions github-actions released this 31 Oct 06:34

CodeWitness 1.0.20 passes self-verification with all ground rules verified.

What changed

  • Self-check verification — CodeWitness verified itself against all seven ground rules (CWR-001 through CWR-007) with VERIFIED verdicts. The self-check ran the full verification pipeline (build, tests, static analysis, dependency scan, coverage) without mutation testing, all against the project's own codebase.

  • 1,760 tests executed, 0 failures — The existing test suite remains fully green.

  • 71.2% line coverage — Measured across the full codebase.

What this release confirms

This release confirms that CodeWitness is self-consistent:

  • Ground rules are documented in selfcheck/requirements.yaml and enforced by the engine
  • The verification pipeline runs end-to-end against CodeWitness itself
  • All verdicts are VERIFIED with appropriate evidence chains

Compatibility

  • No breaking changes
  • All existing adapters, CLI commands, and report formats unchanged

Notes

The self-check is now a documented verification step that can be replayed on any machine with the required toolchain. Run it with:

export JAVA_HOME=/path/to/jdk-25
export HOME=/path/to/workspace
export JAVA_TOOL_OPTIONS=-Dmaven.repo.local=/path/to/workspace/.m2/repository
./codewitness verify . --requirements selfcheck/requirements.yaml --config selfcheck/codewitness.yaml --no-mutation --max-duration 30m

CodeWitness 1.0.19

Choose a tag to compare

@github-actions github-actions released this 30 Oct 13:08

CodeWitness 1.0.19 clarifies the TypeScript parameter properties limitation and documents the workaround.

What changed

  • Documentation: TypeScript parameter properties — Explicitly documents that Node's type stripper does not support TypeScript parameter properties (constructor(private x: T)), which fail with "TypeScript parameter property is not supported in strip-only mode". Projects using these features should add a pinned TypeScript compiler and tsconfig.json, which makes CodeWitness use tsc --noEmit for full type checking instead of the fallback syntax checker.

  • New workaround documentation — Added docs/workarounds/ directory with detailed guidance on the TypeScript parameter properties limitation, including multiple workaround options and their tradeoffs.

What this does not fix

  • The underlying Node.js experimental stripTypeScriptTypes limitation remains; the workaround (adding TypeScript compiler) is the actual fix for affected projects.

Verified for this release

  • 1,759 tests across 22 modules: 0 failures, 0 errors
  • Documentation updated: docs/status.md, docs/workarounds/README.md, docs/workarounds/typescript-parameter-properties.md
  • No code changes: this release is documentation-only

Compatibility

  • No breaking changes
  • Existing TypeScript projects continue to work as before
  • Projects using parameter properties without a TypeScript compiler will continue to get clear error messages directing them to the workaround

Notes

This release addresses a user question: "why does my TypeScript code fail?" The answer was already correct (the error message clearly states the problem), but now documented how to fix it explicitly.

CodeWitness 1.0.18

Choose a tag to compare

@github-actions github-actions released this 28 Oct 16:27

CodeWitness 1.0.18 exercises the one phase it could report without ever running: the Python coverage
measurement, which every machine this project has run on has honestly declined to perform.

What changed

  • The Python coverage phase is now exercised end to end. PythonCoverageProvider reports coverage as
    not measured when the project's interpreter cannot import coverage.py — the right answer, since
    coverage.py is not part of the Python distribution and CodeWitness installs nothing. The consequence went
    unnoticed: this machine's interpreter cannot import it (ModuleNotFoundError: No module named 'coverage'),
    CI installed no Python package beyond the interpreter itself, and fixtures/python-withdrawal-ledger
    deliberately declares no dependencies, so the branch that actually runs coverage run and coverage json
    had never executed anywhere. Its only tests substituted their inputs: PythonCoverageProviderTest fed the
    parser a JSON file and PythonTimeoutTest fed the killed-run path a sandbox double. A regression that made
    the provider always decline to measure would have passed the entire suite, which is exactly the failure the
    CI assertion step exists to prevent for every other language.

  • CI installs coverage.py and asserts it is importable. The new step runs
    python3 -m pip install coverage, and the "Assert every toolchain is present" step now runs
    python3 -c 'import coverage; print("coverage.py", coverage.__version__)' beside the assertions for Xdebug,
    GHDL, fpc and the rest. pytest is deliberately not installed, so the fixture keeps running on the
    standard-library unittest runner the adapter falls back to and that fallback stays what the end-to-end
    suite exercises. This is the arrangement the PHP adapter has had since Xdebug was pinned; Python was the
    one language whose coverage phase was reported but never measured.

  • A new end-to-end test measures a real project through coverage.py. PythonCoverageEndToEndTest
    (@Tag("e2e")) copies fixtures/python-withdrawal-ledger — a copy, because coverage.py writes a data file
    into the directory it runs in and an end-to-end test must not leave .coverage in the fixture it tests —
    inspects it with PythonLanguageAdapter so the interpreter probe is the adapter's own, runs the provider,
    and asserts a real measurement: measured, tool coverage.py, a non-zero statement total, a non-zero
    covered count, covered ≤ total, a non-empty per-file view whose keys are all Python source files, and the
    JSON report the numbers were read from still on disk. On the fixture that is 36 of 37 statements, 97.3%,
    per file ledger.py and tests/test_ledger.py.

  • The absent-driver branch is pinned by a unit test, on both of its claims. PythonCoverageProviderTest
    now asserts that a project which recorded hasCoverage=false is reported as not measured, with tool
    coverage.py and a note naming the reason, and that the numbers stay at zero rather than being invented —
    and that nothing is run: the context carries a sandbox whose runner throws, so a provider that started an
    interpreter anyway would fail the test rather than cost one.

  • Both directions were proved before the change was recorded. Forcing the provider to always decline
    made the new end-to-end test fail with
    coverage.py is importable, so the phase must measure rather than decline: coverage not measured (the project interpreter cannot import coverage); and with coverage.py absent the test skipped itself
    (Tests run: 1, Failures: 0, Errors: 0, Skipped: 1) instead of passing as if it had measured.

  • The documentation says which arrangement makes the phase real. docs/status.md and docs/languages.md
    now state that CI installs coverage.py and asserts it, that a machine without it skips the end-to-end test
    rather than failing, and that Python branch coverage is not measured — the run does not enable --branch,
    so the report carries an empty 0/0 rather than a figure nobody collected. README.md records the same
    arrangement next to the per-fixture toolchain notes.

What this does not fix

  • CodeWitness still installs nothing. coverage.py stays the environment's responsibility, exactly as
    coverage.py's absence is a reported condition rather than a failure. Bundling it would not even work: the
    interpreter that is probed is the project's own — .venv and VIRTUAL_ENV are preferred over the ambient
    one — and the workspace copy skips any directory named coverage, so a vendored copy could neither be
    imported by a project's virtual environment nor reach the copy the run works in.
  • The pytest branch of the coverage run is still unexercised in CI. When the interpreter can import
    pytest the suite is re-run under coverage run -m pytest; CI has no pytest, deliberately, so the exercised
    branch is the unittest one. On a machine with coverage.py and pytest both importable that branch runs,
    and it is the same three commands with a different module argument, but it has no test of its own.
  • A developer machine without coverage.py skips the end-to-end test. That is the documented contract for
    every toolchain-dependent test in this repository, and it is why CI asserts presence: the skip cannot hide
    a regression there. python3 -m pip install --user coverage enables it locally.

Verified for this release

  • Full reactor test suite: 1,760 tests, 0 failures, 0 errors, 0 skipped across the 22 test modules (up
    from 1,759; the added unit test is the only fast-suite addition, and the end-to-end test is excluded from
    the default suite by its e2e tag).
  • The new end-to-end test with coverage.py importable: Tests run: 4, Failures: 0, Errors: 0, Skipped: 0
    for PythonCoverage* — the end-to-end test measured the fixture and did not skip.
  • The same test with the driver absent: Skipped: 1, not a silent pass.
  • The self-check reports all seven requirements VERIFIED against the built 1.0.18 jar.

Compatibility

  • No report format, verdict, exit code, CLI, configuration-key or adapter-SPI change. The change is a CI
    step, two tests and documentation; a project verified by 1.0.17 is verified identically by 1.0.18.

Process note

The inconsistency was visible in the repository for several releases before it was fixed: the PHP adapter's
Xdebug assertion has a comment saying in as many words that the assertion exists so the coverage phase is
"exercised rather than silently skipped in the report", and the Python adapter had no counterpart. What made
it invisible is that the honest behaviour — reporting "not measured" with a reason — is indistinguishable in
a green build from the phase never being run, so the only signal was that no machine ever had the driver.
Reading the tests rather than the reports is what showed it: both of the provider's tests substituted
their inputs, and both passed for years' worth of runs without the provider executing once.

CodeWitness 1.0.17

Choose a tag to compare

@github-actions github-actions released this 26 Oct 11:01

CodeWitness 1.0.17 corrects the self-check's own README, which still described the check as it was
before 1.0.2 — a rule it could not execute, a run of 1,671 tests and ten findings.

What changed

  • selfcheck/README.md no longer claims that the exit-code rule cannot be executed. Its table said
    CWR-007 had no scenario, "so the honest verdict is UNVERIFIED", and the paragraph beneath
    explained why leaving one ground rule unexecuted was deliberate. mode: process made that rule
    executable in 1.0.2, and the self-check has reported it VERIFIED by running the built jar ever
    since. The row now says what the scenario does, and the paragraph records the history without
    claiming the present: the behaviour that an unexecutable claim stays UNVERIFIED is still exercised,
    by SC-CWR-002, which asserts that verdict against VerdictCalculator.
  • The quoted result is replaced with a current one. The block cited run CW-2026-10-25-2415C:
    1,671 tests, PARTIALLY_VERIFIED, six verified and one unverified. It now quotes run
    CW-2026-10-26-XRNH0 — 1,759 tests all passing, coverage line 71.2 % (25562/35919) and branch 59.4 %
    (12413/20890), 30 dependencies with no advisory, all seven requirements VERIFIED, exit 0 — and
    says which fixes were in place.
  • "Known false positives" now describes the report that exists. It said "the static-analysis
    section reports 10 findings (1 high, 9 medium)", which stopped being true in 1.0.13. It now states
    that there are no unsuppressed findings, names the five suppressed ones by rule, file and reason,
    and records that the phase line discloses the suppression (2 medium (2 suppressed by configuration))
    so a reader can reconcile the two counts.

None of this is a behaviour change. It is the same failure mode this project has fixed before, in the
landing page in 1.0.12: documentation outliving the feature it describes. The correction matters more
here than elsewhere, because this is the document that tells a reader what the self-check actually
proves — a reader who believed the old text would conclude that the project's strongest claim still
leaves one ground rule unexecuted, and that the report carries ten findings it has to triage.

What this does not fix

  • The five suppressed findings are still suppressed, for the reasons the section now states. They are
    judgements about this project, not defects, and suppression is disclosed in the run.
  • No code, test, report or configuration changed, so nothing about what CodeWitness verifies moved.

Verified for this release

  • Documentation only: apart from the version constant, no source file changed, and the full reactor suite
    is unchanged at 1,759 tests, 0 failures.
  • Every number written into selfcheck/README.md was read from the report of run
    CW-2026-10-26-XRNH0 — the 1.0.16 self-check, which is also the run that verified the two fixes in
    1.0.15 and 1.0.16 — rather than recalled.

Compatibility

  • No interface change of any kind: CLI, exit codes, report keys, SARIF and codewitness.yaml are
    untouched.