branchproof 0.7.0 → 0.9.0

data/doc/Branchproof.md

@@ -2,10 +2,11 @@
 
 |  |  |
 | --- | --- |
-| **Defined in** | lib/branchproof.rb, lib/branchproof/cli.rb, lib/branchproof/limits.rb, lib/branchproof/loader.rb, lib/branchproof/report.rb, lib/branchproof/source.rb, lib/branchproof/worker.rb, lib/branchproof/project.rb, lib/branchproof/records.rb, lib/branchproof/runtime.rb, lib/branchproof/version.rb, lib/branchproof/analyzer.rb, lib/branchproof/evidence.rb, lib/branchproof/minimizer.rb, lib/branchproof/comparison.rb, lib/branchproof/instrumenter.rb, lib/branchproof/runtime_flow.rb, lib/branchproof/saved_report.rb, lib/branchproof/rails_support.rb, lib/branchproof/coverage_index.rb, lib/branchproof/focused_report.rb, lib/branchproof/decision_syntax.rb, lib/branchproof/minitest_adapter.rb, lib/branchproof/comparison_report.rb, lib/branchproof/flow_instrumentation.rb |
+| **Defined in** | lib/branchproof.rb, lib/branchproof/cli.rb, lib/branchproof/limits.rb, lib/branchproof/loader.rb, lib/branchproof/report.rb, lib/branchproof/source.rb, lib/branchproof/worker.rb, lib/branchproof/project.rb, lib/branchproof/records.rb, lib/branchproof/runtime.rb, lib/branchproof/version.rb, lib/branchproof/analyzer.rb, lib/branchproof/evidence.rb, lib/branchproof/minimizer.rb, lib/branchproof/comparison.rb, lib/branchproof/constraints.rb, lib/branchproof/instrumenter.rb, lib/branchproof/runtime_flow.rb, lib/branchproof/saved_report.rb, lib/branchproof/value_syntax.rb, lib/branchproof/rails_support.rb, lib/branchproof/value_runtime.rb, lib/branchproof/coverage_index.rb, lib/branchproof/decision_table.rb, lib/branchproof/default_syntax.rb, lib/branchproof/focused_report.rb, lib/branchproof/decision_syntax.rb, lib/branchproof/default_runtime.rb, lib/branchproof/exception_syntax.rb, lib/branchproof/iteration_syntax.rb, lib/branchproof/minitest_adapter.rb, lib/branchproof/comparison_report.rb, lib/branchproof/exception_runtime.rb, lib/branchproof/iteration_runtime.rb, lib/branchproof/flow_instrumentation.rb, lib/branchproof/value_instrumentation.rb, lib/branchproof/default_instrumentation.rb, lib/branchproof/exception_instrumentation.rb, lib/branchproof/iteration_instrumentation.rb, lib/branchproof/extended_alternative_runtime.rb |
 
-Keep each bounded source rewrite together so its evaluation order can be
-audited. rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+Keep source-boundary and parameter-binding rules together for auditing.
+rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity,
+Metrics/MethodLength, Metrics/ModuleLength, Metrics/PerceivedComplexity
 
 ## Constants
 ### `VERSION` <a id="constant-VERSION"></a> <a id="VERSION-constant"></a>
@@ -17,13 +18,26 @@ Not documented.
 - [Branchproof/CLI.md](Branchproof/CLI.md)
 - [Branchproof/Comparison.md](Branchproof/Comparison.md)
 - [Branchproof/ComparisonReport.md](Branchproof/ComparisonReport.md)
+- [Branchproof/Constraints/Solver.md](Branchproof/Constraints/Solver.md)
+- [Branchproof/Constraints.md](Branchproof/Constraints.md)
 - [Branchproof/CoverageIndex.md](Branchproof/CoverageIndex.md)
 - [Branchproof/DecisionSyntax.md](Branchproof/DecisionSyntax.md)
