[AdaWorldAPI]

ogar-dismech was already an ogar-loco vocabulary — 19 causal predicates minted contiguously from DOMAIN_FLOOR. This adds the second band: the seven constraint-propagation verbs that make resolution a search, plus the residue that search leaves behind.

Two bands, not one widened palette

The 19 are a closed measured set mirroring upstream's graph builder; folding operations into them would dissolve exactly the property their own test pins. So 0xA3..=0xA9 is a separate band with its own const, and it carries LOCAL: CURIEs — the ogar-ro precedent this crate already cites. A dismech: prefix would assert a provenance upstream never gave.

slot	verb	arity	bodies
0xA3	candidates	0	0
0xA4	fold_xref	1	0
0xA5	naked_single	1	0
0xA6	hidden_single	2	0
0xA7	eliminate	2	0
0xA8	fork	1	2
0xA9	residue_band	1	0

Sudoku is meant mechanically

Resolution is elimination, not similarity.

• naked_single — one candidate remains, the cell is forced.
• hidden_single — the referent can sit in only one cell of its unit, so that cell is forced while still holding other candidates. This is the case where free text does not know what it names: the uniqueness is a property of the unit, never of the cell read alone.
• eliminate — makes cardinality a moving state rather than a static count. A term with two candidates today has one after a neighbour resolves.
• fork — keeps both arms. Deliberately not IF_ELSE: a conditional discards the untaken arm, and that retention is what makes the result a counterfactual instead of a choice.

fold_xref is ordered before any counting. Two addresses of one referent are not two referents; counting first reports a bookkeeping artifact as a fork.

The residue is an overlay — and that is a cost argument

residue_band maps candidate cardinality to the consumer's 3-bit reasoning band. Samples are collected at the graph's own addresses, in separate tables, never merged down.

The shape is eye tracking: you record where the eye looked, not what it saw. So "1:1" is the addressing; the occupancy is sparse. Writing the trace into each subject instead gives every subject a partial copy of the ontology's structure, which does not stay affordable — and it is why three bits suffice.

One-way, structurally. No search op declares DISMECH_TARGET_CODEBOOK: their operands are candidate sets and computed bands, never basin-scoped ids, so a residue value has no path to be read as a graph address.

Pothole → rung degradation → revision

Two of the four outcomes are potholes, and the mapping is the degradation:

candidates	ordinal	reading
0	0 Surface	nothing addressable — the gap names its own cell (the reach-out hook)
1	2 Relation	resolved
2..floor	4 Counterfactual	bounded arms, each interventionable
>= floor	1 Association	does not discriminate — hub-shaped

The diffuse case is hub-shaped in the exact sense Throttle::hub_indegree already means: a term with too many attachments is barred rather than guessed at. diffuse_floor is therefore the same kind of quantity — a required parameter with no shipped default. No measured value exists, and a constant would launder a guess into an apparent finding. Revision is downstream and elsewhere.

It is not evidence

Propagation forces a cell given the constraints; it does not prove it. Wrong constraints force wrong cells with full confidence. The value is not epistemic but search-economic — against tens of thousands of edges the question is rarely "is this true" and almost always "which is worth opening". Confirmation needs a channel the trace did not travel.

No bits move, and nothing derives the band where it is stored

The band's owner pins that the field is "set ONLY by an explicit with_reasoning_band() call" with nothing deriving it internally. So the ordinal is produced here and written there — no dependency edge in either direction, which is what honours that rule rather than breaking it. The v1-provenance gate is carried in the doc comment.

The rung is the layer, not the payload. Rungs project as a stack of alpha layers at zero bit cost: one table per rung over one address space, the 3-bit sample sitting inside a layer. The band is never mapped onto the rung ladder — its owner pins that they are unrelated enums sharing four variant names, at different ordinals.

Verification

• 20 tests (13 pre-existing, unchanged + 7 new).
• Five disable-runs, each verified red-then-green: the codebook guard (let search ops declare it → fails), computes-vs-asserts (make search ops assert → fails), meta-is-never-a-cardinality-outcome (let counting emit 6 → fails), the strict floor (< → <= → fails), band contiguity (punch a gap → fails).
• Anti-vacuity is explicit where it matters: the codebook test asserts predicates do declare it, so it cannot pass by everything answering None.
• One test was re-pinned, not silently widened: an_unminted_domain_byte_is_refused_not_guessed probed max(RELATIONS)+1, which is now candidates — it would have asserted "unminted" about a minted byte. It now probes past both bands, with the reason in the comment.
• cargo fmt clean. cargo clippy carries two pre-existing assertions_on_constants findings in the collision-guard test — measured identical before and after this change, and left alone rather than fixed drive-by.

