recipes: audit finds they measure on a scalar proxy → wire the 3 real tenants (A9 24 loci + SPO + qualia)#780
Conversation
… tenants recipe_claim_audit exercises the REAL shipped recipe_kernels: 28/34 recipes measure/realize their claim on the ThoughtCtx proxy (2 INERT bugs CAS/ETD, 4 CONSTANT input-independent ARE/ZCF/ICR/HKF), but 34/34 read ONLY the scalar proxy basis — none touch the SPO/CAM-PQ/Markov/qualia organ they name. The dominant weakness is substrate-wiring, not recipe composition. Wire the three real tenants into the recipe input: - causal_witness::CausalWitnessFacet — A9 "24 edges": a reading of the 12-byte content-blind register as 24 signed i4 loci (G24N4), each a context pointer into the ±8 Markov window. The THIRD ClassView reading of the same register #729 shipped two of (FROZEN 12xu8 + Orchestration 6x(8:8)); no stored bytes. - recipe_substrate::SubstrateView — projects SPO + witness + qualia into the recipe input. Qualia is ADDITIVE + STAKES-only (temperature, never logic); causality is the witness KAUSAL edge, not a qualia; a missing tenant emits NaN/empty (the NaN-disqualifier signal). - recipe_dispatch — the 34 as a rung-ordered, NaN-gated causal ladder keyed by NARS inference type (deduction/induction/abduction/revision/counterfactual). Thinking is a causal act: the ladder is a causal chain, each step logs its triggering cause (Versuchsleitereffekt = observer effect), dispatch is a deterministic Schroedinger collapse, a NaN input is an unmeasurable conjugate. 3 modules + 3 probes (recipe_claim_audit, loci_recipe_relevance, recipe_ladder_over_substrate — all gates green), +18 tests -> 970 green, clippy clean. Additive, zero-dep, nothing existing touched. Board hygiene: E-RECIPE-SUBSTRATE-WIRING-1, LATEST_STATE, STATUS_BOARD D-REC-WIRE-1. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01K3RyLEbuNSHxxB3NTTrGki
|
Warning Review limit reached
Next review available in: 48 minutes Enable usage-based reviews in Billing to review now. Otherwise, wait until the next included review is available. How can I continue?After more reviews become available, a review can be triggered using the To avoid repeated limits, reduce automatic review volume by pausing incremental auto-reviews earlier, using label-based review opt-in, excluding WIP or generated PR titles, or requesting reviews manually when the PR is ready. If your team needs uninterrupted high-volume reviews, an organization admin can enable usage-based reviews. How do review limits work?CodeRabbit enforces per-developer PR review limits for each organization. Most developers receive the normal plan review availability. For paid Pro and Pro+ PR reviews, CodeRabbit uses adaptive limits for sustained high-volume activity. When a developer's recent PR review activity reaches the 95th percentile or higher among CodeRabbit users, additional reviews become available more gradually as earlier reviews age out of the rolling window. Please refer docs for additional details. Review details⚙️ Run configurationConfiguration used: Organization UI Review profile: CHILL Plan: Pro Plus Run ID: 📒 Files selected for processing (2)
📝 WalkthroughWalkthroughAdds a packed causal-witness facet, substrate-to- ChangesRecipe substrate wiring
Estimated code review effort: 4 (Complex) | ~60 minutes Sequence Diagram(s)sequenceDiagram
participant SubstrateView
participant ThoughtCtx
participant recipe_dispatch
participant recipe_kernels
SubstrateView->>ThoughtCtx: project SPO, witness, and qualia markers
ThoughtCtx->>recipe_dispatch: provide recipe inputs
recipe_dispatch->>recipe_kernels: inspect required fields
recipe_kernels-->>recipe_dispatch: return required masks
recipe_dispatch-->>ThoughtCtx: return rung-ordered RecipeStep results
Possibly related PRs
Poem
🚥 Pre-merge checks | ✅ 5✅ Passed checks (5 passed)
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. Comment |
Bugbot couldn't run - usage limit reachedBugbot 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_077abd3e-167b-4ef5-8fdd-700581960bf1) |
… reasoning, Pei Wang/NARS) arXiv 2511.08392 is the formal frame recipe_dispatch instantiates — a RecipeStep is one proof-carrying step (inference=rule, trigger=premises, nan_disqualifier= the verification gate). Adds MME-Reasoning arXiv id + taxonomy to the anchors. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01K3RyLEbuNSHxxB3NTTrGki
…SCM ladder) arXiv 2206.15475 formalizes the structural-causal-model ladder the witness edges instantiate: SCM structure = Locus::Kausal, intervention = Pearl rung-2, counterfactual = rung-3 = RecipeInference::Counterfactual (ICR #31). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01K3RyLEbuNSHxxB3NTTrGki
…s, one catalogue 66f5a73 measured select_tactic's reachability (8/34, Infrastructure never wins, ICR #31 shadowed by RCR #4). The ladder is the complementary mode, not a replacement: selector = foveated saccade (one tactic per surprise cycle), ladder = systematic sweep (all 34 in rung order, NaN-gated) — the three measured gaps close by mode composition, not selector retuning. Cross-ref in the module doc. Board: E-LADDER-UNSHADOWS-SELECTOR-1 (the mode-composition finding) + E-THINKING-SKILLS-ARE-RUNG-4-MACROS-1 (cc-thinking-skills = rung-4 macro catalogue over the rung-3 recipes; mapped pairs + the unmapped expansion surface; the 34 stays operator-locked). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01K3RyLEbuNSHxxB3NTTrGki
![chatgpt-codex-connector[bot]](https://avatars.githubusercontent.com/in/1144995?s=60&v=4){kind=small}
There was a problem hiding this comment.
💡 Codex Review
Here are some automated review suggestions for this pull request.
Reviewed commit: ecc97c0a77
ℹ️ 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".
| let disq = nan_disqualifier(ctx, id); | ||
| let trigger = kernel(id).map(|k| k.requires().len()).unwrap_or(0); |
There was a problem hiding this comment.
When ctx.sd is in FLOW (sd < SD_FLOW), Gate-bucket recipes such as TCP are skipped by Tactic::run, but ladder() only checks nan_disqualifier and records disqualified_by: None, so callers see those recipes as firing even though the actual kernel gate would reject them. This makes the new dispatch map disagree with the shipped execution semantics for any FLOW context; incorporate kernel(id).gate(ctx) (or a separate skipped state) before reporting a recipe as fired.
Useful? React with 👍 / 👎.
| let sw = (pair_similarity(self.spo.subject, self.spo.ew_subject) | ||
| + pair_similarity(self.spo.predicate, self.spo.ew_predicate) | ||
| + pair_similarity(self.spo.object, self.spo.ew_object)) | ||
| / 3.0; |
There was a problem hiding this comment.
When the SPO tenant is absent (SpoFacet::default()) but a quorum or contradiction witness edge is bound, project() treats confidence as grounded and calls this method; the all-zero default SPO then compares each semantic rail to an all-zero witness rail and pair_similarity returns 1.0 for all three pairs. That turns a missing SPO tenant into a strong confidence signal instead of an undefined/neutral one, so recipes requiring Confidence can fire on fabricated evidence; skip or neutralize the SPO agreement term unless spo_present() is true.
Useful? React with 👍 / 👎.
LATEST_STATE shipped-PRs row + PR_ARC_INVENTORY prepend (Added/Locked/ Deferred/Docs/Confidence) + STATUS_BOARD D-REC-WIRE-1 -> Shipped. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01K3RyLEbuNSHxxB3NTTrGki
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
There was a problem hiding this comment.
Actionable comments posted: 2
🧹 Nitpick comments (1)
crates/lance-graph-contract/examples/recipe_ladder_over_substrate.rs (1)
87-92: 🎯 Functional Correctness | 🔵 Trivial | ⚡ Quick winUse a distinct peer witness here
agreement_count(row.witness)is self-comparison, so it always returns the full locus count. If this is meant to demonstrate quorum agreement, pass a separate witness instead.🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the rest with a brief reason, keep changes minimal, and validate. In `@crates/lance-graph-contract/examples/recipe_ladder_over_substrate.rs` around lines 87 - 92, Update the example’s agreement-count demonstration in the println! block to pass a distinct peer witness rather than row.witness itself. Obtain or construct the intended comparison witness from the surrounding recipe-ladder example, and preserve the existing output while ensuring agreement_count compares two different witnesses.
🤖 Prompt for all review comments with AI agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
Inline comments:
In `@crates/lance-graph-contract/examples/recipe_claim_audit.rs`:
- Around line 673-689: Replace the hardcoded proxy_only value in the aggregate
section with a count derived from each recipe kernel’s requires() contract. For
every RECIPES entry, resolve its kernel and count it only when all required
fields belong to the 8-field ThoughtField scalar basis, then use that measured
count in the existing Axis B output.
In `@crates/lance-graph-contract/src/recipe_substrate.rs`:
- Around line 98-121: Update logical_confidence() to detect an absent/default
SPO facet before calculating pairwise agreement, using the existing SPO presence
semantics such as spo_present(). Return zero confidence for ungrounded SPO while
preserving the current quorum, contradiction, and agreement formula for grounded
SPO.
---
Nitpick comments:
In `@crates/lance-graph-contract/examples/recipe_ladder_over_substrate.rs`:
- Around line 87-92: Update the example’s agreement-count demonstration in the
println! block to pass a distinct peer witness rather than row.witness itself.
Obtain or construct the intended comparison witness from the surrounding
recipe-ladder example, and preserve the existing output while ensuring
agreement_count compares two different witnesses.
🪄 Autofix (Beta)
Fix all unresolved CodeRabbit comments on this PR:
- Push a commit to this branch (recommended)
- Create a new PR with the fixes
ℹ️ Review info
⚙️ Run configuration
Configuration used: Organization UI
Review profile: CHILL
Plan: Pro Plus
Run ID: 63f1be12-42ff-4c4c-aca5-7f6376c68559
📒 Files selected for processing (10)
.claude/board/EPIPHANIES.md.claude/board/LATEST_STATE.md.claude/board/STATUS_BOARD.mdcrates/lance-graph-contract/examples/loci_recipe_relevance.rscrates/lance-graph-contract/examples/recipe_claim_audit.rscrates/lance-graph-contract/examples/recipe_ladder_over_substrate.rscrates/lance-graph-contract/src/causal_witness.rscrates/lance-graph-contract/src/lib.rscrates/lance-graph-contract/src/recipe_dispatch.rscrates/lance-graph-contract/src/recipe_substrate.rs
| // ── aggregate ── | ||
| let recipe_weak = n_inert + n_constant; | ||
| let proxy_only = 34; // structural: every kernel's requires() is in the 8-scalar basis | ||
| println!("\n── aggregate ──"); | ||
| println!( | ||
| " Axis A: {} MEASURES + {} REALIZES = {} sound on the proxy; {} recipe-WEAK ({} INERT + {} CONSTANT)", | ||
| n_measures, | ||
| n_realizes, | ||
| n_measures + n_realizes, | ||
| recipe_weak, | ||
| n_inert, | ||
| n_constant | ||
| ); | ||
| println!( | ||
| " Axis B: {}/34 kernels consume ONLY the ThoughtField scalar proxy basis — 0 consume a real organ", | ||
| proxy_only | ||
| ); |
There was a problem hiding this comment.
🎯 Functional Correctness | 🟡 Minor | ⚡ Quick win
Axis B is asserted, not measured. The module doc bills Axis B as "measured, structural," but proxy_only is a hardcoded 34 and the only related gate (G4) merely checks that ORGAN_SHIPS maps all 34 ids — nothing inspects each kernel's requires() to confirm it draws solely from the 8-field scalar basis. The headline printed to the operator ("34/34 kernels consume ONLY the ThoughtField scalar proxy basis") is therefore an unverified constant. Since requires() is already the gate contract used elsewhere, deriving this from the kernels would make the claim self-substantiating.
Sketch: derive Axis B instead of hardcoding
// count kernels whose requires() is a subset of the scalar ThoughtField basis
let proxy_only = RECIPES
.iter()
.filter(|r| /* every field in kernel(r.id).requires() is a ThoughtField scalar */ true)
.count();🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@crates/lance-graph-contract/examples/recipe_claim_audit.rs` around lines 673
- 689, Replace the hardcoded proxy_only value in the aggregate section with a
count derived from each recipe kernel’s requires() contract. For every RECIPES
entry, resolve its kernel and count it only when all required fields belong to
the 8-field ThoughtField scalar basis, then use that measured count in the
existing Axis B output.
| /// **Logical confidence** — from the SPO tenant + witness edges ONLY (no | ||
| /// qualia). Rises when a **quorum** (agreeing) peer is bound and when the | ||
| /// semantic triple agrees with its episodic witness; the contradiction edge | ||
| /// pulls it down. | ||
| #[must_use] | ||
| pub fn logical_confidence(&self) -> f32 { | ||
| // SPO semantic ↔ episodic-witness agreement (real: does the triple's | ||
| // meaning match what was witnessed). | ||
| let sw = (pair_similarity(self.spo.subject, self.spo.ew_subject) | ||
| + pair_similarity(self.spo.predicate, self.spo.ew_predicate) | ||
| + pair_similarity(self.spo.object, self.spo.ew_object)) | ||
| / 3.0; | ||
| let quorum = if self.witness.is_bound(Locus::Quorum) { | ||
| 0.2 | ||
| } else { | ||
| 0.0 | ||
| }; | ||
| let contra = if self.witness.is_bound(Locus::Contradiction) { | ||
| 0.2 | ||
| } else { | ||
| 0.0 | ||
| }; | ||
| (0.5 * sw + 0.3 + quorum - contra).clamp(0.0, 1.0) | ||
| } |
There was a problem hiding this comment.
🎯 Functional Correctness | 🟡 Minor | ⚡ Quick win
logical_confidence() reads default (absent) SPO as "perfect agreement."
When spo is SpoFacet::default() (all-zero, meaning "no SPO tenant"), subject == ew_subject == predicate == ew_predicate == object == ew_object == (0,0), so pair_similarity returns 1.0 for all three pairs and sw = 1.0 — the formula then reports ≈0.8 confidence for a row with no real SPO grounding at all. project() correctly gates this today via conf_grounded, but this public method returns a misleading high score to any caller that invokes it directly without checking spo_present() first.
🛡️ Proposed fix: guard the direct accessor too
pub fn logical_confidence(&self) -> f32 {
+ if !self.spo_present() {
+ // No real SPO tenant: don't let the all-zero-agrees-with-all-zero
+ // artifact of `pair_similarity` masquerade as grounded agreement.
+ let quorum = if self.witness.is_bound(Locus::Quorum) { 0.2 } else { 0.0 };
+ let contra = if self.witness.is_bound(Locus::Contradiction) { 0.2 } else { 0.0 };
+ return (0.3 + quorum - contra).clamp(0.0, 1.0);
+ }
// SPO semantic ↔ episodic-witness agreement (real: does the triple's
// meaning match what was witnessed).
let sw = (pair_similarity(self.spo.subject, self.spo.ew_subject)📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| /// **Logical confidence** — from the SPO tenant + witness edges ONLY (no | |
| /// qualia). Rises when a **quorum** (agreeing) peer is bound and when the | |
| /// semantic triple agrees with its episodic witness; the contradiction edge | |
| /// pulls it down. | |
| #[must_use] | |
| pub fn logical_confidence(&self) -> f32 { | |
| // SPO semantic ↔ episodic-witness agreement (real: does the triple's | |
| // meaning match what was witnessed). | |
| let sw = (pair_similarity(self.spo.subject, self.spo.ew_subject) | |
| + pair_similarity(self.spo.predicate, self.spo.ew_predicate) | |
| + pair_similarity(self.spo.object, self.spo.ew_object)) | |
| / 3.0; | |
| let quorum = if self.witness.is_bound(Locus::Quorum) { | |
| 0.2 | |
| } else { | |
| 0.0 | |
| }; | |
| let contra = if self.witness.is_bound(Locus::Contradiction) { | |
| 0.2 | |
| } else { | |
| 0.0 | |
| }; | |
| (0.5 * sw + 0.3 + quorum - contra).clamp(0.0, 1.0) | |
| } | |
| /// **Logical confidence** — from the SPO tenant + witness edges ONLY (no | |
| /// qualia). Rises when a **quorum** (agreeing) peer is bound and when the | |
| /// semantic triple agrees with its episodic witness; the contradiction edge | |
| /// pulls it down. | |
| #[must_use] | |
| pub fn logical_confidence(&self) -> f32 { | |
| if !self.spo_present() { | |
| // No real SPO tenant: don't let the all-zero-agrees-with-all-zero | |
| // artifact of `pair_similarity` masquerade as grounded agreement. | |
| let quorum = if self.witness.is_bound(Locus::Quorum) { | |
| 0.2 | |
| } else { | |
| 0.0 | |
| }; | |
| let contra = if self.witness.is_bound(Locus::Contradiction) { | |
| 0.2 | |
| } else { | |
| 0.0 | |
| }; | |
| return (0.3 + quorum - contra).clamp(0.0, 1.0); | |
| } | |
| // SPO semantic ↔ episodic-witness agreement (real: does the triple's | |
| // meaning match what was witnessed). | |
| let sw = (pair_similarity(self.spo.subject, self.spo.ew_subject) | |
| pair_similarity(self.spo.predicate, self.spo.ew_predicate) | |
| pair_similarity(self.spo.object, self.spo.ew_object)) | |
| / 3.0; | |
| let quorum = if self.witness.is_bound(Locus::Quorum) { | |
| 0.2 | |
| } else { | |
| 0.0 | |
| }; | |
| let contra = if self.witness.is_bound(Locus::Contradiction) { | |
| 0.2 | |
| } else { | |
| 0.0 | |
| }; | |
| (0.5 * sw + 0.3 + quorum - contra).clamp(0.0, 1.0) | |
| } |
🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@crates/lance-graph-contract/src/recipe_substrate.rs` around lines 98 - 121,
Update logical_confidence() to detect an absent/default SPO facet before
calculating pairwise agreement, using the existing SPO presence semantics such
as spo_present(). Return zero confidence for ungrounded SPO while preserving the
current quorum, contradiction, and agreement formula for grounded SPO.
…w-h9osnl board: post-merge hygiene for #780 (LATEST_STATE row + PR_ARC prepend + D-REC-WIRE-1 → Shipped)
…e dispatch (Maslow carry + prune, organ-derived rung) Closes #780's Axis-B gap on the DISPATCH path. #780 wired the organs into the ctx (SubstrateView) but the dispatch gate stayed on the 8-field scalar proxy. recipe_loci is the missing half: a dispatch gate keyed to the live CausalWitnessFacet 24 loci. - required_loci(id): each recipe's consumed Locus dimensions, grounded in the recipe's own recipes.rs::substrate string. - loci_disqualifier / reachable: per-specific-dimension gate (never a popcount) — a recipe fires only when every required dimension is BOUND. - locus_rung / loci_rung / loci_dispatch_order: the ORDER is organ-derived too — a recipe is as deep as its deepest required dimension (ICR #31 → Counterfactual apex because Kausal/Contradiction ARE apex dimensions), replacing the static Tier+inference table (kept as a documented cross-check). - carried_awareness: lower-rung groundings read UP the Maslow climb, monotone, never re-derived (the anti-exponential-rediscovery property; #777). - active_after_prune: higher thinking subsumes lower-related (strict dimension superset) and drops it from active dispatch. Complements the two shipped reach-doors (A style-fan / B select_tactic) which gate on style/mechanism/scalar and never read the organ. Additive, zero-dep, nothing existing touched. 11 module tests + examples/recipe_loci_walk.rs with 4 measured gates (selector 7/34, organ 34/34 grounded, carry monotone, prune fires + apex survives). Board: E-RECIPE-LOCI-ORGAN-GATE-1, LATEST_STATE inventory, STATUS_BOARD D-REC-LOCI-1. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Awg6TXocHcwTtc6eGsHcdD
…#783 = CONVERGENT E-RECIPE-LOCI-CONVERGENCE-1: recipe_loci is the organ-gated dispatch half that pairs with my organ-input half; witness_fabric→recipe_loci is a clean producer→consumer chain. One MEASURED tension: two rung definitions (organ-depth vs inference-cost) dispatch 38% of recipe-pairs in a different order (both agree ICR#31 apex). No hard collision. Recommends 3 small wiring follow-ups. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01K3RyLEbuNSHxxB3NTTrGki
2 participants
Root cause (the audit answers "do the 34 recipes measure what they claim?")
recipe_claim_auditexercises the real shippedrecipe_kernels::kernel(id)on a positive vs control ctx, two measured axes:ThoughtFieldscalar-proxy basis — 0 read a real organ (SPO 2³ / CAM-PQ 4096² / temporal.rs Markov / VSA / deepnsm), exactly as the module doc concedes.Verdict: the recipe compositions are sound; the dominant weakness is substrate-side — the wiring, not the recipes.
The wiring (closes the gap)
causal_witness::CausalWitnessFacet— the A9 "24 edges": a reading of the 12-byte content-blind register as 24 signedi4loci (G24N4), each a context pointer (∈[−8,+7],0=unbound) into the ±8 Markov window. The third ClassView reading of the same register feat(P4): autopoiesis-triangle wiring on the SoA/ractor carrier (Bricks 1-2) #729 shipped two of (FROZEN12×u8, Orchestration6×(8:8)) — a reading, no stored bytes, envelope-safe. 16 named loci + 8 reserved-empty (never padded).recipe_substrate::SubstrateView— projects SPO + witness + qualia into the recipe input. Qualia is ADDITIVE + STAKES-only (temperature, never a logical marker); logic + causality ← SPO + the 24 witness edges (the cause isLocus::Kausal, not a qualia); a missing tenant emits NaN/empty (the NaN-disqualifier signal).recipe_dispatch— the 34 as a rung-ordered, NaN-gated causal ladder keyed by NARS inference type (deduction / induction=fanout / abduction / revision / counterfactual). Thinking is a causal act: the ladder is a causal chain; each step logs its triggering cause (Versuchsleitereffekt = observer effect); dispatch is a deterministic Schrödinger collapse; a NaN required input is an unmeasurable conjugate (skipped, not read off noise); theN≤√d/4bundle bound is the Heisenberg-shaped uncertainty relation.Evidence
clippyclean,fmtclean.recipe_claim_audit,loci_recipe_relevance(the 24×34 relevance matrix),recipe_ladder_over_substrate(the whole wiring end-to-end).Board hygiene
E-RECIPE-SUBSTRATE-WIRING-1(EPIPHANIES), LATEST_STATE contract inventory (3 modules), STATUS_BOARDD-REC-WIRE-1.Open / follow-ups (operator gates)
pair_similarityis a documented zero-dep stand-in for the ndarray 256×256 CAM-PQ table (ndarray-side follow-up).add_repo+ benchmark probe):AdaWorldAPI/NARS-Swift(inference-rule oracle for the deduction/induction/abduction/revision/counterfactual map) andMME-Reasoning(arXiv 2505.21327 — the reasoning benchmark test bed).🤖 Generated with Claude Code
Generated by Claude Code
Summary by CodeRabbit
New Features
Documentation