+- [Branchproof/DecisionTable.md](Branchproof/DecisionTable.md)
+- [Branchproof/DefaultInstrumentation.md](Branchproof/DefaultInstrumentation.md)
+- [Branchproof/DefaultRuntime.md](Branchproof/DefaultRuntime.md)
+- [Branchproof/DefaultSyntax.md](Branchproof/DefaultSyntax.md)
 - [Branchproof/Error.md](Branchproof/Error.md)
 - [Branchproof/Evidence.md](Branchproof/Evidence.md)
+- [Branchproof/ExceptionInstrumentation.md](Branchproof/ExceptionInstrumentation.md)
+- [Branchproof/ExceptionRuntime.md](Branchproof/ExceptionRuntime.md)
+- [Branchproof/ExceptionSyntax.md](Branchproof/ExceptionSyntax.md)
+- [Branchproof/ExtendedAlternativeRuntime.md](Branchproof/ExtendedAlternativeRuntime.md)
 - [Branchproof/FlowInstrumentation.md](Branchproof/FlowInstrumentation.md)
 - [Branchproof/FocusedReport.md](Branchproof/FocusedReport.md)
 - [Branchproof/Instrumenter.md](Branchproof/Instrumenter.md)
+- [Branchproof/IterationInstrumentation.md](Branchproof/IterationInstrumentation.md)
+- [Branchproof/IterationRuntime.md](Branchproof/IterationRuntime.md)
+- [Branchproof/IterationSyntax.md](Branchproof/IterationSyntax.md)
 - [Branchproof/Limits.md](Branchproof/Limits.md)
 - [Branchproof/Loader.md](Branchproof/Loader.md)
 - [Branchproof/Minimizer.md](Branchproof/Minimizer.md)
@@ -37,6 +51,9 @@ Not documented.
 - [Branchproof/RuntimeFlow.md](Branchproof/RuntimeFlow.md)
 - [Branchproof/SavedReport.md](Branchproof/SavedReport.md)
 - [Branchproof/Source.md](Branchproof/Source.md)
+- [Branchproof/ValueInstrumentation.md](Branchproof/ValueInstrumentation.md)
+- [Branchproof/ValueRuntime.md](Branchproof/ValueRuntime.md)
+- [Branchproof/ValueSyntax.md](Branchproof/ValueSyntax.md)
 - [Branchproof/Worker.md](Branchproof/Worker.md)
 - [CHANGELOG.md](CHANGELOG.md)
 - [README.md](README.md)

data/doc/CHANGELOG.md

@@ -1,5 +1,58 @@
 ## [Unreleased]
 