Named next, not built

• The second-order collector over lance-graph-supervisor's PhaseCensus — a mask over the activities (one &self pass), never the retired actor/pump surface.
• The 0/1/2/n distribution measurement that would calibrate diffuse_floor.

---

🤖 Generated with Claude Code

https://claude.ai/code/session_017Pud4qpxFHwqyqDjSabQbs

---

Generated by Claude Code

[coderabbitai]

Important

• 🔍 Trigger review

This repository does not receive automatic reviews because it has fewer than 10 stars.

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro Plus

Run ID: e695c8c6-85a7-4165-8020-c6bae0ac7fe0

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}

[cursor]

Bugbot couldn't run - usage limit reached

Bugbot is counted against Cursor usage for this user or team, and this run hit a usage or spend limit.

A user or team admin can review and increase usage limits in the Cursor dashboard.

(requestId: serverGenReqId_076d1d29-8201-41d5-90f1-4cf73050acf4)

[AdaWorldAPI]

@coderabbitai review

Automatic review does not fire on this repository (below the star threshold), and Bugbot is at its usage limit — so this PR would otherwise reach merge with no automated review at all. Requesting one explicitly.

Two places worth a reviewer's attention in particular:

1. residue_band's diffuse_floor is a required parameter with no default, deliberately — no measured value exists for it. If that reads as an ergonomic gap rather than a guard, say so; I judged the alternative (shipping a constant) to be worse, but that is a judgement, not a fact.
2. The pushes_result split between the two bands (predicates Some(false), search ops Some(true)) is load-bearing as a contamination boundary, not merely a table entry. It is asserted two-sided and disable-verified, but a second opinion on whether the declaration actually carries that weight — versus needing enforcement at the consumer's dispatch — is welcome.

---

Generated by Claude Code

[coderabbitai]

Tip

For best results, initiate chat on the files or code changes.

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo '== PR metadata =='
gh pr view 279 --repo AdaWorldAPI/OGAR --json title,baseRefName,headRefName,files --jq '{title,baseRefName,headRefName,files:[.files[].path]}'

echo '== Changed-file summary =='
git diff --stat HEAD^ HEAD
echo '== Diff =='
git diff --find-renames --find-copies --unified=80 HEAD^ HEAD

echo '== Rust source/test map =='
fd -e rs . | sort

echo '== Relevant identifier occurrences =='
rg -n -C 5 -e '\b(pushes_result|residue_band|diffuse_floor|with_reasoning_band|DISMECH_TARGET_CODEBOOK|candidates|fold_xref|naked_single|hidden_single|eliminate|fork)\b' -g '*.rs' .

echo '== AST outlines for changed Rust files =='
git diff --name-only --diff-filter=AM HEAD^ HEAD | rg '\.rs$' | while IFS= read -r f; do
  echo "-- $f --"
  ast-grep outline "$f" --items all || true
done

Length of output: 118290

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo '== Vocabulary API and conformance =='
sed -n '360,550p' crates/ogar-loco/src/vocabulary.rs
sed -n '560,980p' crates/ogar-loco/src/vocabulary.rs

echo '== Statement segmentation =='
sed -n '1,240p' crates/ogar-loco/src/statements.rs

echo '== Production call sites for table semantics =='
rg -n -C 6 --glob '*.rs' --glob '!**/tests/**' --glob '!**/examples/**' \
  '\b(pushes_result|body_refs|branches|statement_bounds|segment_statements)\s*\(' \
  crates

echo '== Direct DisMech vocabulary consumers =='
rg -n -C 6 --glob '*.rs' \
  '\b(DisMechVocabulary|SEARCH_OPS|RESIDUE_BAND|FORK|residue_band|DISMECH_TARGET_CODEBOOK|plug_into)\b' \
  crates --glob '!crates/ogar-dismech/src/lib.rs'

echo '== Manifest dependency relationships =='
rg -n -C 2 'ogar-dismech|ogar-loco' --glob 'Cargo.toml' --glob 'Cargo.lock' .

Length of output: 85537

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo '== Vocabulary documentation around the allocation claim =='
nl -ba crates/ogar-dismech/src/lib.rs | sed -n '425,455p'

echo '== Package description =='
nl -ba crates/ogar-dismech/Cargo.toml | sed -n '1,18p'

