[AdaWorldAPI]

This PR changes a plan and the board only; no code. It is based on main at d3fb285, after #1628.

What changes

Operator decision, 2026-10-20: one fold costs about 1.7 ns, so between 10⁶ and 10⁹ folds are cheaper than a single write. Most of thought git therefore runs in memory as an API, and writing to Lance is a deliberate decision. The new section is "Correction: replay is the API, the write is the Rubicon decision" in thought-git-basics-v1.md:

1. Folds against a write. The operator puts one write at 233–350 ms. The figures measured in this repo:
   • a 1.7 ms write floor;
   • a LanceCycleWriter commit of 5.8–10.5 ms;
   • 336 ms for a Lance scan and 532 ms for a replay from Lance.
2. 99.9 % of the operations run autonomously in memory: branch, write, diff, status, squash, discard and replay. None of them calls Lance.
3. Squash stacks the unremarkable. A thought without anomalies is squashed onto the stack, and work continues on a new branch. The anomaly signals already exist in code:
   • contradiction records (givens_layer_probe);
   • regressions, i.e. visits > 1 (AlphaOverlay);
   • cold/hot surprise, i.e. a non-empty expected.xor(attended) (AlphaMask);
   • two thoughts reading one address differently (ThoughtTables::differs).
4. The write is the Rubicon decision in Heckhausen's sense: a result is landed only when it is satisfactory. A kanban card tracks the intention to write, not the branch.
5. Presence decides what is written. These rules are read from the code, not newly designed:
   • an absent lane is unknown (the NaN case), never zero;
   • agreement with a given is not stored;
   • a contradiction is recorded, never stored as a value;
   • RowDelta keeps only the slots that differ from the base.
6. Rebase is replay of the receipt on the new base, so v1 needs no recursion driver.
7. "Satisfactory" is decided by automated hypothesis testing. Each strategy runs as one branch on the same Sudoku fixture; jc compares and synthesizes the branches with statistics through an R-style API.
   • The engines run in parallel, one per crate. lance-graph-act-r, -metta, -nal, -relalg and -mask-risc exist; lance-graph-cog (Hyperon) and lance-graph-ona do not yet.
   • First come the different strategies on Sudoku, then the 115 rows of nal_inventory.tsv, run as MeTTa programs.
   • MeTTa runs the way PeTTa runs it: compiled to relational clauses, executed on datafrog instead of SWI-Prolog. ruff_metta_spo extracts each rule and classifies it against PeTTa's builtin registry. hyperon-experimental is optional.
8. A separate table holds three things: the relations of relalg, Datalog and datafrog, the git metadata (PR entries), and the replay receipts.
   • Rows are keyed by (data dataset, data version, thought id), which links them to the kanban lane version. The data table and this table do not depend on each other's schema.
   • Relations take the measured D-MPS-8 layout, a versioned relationship table. MORK and PathMap stay disposable oracle indexes behind the Schnellverschluss.
   • This settles where a landed receipt lives (D-TGB-4) and the PR-record question in thought-git-api-v1.md.
   • Open: landing now writes two Lance versions, which are not atomic together. The working rule is to write the data first, then the metadata row. A missing metadata row is detected at replay, and D-TGB-3 gets a new falsifier for it.
9. Thought git is a reusable API, and drivers sit outside it.
   • The API owns the verbs, the slot pool, the cells, the anomaly readings, the receipts and the metadata table. It never chooses what to do next.
   • A driver owns that policy and acts only through the verbs. The drivers named are:
     • ACT-R (arbitrate picks an intent from the candidates the API supplies);
     • graph-flow-kanban in rs-graph-llm (advances on mul::GateDecision);
     • ogar-loco.
   • Proposed placement: types in the contract, one implementation crate, each adapter with its driver.
10. Orchestration runs in phases, and the stack under the API is fixed.
    • Phase 1 drives the API through ogar-loco / ActionDef; phase 2 drives it through ACT-R.
    • Under the API: datafrog > lance-graph-mask-risc (the RISC polyfill) > lance-graph-relalg > lance-graph-r2il. petgraph is optional, as a usability layer only.
    • lance-graph-supervisor runs in parallel; kanban_actor.rs is read only.
    • lance-graph-flow inherits the langgraph-style part of rs-graph-llm (graph-flow, Rig).
    • Later, not scheduled: OpenPsi for motivation (after a transcode), and MeTTa over lance-graph-mork for folding.
    • D-TGB-8 (new): the abstraction API. datafrog asks (derives the candidates), ACT-R chooses (arbitrate).
11. Polyfill, never legacy. Everything the API executes runs on the polyfill stack. The plan names the legacy paths this rules out: AlphaTunnel's ten static rung lanes, the competing w_slot readers, the deleted kanban actor, the quarantined OutgoingHop gather, DataFusion, SWI-Prolog and the Hyperon interpreter as executors, and graph-flow session storage as a home for state. datafrog is lowered to the polyfill where it executes and stays the exact oracle for that lowering.

Consequences in the plan

• D-TGB-1 (slot pool): branch now takes a slot without a decision, and squash, discard or land free it. At 63 slots, unremarkable thoughts are squashed first; if none is, branch is refused. The old rule "slot taken at the Rubicon crossing" is struck.

• D-TGB-0 (fixtures): new fixtures for:

  • write intentions;
  • the squash stack;
  • each anomaly signal stopping the squash;
  • an unwritten lane reading as absent, not zero.

  The w_slot reference fixtures, left over from the withdrawn pointer reading, are struck.

• D-TGB-7 (new): the reusable API plus the first driver. Its falsifier is driver independence: two drivers that make the same decisions produce byte-identical cells, receipts and metadata rows.

• D-TGB-8 (new): the datafrog-asks / ACT-R-chooses abstraction API.

• Open questions added:

  • the anomaly predicate and its thresholds;
  • the jc statistic and its threshold for "satisfactory";
  • the jc R-style interface;
  • the name of the implementation crate.

• Board:

  • STATUS_BOARD rows D-TGB-0, D-TGB-1, D-TGB-7 and D-TGB-8;
  • a new board entry, 2026-10-20-thought-git-replay-api-write-rubicon;
  • the entries index, regenerated (387 rows);
  • the supersession index, regenerated: the plan cites the REUSE ruling on GateDecision.

🤖 Generated with Claude Code

https://claude.ai/code/session_01VncKoyG6JkpsoqhqTGTv3f

[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: Advanced
• Run ID: 4b01c933-ba2c-4917-beb4-509a326d00d1

• Autofix · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts

Warning

Billing warning: we have not been able to collect payment for this subscription for more than 72 hours. Please update the payment method or pay any pending invoices in Billing to avoid service interruption.

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.}

[chatgpt-codex-connector]

Codex Review Summary

This comment shows the latest Codex review activity on this pull request.

Review	Status	Commit	Review trigger
📝 Code Review	✅ Completed 2026-10-20T15:49:05.985081Z	9120978	Draft marked ready

ℹ️ 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" or "@codex security review".

Codex reacts with 👀 while any review is running, comments if it has suggestions, and reacts with 👍 once all reviews finish with no findings.