+## [0.9.0] - 2026-09-18
+
+- Measure contextual predicates, guarded pattern selection, dynamic case splat
+  groups, required pattern matching, and safe-navigation compound assignment.
+- Add coverage for rescue paths, optional argument binding, standalone
+  predicates, value alternatives, iteration, and source-visible callbacks.
+- Preserve Boolean criteria for Boolean decisions and report other choices as
+  alternative coverage, including their source locations and supporting tests.
+- Exercise 144 Ruby construct fixtures and 406 native cases across source inventory, native behavior,
+  runtime evidence, analysis, reports, saved reports, and CLI integration.
+- Preserve nonlocal control transfers on the right side of logical expressions.
+- Harden default-argument, exception, and iteration instrumentation around
+  implicit parameters, nonlocal transfers, nested frames, and deferred callbacks.
+- Remove unreachable integer bitwise alternatives and keep their exclusions out
+  of coverage denominators.
+- Cache repeated value evidence while preserving vector counts, test/phase
+  attribution, and saved-report coverage semantics.
+
+## [0.8.0] - 2026-09-17
+
+- Derive a reduced decision table for every supported Boolean decision from its
+  `AND`/`OR`/`NOT`/atom structure, preserving Ruby short-circuit semantics with
+  an explicit `dont_care` value instead of exhaustive Cartesian expansion.
+- Give every rule a stable identity derived from the decision, its normalized
+  condition vector, the expected outcome, and the table schema version, so
+  saved reports compare across runs, test order, and Minitest seeds.
+- Overlay the existing run's observations onto the rules, attribute covered
+  rules to their Minitest tests, and describe uncovered rules as condition-value
+  requirements. No additional test execution is performed.
+- Report Decision Table Coverage as its own criterion in the coverage ladder,
+  per decision and in aggregate, independently from MC/DC in both directions.
+- Add conservative reachability: `observed`, `unknown`, and
+  `statically_impossible` with stable reason codes. Constraint analysis version 2
+  requires safe source constraints before excluding rules, keeping arbitrary
+  comparison receivers, mutation, and unordered numeric cases unknown.
+- Exclude statically impossible rules from coverage denominators while keeping
+  them visible, and let runtime evidence withdraw an impossibility claim with a
+  `constraint_model_conflict` diagnostic.
+- Add `--view decision-tables`, which honours `--missing-only` and never lists
+  an impossible rule as a missing obligation.
+- Bound table derivation with the new `max_conditions_for_decision_table` and
+  `decision_table_rules_per_decision` limits.
+- Persist the table, rule identities, coverage, attribution, and reachability in
+  schema `1.3` reports, and distinguish rule-coverage changes from reachability
+  changes in offline comparison.
+- Enforce exact rule-limit boundaries and index runtime rule matching rather
+  than scanning all observations per rule.
+- Add `--no-reachability` to keep all generated rules as coverage obligations.
+- Align the JSON regression flag with decision-table CLI failures, report
+  analysis-version changes, and validate saved rule identities and evidence.
+- Keep uncalculated decision locations and reasons in missing-only reports;
+  label `unless` and `until` outcomes as predicate values.
+
 ## [0.7.0] - 2026-09-10
 
 - Discover Boolean loop predicates, subjectless case candidates, standalone

data/doc/README.md

@@ -1,10 +1,11 @@
 # Branchproof
 
-Branchproof measures decision, condition, and modified condition/decision
-coverage (MC/DC) from one serial Minitest run. It discovers Ruby decisions
-through Prism, records their runtime paths, and attributes evidence to tests.
-Boolean decisions receive the coverage ladder; `case`, pattern alternatives,
-safe navigation, and conditional assignments receive alternative coverage.
+Branchproof measures decision, condition, modified condition/decision (MC/DC),
+and decision-table coverage from one serial Minitest run. It discovers Ruby
+decisions through Prism, records their runtime paths, and attributes evidence
+to tests. Boolean decisions receive the coverage ladder; `case`, pattern
+alternatives, safe navigation, and conditional assignments receive alternative
+coverage.
 
 The gem and primary command are named `branchproof`. The `mcdc` command and
 `MCDC` namespace remain compatibility aliases with the same behavior.
@@ -128,7 +129,7 @@ json` when a consumer needs the complete identifiers and versioned schema.
 
 ### Coverage ladder
 
-Each successful `analyze` run calculates four criteria from the same completed
+Each successful `analyze` run calculates five criteria from the same completed
 observations. The report shows their status for each supported decision and
 aggregate counts with explicit denominators:
 
@@ -138,6 +139,7 @@ aggregate counts with explicit denominators:
 | Condition | Every atomic condition evaluated both true and false | Two required truth values per supported condition |
 | Condition/Decision | Both Decision and Condition Coverage hold for a decision | Supported decisions |
 | MC/DC | Every condition has an independence witness pair | Supported conditions |
+| Decision Table | Every executable logical rule was exercised | Non-impossible generated rules |
 
 For `logged_in? && admin?`, observations `[F-] => F` and `[TT] => T` give:
 
@@ -146,6 +148,7 @@ Decision                    PASS
 Condition                   FAIL (3/4 values observed)
 Condition/Decision          FAIL
 MC/DC                       FAIL (1/2 conditions proven)
+Decision Table              FAIL (2/3 rules covered)
 ```
 
 The skipped `admin?` in `[F-]` counts as neither true nor false. Conditions