Length of output: 648

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo '== Vocabulary documentation around the allocation claim =='
awk 'NR >= 425 && NR <= 455 { printf "%6d  %s\n", NR, $0 }' crates/ogar-dismech/src/lib.rs

echo '== Package description =='
awk 'NR >= 1 && NR <= 18 { printf "%6d  %s\n", NR, $0 }' crates/ogar-dismech/Cargo.toml

Length of output: 2741

---

@AdaWorldAPI, I found one documentation issue.

• crates/ogar-dismech/src/lib.rs Line 435–437: The documentation says that 0xA3..=0xFF is reserved and refused. This PR allocates 0xA3..=0xA9 to SEARCH_OPS. Update the range to 0xAA..=0xFF, or describe the reserved range as the bytes after both bands.

On the requested design points:

1. diffuse_floor is a guard, not an ergonomic gap. The function requires each caller to make an explicit corpus policy decision. A shipped default would silently encode an unmeasured threshold. The documented <= 2 policy also makes an invalid-looking low value an intentional strict policy, not an API failure.

2. The pushes_result declaration carries real weight. Validation freezes it in VocabularyTable, and statement_bounds uses that table to calculate stack depth and statement boundaries. A predicate incorrectly marked as pushing would change maskable statement grouping. A search operation incorrectly marked as non-pushing would close a statement early.

   The declaration does not enforce an executor’s semantic dispatch by itself. This repository has no production executor for these search operations. When one is added, it must dispatch through the validated VocabularyTable and treat pushes_result as stack semantics. It must not infer behavior from FnIndex values or names.

   FORK is correctly the exception to “search operations push.” It branches to two bodies and is non-pushing, like shared-core control calls. Consider adding an explicit assert_eq!(v.pushes_result(FORK), Some(false)) test. The current test intentionally filters FORK out, so it does not pin this required exception.

Static review complete. I did not execute repository code or tests.

[review]

---

✏️ Learnings added

Learnt from: AdaWorldAPI
URL: https://github.com/AdaWorldAPI/OGAR/pull/279

Timestamp: 2026-08-21T09:01:26.099Z
Learning: In `crates/ogar-dismech/src/lib.rs`, `residue_band(candidates, diffuse_floor)` intentionally requires the caller to provide `diffuse_floor`; the crate must not ship a default threshold because no measured calibration exists. Values of `diffuse_floor <= 2` are valid strict policies that make the Counterfactual outcome unreachable.

Note: Learnings are effective only in the context of similar code segments. To apply general coding guidelines, please configure review instructions. You can manage existing learnings in the app.

_{You are interacting with an AI system.}

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: b5cc4516fb

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[AdaWorldAPI]

Both findings were real and both were mine. Fixed in 0d8ee83.

The reserved range. 0xA3..=0xFF was true until this branch allocated 0xA3..=0xA9, and I did not update the sentence beside the code I changed — so it shipped a doc comment that contradicted its own struct. It now names both bands and reserves 0xAA..=0xFF.

The FORK gap is the one that matters, and the diagnosis is exact. a_search_op_computes_where_a_predicate_asserts filters on bodies == 0, which excludes fork by construction, and fork_branches_where_every_predicate_is_a_leaf asserts body_refs without touching pushes_result. So the single exception to the rule the band is built on was pinned by nothing. It is asserted explicitly now, in the test whose own filter created the hole, and disable-verified: making search ops push unconditionally fails with a branching call must not also push.

That is the third instance of the same failure shape in this session — a test whose filter or fixture excludes precisely the case it exists to cover. Writing the rule down does not confer immunity to it; only running the disable does, and here the review caught what my five disable-runs did not, because I never disabled the thing the filter had already removed.

On the two design points, the useful part is the mechanism you named, which I did not have. I justified the pushes_result split as a declaration; the actual weight is that validate freezes it into VocabularyTable and statement_bounds computes stack depth and statement boundaries from it — so a wrong answer re-segments statements rather than merely mislabelling a byte. That reason is now inline at the assertion.

And your correction stands unqualified: the declaration does not enforce an executor's dispatch, because this repository has no production executor for these verbs. When one lands it must read the validated table rather than infer from FnIndex values or names. I have not softened the module doc's "one-way, structurally" claim, because what it actually says is narrower — no search op declares the target codebook, so a residue value has no path to be read as a graph address — but the distinction between that and runtime enforcement is worth having stated on the record, which it now is here.

---

Generated by Claude Code