@@ -155,6 +158,12 @@ for `logged_in?`; `admin?` still needs `[TF] => F`.
 
 Decision and Condition Coverage are calculated independently from the captured
 evidence. Condition/Decision requires both; MC/DC adds independence evidence.
+Decision Table Coverage is calculated independently of all of them: MC/DC asks
+whether each condition can independently affect the outcome, while Decision
+Table Coverage asks whether each logical rule was exercised. Neither status is
+inferred from the other, so `MC/DC PASS` with `Decision Table FAIL` and the
+reverse are both valid results.
+
 Unsupported decisions are excluded from every denominator, while
 unexecuted supported decisions remain in scope. Empty denominators are N/A.
 
@@ -170,6 +179,184 @@ under `analysis.decisions[].coverage`, and condition value evidence under
 pairs, counterpart constraints, and raw vectors remain available. Statuses
 distinguish `covered`, `partial`, `unexecuted`, and `unsupported` results.
 
+### Decision table coverage
+
+For a Boolean decision Branchproof can represent with `AND`, `OR`, `NOT`, and
+atomic conditions, it derives a reduced decision table statically from the
+Boolean structure and then overlays the runtime evidence of the same run. No
+application code is executed while the table is derived, and no extra test run
+is performed while it is overlaid.
+
+Rules come directly from the short-circuit evaluation paths of the Ruby expression,
+so a condition the interpreter would
+skip appears as an explicit don't-care (`-`) rather than as two separate rules.
+Exhaustive Boolean expansion is deferred; it is not required to calculate coverage
+and is never performed on the reporting path.
+For `premium? && (admin? || owner?)`:
+
+```text
+Decision Table: 3/4 rules covered (75.0%)
+  Rule  premium?  admin?  owner?  Result  Status
+  R1    F         -       -       F       COVERED
+  R2    T         T       -       T       COVERED
+  R3    T         F       T       T       MISSING
+  R4    T         F       F       F       COVERED
+  R1 tests: UserAccessTest#test_free_user
+  R2 tests: UserAccessTest#test_admin
+  R3
+  Need:
+    premium? = truthy
+    admin?   = falsey
+    owner?   = truthy
+  Expected decision:
+    true
+  Reachability:
+    unknown
+  R4 tests: UserAccessTest#test_denied
+```
+
+A missing rule describes condition values only. It does not claim which
+application inputs would produce them.
+
+An observation matches a rule when every required condition value matches and
+the decision outcome matches. Conditions Ruby skipped can only line up with
+don't-care positions; they never satisfy a required true or false. Every rule
+carries a stable identity derived from the decision, its normalized condition
+vector, the expected outcome, and the table schema version — never from a test
+name, an observation order, or the Minitest seed, so saved reports compare
+across runs.
+
+Decision tables are derived for `if`, `unless`, `elsif`, ternary, `while`,
+`until`, subjectless `case`/`when`, and supported Boolean pattern guards.
+Multi-way `case`/`when`, `case`/`in` alternatives, safe navigation, conditional
+assignment, and exception handling keep their alternative coverage model and
+produce no Boolean table.
+For `unless` and `until`, the outcome is the predicate value, not whether the
+body executes; the terminal report labels it accordingly.
+
+#### Reachability and impossible rules
+
+Each rule carries a reachability status: `observed`, `unknown`, or
+`statically_impossible`. Branchproof proves impossibility or leaves
+reachability unknown. It never infers impossibility from a missing test, a
+missing observation, application conventions, Rails validations, database
+constraints, comments, or method names.
+
+Constraint analysis version 2 requires evidence that a constraint is safe before
+using it to exclude a rule. A variable name and a numeric literal do not prove
+that the receiver is a number, that its comparison methods use built-in semantics,
+or that its value stays unchanged. Numeric, equality, and nil-check expressions
+are still normalized for inspection, but unproven source constraints remain
+`unknown`. The standalone constraint solver describes its explicit model, not
+arbitrary Ruby objects.
+
+Literal truth values can establish impossibility without invoking application
+methods. For `age && false`, the rule requiring the literal `false` to be truthy
+cannot execute:
+
+```text
+Decision Table: 2/2 rules covered (100.0%)
+Statically impossible rules excluded: 1
+  Rule  age  false  Result  Status
+  R1    F    -      F       COVERED
+  R2    T    F      F       COVERED
+  R3    T    T      T       EXCLUDED
+  R3 TT => T
+  Status:
+    EXCLUDED
+  Reachability:
+    STATICALLY IMPOSSIBLE
+  Reason:
+    conflicting Boolean literal requirements
+```
+
+Impossible rules stay visible in the full report but leave the coverage
+denominator. Reason codes are stable: `conflicting_numeric_bounds`,
+`conflicting_equalities`, `equality_outside_numeric_range`, `nil_conflict`, and
+`boolean_literal_conflict`. Human-readable messages may change independently.
+
+Runtime evidence is authoritative. If an observation matches a rule the static
+model called impossible, the rule becomes `observed`, the impossibility claim is
+withdrawn, the rule returns to the denominator, and a `constraint_model_conflict`
+diagnostic records the disagreement.
+
+For example, `age > 10 && age < 5` stays unknown without a proven domain;
+custom comparison methods can make both comparisons true. Similarly,
+`x > 10 && (x = 0) && x < 5` can execute successfully. `Float::NAN` also prevents
+treating a false comparison as its ordered complement. Runtime evidence can cover
+these rules, but lack of evidence cannot exclude them. Ruby truthiness remains
+distinct from Boolean equality: only `false` and `nil` are falsey.
+
+Use `analyze --no-reachability` to disable all static exclusions, including literal
+proofs. Every generated rule then remains an obligation; reports show
+`Reachability: not analyzed`. The mode is persisted with the report and considered
+when comparing analysis contexts. Reading a saved report preserves its original
+analysis; it does not recalculate it under a different mode.
+
+#### Decision table views and limits
+
+`--view decision-tables` groups the terminal report by decision table, and
+`--missing-only` narrows it to uncovered, non-impossible rules while retaining
+uncalculated decisions with their location and reason. `decision_tables` is an
+accepted compatibility spelling for the view:
+
+```sh
+bundle exec branchproof analyze 'lib/**/*.rb' \
+  --view decision-tables \
+  --missing-only
+```
+
+Tables grow exponentially with condition count, so
+`max_conditions_for_decision_table` (default 12) and
+`decision_table_rules_per_decision` (default 4096) bound the derivation. A
+decision above either limit reports `Decision Table: NOT CALCULATED` with the
+reason `decision_table_condition_limit_exceeded` or
+`decision_table_rule_limit_exceeded` instead of a partial table.
+
+JSON stores the table under `analysis.decisions[].decision_table` with its
+`schema_version`, `constraint_analysis_version`, rules, rule identities, rule
+coverage, test attribution, reachability, and reachability reason. This abbreviated
+example omits counts and evidence bookkeeping fields; full reports also retain
+rule indexes, vector IDs, unattributed counts, and withdrawn-impossibility details:
+
+```json
+{
+  "decision_table": {
+    "status": "calculated",
+    "schema_version": 1,
+    "constraint_analysis_version": 2,
+    "rules": [
+      {
+        "id": "8f1c...",
+        "label": "R1",
+        "conditions": ["false", "dont_care", "dont_care"],
+        "outcome": false,
+        "coverage": "covered",
+        "reachability": "observed",
+        "tests": ["..."]
+      },
+      {
+        "id": "3ad0...",
+        "label": "R3",
+        "conditions": ["true", "false", "true"],
+        "outcome": true,
+        "coverage": "missing",
+        "reachability": "unknown",
+        "tests": []
+      }
+    ]
+  }
+}
+```
+
+Aggregate counts live under `analysis.coverage.decision_table` and keep rule
+coverage and fully covered decisions as distinct metrics:
+
+```text
+DT (Decision table coverage): 83.9% (47/56 rules)
+Decision tables fully covered: 13/18 decisions
+```
+
 ### Find missing cases
 
 Use `--missing-only` to focus the terminal report on conditions that still
@@ -231,7 +418,7 @@ analysis even at Level 1. A failed, unsupported, or incomplete run is reported
 with its status and diagnostics and cannot become a successful coverage
 result by changing the display level.
 
-### Focused condition and test views
+### Focused condition, test, and decision-table views
 
 Use `--view conditions` to group the report by condition. Each condition shows
 its expression, decision, and project-relative source location with the
@@ -253,6 +440,10 @@ conditions. A test that evaluates both Boolean values is evidence of execution;
 it is a proof contributor only when the analyzer's independent witness pair
 uses its observations.
 
+Use `--view decision-tables` to group the report by decision table. See
+[Decision table coverage](#decision-table-coverage) for the rule, reachability,
+and attribution detail it renders.
+
 `--view` changes terminal grouping and does not change instrumentation or test
 execution. JSON output always contains the complete evidence document, so an
 explicit view cannot be combined with `--format json`. The `mcdc` executable
@@ -308,7 +499,12 @@ patterns is valid comparison context, and seed differences are disclosed.
 
 `compare` exits 0 for a complete comparison, including one with coverage
 changes; `--fail-on-regression` exits 1 when a complete comparable run loses
-proof. Invalid input or an incomplete comparison exits 2, which takes
+MC/DC proof or decision-table rule coverage. The JSON `regression` flag includes
+either kind of loss; `regressions` retains the MC/DC count and
+`decision_table_regressions` supplies the separate rule-loss count. Changes to
+table schemas, constraint-analysis versions, or reachability modes are reported
+as analysis context changes rather than silently treated as unchanged analysis.
+Invalid input or an incomplete comparison exits 2, which takes
 precedence. Reports are explicit snapshots: comparison never creates history,
 promotes a baseline, or overwrites either input.
 
@@ -346,6 +542,13 @@ ID. Repeated equivalent executions aggregate into a vector's `count`, retaining
 the supporting tests. Ternary outcomes likewise describe the predicate, not
 the value returned by the chosen branch.
 
+Value decisions remain enabled by default. For each decision, evidence caches
+the most recent successful completed trace, keyed by its observations, outcome,
+test, and phase. Consecutive equivalent executions increment vector and phase
+counts without repeating serialization and digest work. When observations,
+test, or phase changes, the execution is recorded normally, so alternating
+traces retain their full evidence and attribution.
+
 Other constructs use alternative coverage, separate from MC/DC:
 
 | Construct | Kind | Context | Required alternatives |
@@ -355,6 +558,18 @@ Other constructs use alternative coverage, separate from MC/DC:
 | `receiver&.method` | `implicit` | `safe_navigation` | Receiver nil / non-nil |
 | `lhs ||= rhs` | `implicit` | `or_assignment` | RHS skipped / executed |
 | `lhs &&= rhs` | `implicit` | `and_assignment` | RHS skipped / executed |
+| `receiver&.value ||= rhs` / `&&=` | `multiway` | `or_assignment` / `and_assignment` | Receiver nil / RHS skipped / RHS evaluated |
+| `value => pattern` | `pattern` | `required_pattern` | Matched / mismatch |
+| Rescue regions | `exception` | `rescue` | Normal completion / rescue clause / unhandled exception |
+| Optional positional and keyword arguments | `implicit` | `default_argument` | Supplied / default evaluated |
+| Standalone predicate calls | `implicit` | `predicate` | Falsey / truthy result |
+| `<=>` | `multiway` | `comparison` | Negative / zero / positive / nil |
+| `[]` lookup | `multiway` | `lookup` | Truthy / false / nil result |
+| `send`, `public_send`, and `__send__` | `implicit` | `dispatch` | Successful return / exception |
+| Regular-expression match capture | `implicit` | `match_capture` | False / true |
+| Iterator bodies | `implicit` | `iteration` | Empty / entered |
+| Lazy iterator callbacks | `multiway` | `lazy_callback` | Callback entered |
+| `fetch` with a fallback block | `implicit` | `fetch_fallback` | Value present / fallback entered |
 
 Each safe-navigation operation in a chain is a distinct decision. Assignment
 instrumentation preserves Ruby's native local, instance, class, global,
@@ -376,21 +591,39 @@ that fails before choosing a branch is aborted, not counted as a selected
 alternative. Selected branches and assignment paths remain observed even when
 their bodies or right-hand sides subsequently raise or return.
 
-Unsupported syntax stays visible and outside coverage denominators. Current
-exclusions include guarded `case/in` (`unsupported_pattern_guard`), dynamic
-`when` splats (`unsupported_case_splat`), safe-navigation compound assignment
-(`unsupported_assignment_target`), and rescue alternatives
-(`unsupported_rescue_control_flow`). A guard predicate can still supply Boolean
-evidence when Ruby evaluates it; an unsupported guarded case does not claim
-pattern-match coverage from that evidence. Flip-flops remain
-`unsupported_flip_flop`. Decisions inside `defined?`, contextual regular
-expressions, heredocs, unsafe predicates, and limit overflows retain explicit
-exclusions. Ruby-defined custom `!` methods keep their runtime behavior;
+Guarded pattern alternatives measure the selected clause, including guard
+acceptance. The guard also supplies Boolean evidence when Ruby evaluates it.
+A dynamic `when *candidates` is one static candidate group; the report does not
+claim coverage of individual elements in that runtime collection.
+
+Flip-flops and implicit regular-expression conditions retain Ruby's conditional
+semantics and contribute one atomic predicate outcome. `defined?` measures its
+result without evaluating or instrumenting the operand. Standalone predicate
+calls record returned truthiness as alternative coverage; they do not claim
+short-circuit conditions or coverage of library internals. Eager bitwise `&`,
+`|`, and `^` are excluded because integer results do not represent Ruby
+truthiness decisions: integer `0` is truthy in Ruby. These expressions add no
+decisions or coverage obligations.
+Dynamic dispatch records completion or exception, and preserves the original
+return value. Lazy callback observations arise only when the callback runs.
+Lookup coverage cannot distinguish an absent key from a stored nil; `fetch`
+fallback coverage measures that separate absence-based choice.
+Optional argument probes use generated local flags and preserve parameter
+signatures, defaults, and existing local bindings. Code that enumerates its own
+local variables can see these instrumentation locals.
+
+Unsupported syntax stays visible and outside coverage denominators. Heredocs,
+unsafe predicates, data sections, and limit overflows retain explicit exclusions.
+Ruby-defined custom `!` methods keep their runtime behavior;
 evidence that contradicts Boolean negation is rejected instead of proving
 coverage with an invalid logical model.
 
-New reports use schema `1.2`; saved schema `1.0` and `1.1` reports remain
-readable. Expanded discovery changes coverage denominators, so compare reports
+New reports use schema `1.3`; saved schema `1.0`, `1.1`, and `1.2` reports
+remain readable. Comparison distinguishes decision-table coverage movement
+(`rule coverage gained`, `rule coverage lost`) from analysis movement
+(`rule reachability changed`), and treats a structurally changed decision as a
+changed decision-table context instead of guessing which old rule a new rule
+corresponds to. Expanded discovery changes coverage denominators, so compare reports
 with their supported syntax scope in mind.
 
 ### Limits
@@ -398,7 +631,8 @@ with their supported syntax scope in mind.
 `--limits` accepts a JSON object containing positive integer overrides. The
 available keys are `conditions_per_decision`, `vectors_per_decision`,
 `owner_associations_per_run`, `tests_per_run`, `exact_candidates`,
-`exact_search_nodes`, and `constraint_search_states`.
+`exact_search_nodes`, `constraint_search_states`,
+`max_conditions_for_decision_table`, and `decision_table_rules_per_decision`.
 
 ```json
 {