D-MBX-A6-P4: cycle loop-closure driver — sparse seal/apply + MUL-gate thought seam (control-loop contract)

[AdaWorldAPI]

What this is

Makes the merged #878 persist_sink cycle/WAL bootstrap load-bearing — its first caller — and closes the cycle control loop:

owners cast sparse intents → seal (one WAL write, Vn+1) + expose the sealed
paired-transition set → apply ONLY the sealed sparse transitions (represented
owners advance one legal step + watermark; unrepresented owners byte-identical)
→ CognitiveWork runs the MUL gate → owner_adapter casts the next intent →
held/Hold owners reschedule → loop → recover

Honesty ledger (what this PR proves vs does NOT)

• Control-loop contract: PROVEN — 19 falsifiers over contract-probe fakes.
• Actor-owned production wiring: NOT proven — MailboxFleet + its HashMap impl is the probe/registry fleet; bridging the sealed sparse set into KanbanActor-owned state is open. Per the ratified sparse-cycle ruling, apply is writer-fires-inline (no message bus) by design.
• cognitive-shader-driver / MailboxSoA thought: NOT proven — the P4c thought body is the real MUL gate (gate_decision_i4 → advance_on_gate), but its qualia/mantissa inputs come from a caller extractor (the deferred MailboxSoaView::qualia() seam), not a live SoA dispatch.
• Durability: FAKE — contract-probe WalSink until the concrete LanceShardSink lands (compile+test green ≠ storage proven).

The load-bearing rule (enforced in code)

A DatasetVersion is global knowledge, NOT permission to advance every mailbox. Only owners with a sealed paired_move advance; the version tick never fans a step across the fleet (E-COMPLETE-CYCLE-IS-PHYSICALLY-SPARSE-…-1, E-D-MBX-SPINE-IS-STRAIGHT-TRACK-…-1).

Review round (grain-of-salt audit, commit 71d1db1)

Each finding was verified against code; all accepted items were real defects:

1. Retry-safe seal — a WAL failure previously LOST the drained cycle. seal_cycle → Result<SealedCycle, Box<SealFailure>> now returns the complete frozen cast set byte-identical for retry. Falsifier: failed commit → zero owner mutation → same-cycle retry → exactly one version, no cast lost/duplicated.
2. Restart-stable stream positions — stream_position = CastId was the P3d-documented trap ("cast_id is provenance only"): a reconstructed BatchWriter restarts at 0 and recover_and_apply silently skips positions ≤ watermark. collect_casts now takes the caller's durable position_base cursor; SealedCycle.next_position_base carries it forward. Restart falsifier pins the exact failure mode.
3. Watermark-coupled apply — apply_sealed_transitions advances the per-owner recovery watermark WITH the phase (one rule shared with recovery). Falsifier: normal apply → crash → recovery replays NOTHING (previously: replay → permanent StalePhase stall).
4. ≤1-move/owner enforced PRE-seal — the old deferred counter sealed a durable move and then never applied it (recovery WOULD — divergent semantics). Extras (same cast or later casts; also kills the silent moves.first() truncation) return as HeldIntent, re-staged via restage_held. Sealed set == applied set; recovery-agrees falsifier.
5. Mid-apply prefix preserved — Err((partial, cause)), mirroring recover_and_apply; the prefix's watermarks survive.
6. Hold = reschedule, never strand — CognitiveWorkOutcome.held_owners + run_cognitive_work[_gated]_over re-poll; falsifier wakes a Held owner on a later cycle.
7. recover_fleet partitions history once — O(history + Σtails), not O(fleet×history).
8. P4d honesty — wait-free at the cast/cycle boundary (sequential pass); strengthened falsifier: two represented owners, A unfinished, B casts + advances without waiting. Concurrent per-owner execution is the actor leg, explicitly out of driver scope.

Declined with reason: routing P4b through KanbanActor mailboxes — contradicts the operator-ratified writer-fires-inline sparse ruling (no message bus for P4a/P4b). The honesty half is taken in docs instead (MailboxFleet is not a production-ownership claim).

Falsifiers (19 lib tests, cargo test -p lance-graph-supervisor --features cycle-driver)

• 64k/17 headline — 65 536 mailboxes, 17 sealed → exactly 17 advance, 65 519 byte-identical, one WAL write, zero dataset reads, 17 watermarks.
• Failed-seal → byte-identical retry · restart-stable positions across writer reconstruction · normal-apply-advances-watermark (no replay after crash) · held-move-lands-next-cycle + recovery-agrees · multi-move no-truncation · mid-apply prefix preservation.
• MUL-gate discriminates — three distinct outputs for three inputs (Flow→Evaluation / Block→Prune / Hold→rescheduled-and-woken), None at absorbing columns.
• P4e idempotence + load-bearing-watermark negative control · P4f O(dirty)-not-O(fleet) (640 resolves over a 64k fleet).

clippy (feature) + fmt clean; default (no-feature) supervisor build unchanged. Mints no new semantic/temporal/rung/witness type — composes SweepSlot/CycleFrame/KanbanMove/DatasetVersion/PersistError/StrategyOutcome/recover_and_apply/emit_bootstrap_intent/MailboxSoaOwner/gate_decision_i4.

Plan: .claude/plans/cycle-loop-closure-driver-v1.md (status synced). Board: STATUS_BOARD D-MBX-A6-P4 + LATEST_STATE honesty ledger.

🤖 Generated with Claude Code

[coderabbitai]

📝 Walkthrough

Walkthrough

This change adds a feature-gated cycle driver. It seals staged casts into one WAL cycle, applies sparse owner transitions, stages cognitive-work intents, evaluates MUL gates, and performs watermark-based fleet recovery. Documentation records the architecture and remaining concrete sink limitations.

Changes

Cycle loop closure

Layer / File(s)	Summary
Architecture and integration contracts .claude/board/*, .claude/plans/*	Documents the cycle-driver flow, sparse persistence rules, ownership boundaries, recovery requirements, and implementation status.
Cycle driver wiring and sparse application crates/lance-graph-supervisor/Cargo.toml, crates/lance-graph-supervisor/src/lib.rs, crates/lance-graph-supervisor/src/cycle_driver.rs	Adds the feature, cycle contracts, cast collection, single-cycle sealing, and legal sparse owner transitions.
Cognitive work, MUL gating, and recovery crates/lance-graph-supervisor/src/cycle_driver.rs	Adds intent staging, qualia-based gating, bootstrap handling, and watermark-based fleet recovery.
Cycle-driver validation crates/lance-graph-supervisor/src/cycle_driver.rs	Adds fake persistence and tests for sparse execution, scale, gating, round trips, and recovery idempotence.

Estimated code review effort: 4 (Complex) | ~60 minutes

Sequence Diagram(s)

sequenceDiagram
  participant BatchWriter
  participant CycleDriver
  participant WalSink
  participant MailboxFleet
  BatchWriter->>CycleDriver: Drain staged casts
  CycleDriver->>WalSink: Persist one sealed cycle
  WalSink-->>CycleDriver: Return sparse transitions
  CycleDriver->>MailboxFleet: Apply represented transitions
  MailboxFleet-->>CycleDriver: Return application counts

Loading

Possibly related PRs

• AdaWorldAPI/lance-graph#878: Provides the cycle/WAL persistence interfaces used by the new driver.
• AdaWorldAPI/lance-graph#537: Documents the per-owner, per-cycle sparse transition model.
• AdaWorldAPI/lance-graph#877: Introduces the owner-adapter flow extended by bootstrap intent handling.

Suggested reviewers: claude

Poem

I hop through cycles, neat and bright,
Seal sparse casts before the night.
Owners move when records say,
Quiet mailboxes stay in place.
MUL gates guide the thought’s next flight.

🚥 Pre-merge checks | ✅ 5

✅ Passed checks (5 passed)

Check name	Status	Explanation
Docstring Coverage	✅ Passed	Docstring coverage is 100.00% which is sufficient. The required threshold is 80.00%.
Linked Issues check	✅ Passed	Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check	✅ Passed	Check skipped because no linked issues were found for this pull request.
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title clearly identifies the cycle loop-closure driver and its main sparse seal/apply and MUL-gate changes.

✨ Finishing Touches

📝 Generate docstrings

• Create stacked PR
• Commit on current branch

---

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]

Cursor Bugbot has reviewed your changes using high effort and found 4 potential issues.

^{❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, enable autofix in the Cursor dashboard.}

^{Reviewed by Cursor Bugbot for commit c2134c1. Configure here.}

[cursor]

Deferred moves never advance again

Medium Severity

apply_sealed_transitions (and thus run_cycle) applies only one sealed transition per owner per cycle, deferring any subsequent ones. These durable, deferred transitions are not re-evaluated or applied in subsequent normal cycles, effectively stalling them until a recovery scan is performed.

 

^{Reviewed by Cursor Bugbot for commit c2134c1. Configure here.}

[cursor]

Apply path never updates watermarks

High Severity

After apply_sealed_transitions updates an owner's phase, it doesn't advance the associated stream_position watermark. This means recover_fleet can attempt to replay already-applied moves, leading to a PersistError::StalePhase error because the owner's phase has already progressed.

 

^{Reviewed by Cursor Bugbot for commit c2134c1. Configure here.}

[cursor]

Retry after seal loses casts

High Severity

collect_casts drains BatchWriter payloads before persist_cycle succeeds, and run_cycle always collects first. On a retryable PersistError::Write, a caller that re-invokes run_cycle gets an empty drain while intent rows remain on the writer board, so those casts never reach the WAL unless the caller kept the earlier Vec<SweepSlot> and retries seal_cycle alone.

Additional Locations (1)

• crates/lance-graph-supervisor/src/cycle_driver.rs#L274-L276

 

^{Reviewed by Cursor Bugbot for commit c2134c1. Configure here.}

[cursor]

CastId breaks stream watermarks

Medium Severity

collect_casts sets SweepSlot::stream_position to the per-writer CastId, which resets when BatchWriter::new() is used. That violates the persist contract that stream_position stay monotonic per owner across cycles, so recovery can skip new landings when an old watermark dominates restarted cast ids.

 

^{Reviewed by Cursor Bugbot for commit c2134c1. Configure here.}

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: c2134c159e

ℹ️ 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".

[chatgpt-codex-connector]

Use a restart-stable stream position

Do not use the in-memory CastId directly as the durable watermark key. BatchWriter::new() resets next_id to zero after a restart, while recover_and_apply skips every landing whose stream_position <= the previously persisted watermark. Consequently, casts sealed after a restart can reuse old positions and be silently skipped during the next recovery; the position must remain monotonic across writer instances, as required by SweepSlot's contract.

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

Retain drained casts when sealing fails

Preserve or return the collected casts when seal_cycle reports a retryable PersistError::Write. At this point collect_casts has drained pending_payloads, and seal_cycle consumes the only remaining payload copies, so a transient WAL failure drops every staged update; retrying run_cycle with the same writer sees an empty batch and can seal an empty cycle instead of the intended data.

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

Carry deferred transitions into the next horizon

Actually retain the transition when a second same-owner cast is deferred. The branch only increments a counter and discards the transition reference; AppliedCycle returns no deferred moves and run_cycle does not stage them again. Thus, when stacked casts contain sequential moves for one owner, the later durable move never executes during normal operation despite the comment claiming it waits for the next sealed horizon.

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

Reschedule owners when the gate holds

Requeue an owner when shade_owner returns None for Hold or for a blocked CognitiveWork phase. run_cognitive_work only evaluates owners present in AppliedCycle because they just entered CognitiveWork; casting nothing means that owner is absent from every subsequent cycle and the gate is never evaluated again, so common Hold decisions permanently strand the mailbox instead of resting for one cycle and re-evaluating.

Useful? React with 👍 / 👎.

[coderabbitai]

Actionable comments posted: 6

🧹 Nitpick comments (3)

crates/lance-graph-supervisor/src/cycle_driver.rs (3)

797-832: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Add a test for the OwnerMismatch branch.

The tests cover StalePhase and the missing-owner count. The OwnerMismatch guard at lines 233-238 and the Illegal mapping at lines 246-248 have no test. persist_cycle rejects cross-owner moves at seal time, so this guard is only reachable through a directly constructed SealedCycle. That is exactly what a test can build.

💚 Proposed test

+    // ── P4b: a cross-owner sealed move is rejected (defence in depth) ──────────
+    #[test]
+    fn p4b_cross_owner_move_is_an_owner_mismatch() {
+        let mut fleet: HashMap<MailboxId, FakeOwner> =
+            HashMap::from([(7, FakeOwner::at(7, KanbanColumn::Planning))]);
+        let sealed = SealedCycle {
+            version: DatasetVersion(1),
+            transitions: vec![SealedTransition {
+                stream_position: 0,
+                owner: 7,
+                // the move claims mailbox 8 while landing on owner 7
+                mv: mv(8, KanbanColumn::Planning, KanbanColumn::CognitiveWork),
+            }],
+        };
+        assert!(matches!(
+            apply_sealed_transitions(&mut fleet, &sealed),
+            Err(PersistError::OwnerMismatch { .. })
+        ));
+    }

Based on coding guidelines: "Add Rust unit tests alongside implementations via #[cfg(test)] modules; prefer focused scenarios over broad integration tests".

🤖 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-supervisor/src/cycle_driver.rs` around lines 797 - 832,
Add a focused #[tokio::test] alongside the existing apply_sealed_transitions
tests that constructs a SealedCycle containing a directly created
SealedTransition whose owner differs from the move’s embedded owner, then assert
apply_sealed_transitions returns PersistError::OwnerMismatch. Also add coverage
for the Illegal mapping if it is a separate reachable branch, using the existing
test helpers and error-matching style without changing production behavior.

Source: Coding guidelines

---

356-377: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Move the gate inference onto the carrier object.

shade_owner is a free function that receives the carrier (owner) and its cognitive state (qualia, mantissa) as separate arguments. Put the inference on the carrier instead, through an extension trait with a blanket impl. The call site then reads owner.shade(&qualia, mantissa, reliability). When MailboxSoaView::qualia() lands, the trait method can drop the extra arguments without changing the call shape.

♻️ Proposed extension trait

+/// Carrier-side MUL gate inference. Blanket-implemented for every
+/// `MailboxSoaOwner`; collapses to `shade(reliability)` once
+/// `MailboxSoaView::qualia()` lands.
+pub trait ShadeOwner: MailboxSoaOwner {
+    fn shade(
+        &self,
+        qualia: &QualiaI4_16D,
+        mantissa: i8,
+        reliability: f32,
+    ) -> Option<StrategyOutcome> {
+        let phase = self.phase();
+        let to = phase.advance_on_gate(&gate_decision_i4(qualia, mantissa))?;
+        Some(StrategyOutcome {
+            reliability,
+            intended_move: Some(KanbanMove {
+                mailbox: 0,
+                from: phase,
+                to,
+                witness_chain_position: 0,
+                exec: ExecTarget::Native,
+            }),
+        })
+    }
+}
+impl<O: MailboxSoaOwner> ShadeOwner for O {}

Then run_cognitive_work_gated calls owner.shade(&qualia, mantissa, reliability)?.

Based on coding guidelines: "Keep cognitive state and inference behavior on the carrier object: prefer methods such as trajectory.resolve() over free functions that separately receive the carrier state."

🤖 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-supervisor/src/cycle_driver.rs` around lines 356 - 377,
Move the logic from the free function shade_owner onto the carrier via an
extension trait with a blanket impl for MailboxSoaOwner. Define the trait method
shade and have it perform the existing gate_decision_i4, phase advancement, and
StrategyOutcome construction; update run_cognitive_work_gated to call
owner.shade(&qualia, mantissa, reliability)? while preserving the current
sentinel move behavior.

Source: Coding guidelines

---

433-433: 🚀 Performance & Scalability | 🔵 Trivial | ⚡ Quick win

Consider a version floor for scan_sealed.

recover_fleet always calls scan_sealed(None), so it materializes the entire sealed history into memory on every pass. The history grows with every cycle, so recovery time and peak memory grow without bound. Recovery becomes slower as the system runs longer.

Accept an optional from: Option<DatasetVersion> floor derived from the lowest persisted watermark, or plan a WAL truncation point before the concrete LanceShardSink lands.

🤖 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-supervisor/src/cycle_driver.rs` at line 433, Update
recover_fleet and the scan_sealed call to avoid materializing the entire sealed
history: derive the lowest persisted watermark as a DatasetVersion floor and
pass it through the optional from parameter. Ensure recovery still includes
every sealed entry needed from that floor onward; if the sink cannot support
this yet, establish a WAL truncation point before introducing LanceShardSink.

🤖 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 @.claude/board/INTEGRATION_PLANS.md:
- Around line 1-35: Synchronize the plan metadata with the shipped P4a–P4f
implementation: in .claude/board/INTEGRATION_PLANS.md lines 1-35, mark the entry
historical or implemented and link the feature-gated driver; in
.claude/plans/cycle-loop-closure-driver-v1.md lines 3-13, replace the
planned/unshipped status, lines 42-52, mark the zero-production-caller statement
as historical, and lines 345-347, clarify that status discipline distinguishes
design history from implementation status.

In @.claude/plans/persistence-cycle-wal-bootstrap-v1.md:
- Line 269: Align the section numbering in the persistence-cycle document:
update the headings currently labeled “2.1” and “2.2” to “3.1” and “3.2” to
match the reference at §3.1, or consistently change the reference back to
§2.1/§2.2. Ensure all related cross-references use the same numbering scheme.
- Line 80: Update every diagram-only Markdown fence to declare the text language
for MD040 compliance: .claude/plans/persistence-cycle-wal-bootstrap-v1.md lines
80, 95, 122, 154, and 165, plus .claude/plans/cycle-loop-closure-driver-v1.md
lines 94 and 260. Add text to each opening fence without changing the diagram
contents.

In `@crates/lance-graph-supervisor/src/cycle_driver.rs`:
- Around line 232-251: Update apply_sealed_transitions to return the
already-built AppliedCycle together with PersistError on every OwnerMismatch,
StalePhase, or Illegal early return, constructing it from applied, deferred, and
missing. Align the result shape with persist_sink::recover_and_apply, then
update run_cycle to unpack/map the error tuple while preserving the recovered
applied prefix for callers to persist.
- Around line 433-457: Update the recovery flow around recover_fleet and
recover_and_apply to partition sealed landings by owner once before iterating
fleet_ids, then pass each owner’s grouped landings into recover_and_apply
instead of the full sealed slice. Preserve the existing per-owner ordering,
watermark updates, partial-error handling, and recovery counters.
- Around line 128-161: Document on collect_casts or its surrounding API that the
same BatchWriter instance must be reused across cycles, because
SweepSlot::stream_position derives from cast.0 and must remain monotonic per
owner for durable recovery watermarks; clarify that drain_pending_payloads only
clears staged payloads and does not permit recreating the writer with a reset
counter.

---

Nitpick comments:
In `@crates/lance-graph-supervisor/src/cycle_driver.rs`:
- Around line 797-832: Add a focused #[tokio::test] alongside the existing
apply_sealed_transitions tests that constructs a SealedCycle containing a
directly created SealedTransition whose owner differs from the move’s embedded
owner, then assert apply_sealed_transitions returns PersistError::OwnerMismatch.
Also add coverage for the Illegal mapping if it is a separate reachable branch,
using the existing test helpers and error-matching style without changing
production behavior.
- Around line 356-377: Move the logic from the free function shade_owner onto
the carrier via an extension trait with a blanket impl for MailboxSoaOwner.
Define the trait method shade and have it perform the existing gate_decision_i4,
phase advancement, and StrategyOutcome construction; update
run_cognitive_work_gated to call owner.shade(&qualia, mantissa, reliability)?
while preserving the current sentinel move behavior.
- Line 433: Update recover_fleet and the scan_sealed call to avoid materializing
the entire sealed history: derive the lowest persisted watermark as a
DatasetVersion floor and pass it through the optional from parameter. Ensure
recovery still includes every sealed entry needed from that floor onward; if the
sink cannot support this yet, establish a WAL truncation point before
introducing LanceShardSink.

🪄 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: ed2db7f4-0d99-440f-92d8-9a70ab441df0

📥 Commits

Reviewing files that changed from the base of the PR and between 18b5b65 and c2134c1.

⛔ Files ignored due to path filters (1)

• Cargo.lock is excluded by !**/*.lock

📒 Files selected for processing (9)

• .claude/board/EPIPHANIES.md
• .claude/board/INTEGRATION_PLANS.md
• .claude/board/LATEST_STATE.md
• .claude/board/STATUS_BOARD.md
• .claude/plans/cycle-loop-closure-driver-v1.md
• .claude/plans/persistence-cycle-wal-bootstrap-v1.md
• crates/lance-graph-supervisor/Cargo.toml
• crates/lance-graph-supervisor/src/cycle_driver.rs
• crates/lance-graph-supervisor/src/lib.rs

[coderabbitai]

📐 Maintainability & Code Quality | 🟡 Minor | ⚡ Quick win

Synchronize the design-plan status with the shipped implementation.

Both documents retain pre-implementation wording while the current board records P4a–P4f as shipped.

• .claude/board/INTEGRATION_PLANS.md#L1-L35: mark the entry historical or implemented, and link the feature-gated driver.
• .claude/plans/cycle-loop-closure-driver-v1.md#L3-L13: update the planned/unshipped status.
• .claude/plans/cycle-loop-closure-driver-v1.md#L42-L52: mark the zero-caller statement as historical.
• .claude/plans/cycle-loop-closure-driver-v1.md#L345-L347: update the status discipline to distinguish design history from implementation status.

📍 Affects 2 files

• .claude/board/INTEGRATION_PLANS.md#L1-L35 (this comment)
• .claude/plans/cycle-loop-closure-driver-v1.md#L3-L13
• .claude/plans/cycle-loop-closure-driver-v1.md#L42-L52
• .claude/plans/cycle-loop-closure-driver-v1.md#L345-L347

🤖 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 @.claude/board/INTEGRATION_PLANS.md around lines 1 - 35, Synchronize the plan
metadata with the shipped P4a–P4f implementation: in
.claude/board/INTEGRATION_PLANS.md lines 1-35, mark the entry historical or
implemented and link the feature-gated driver; in
.claude/plans/cycle-loop-closure-driver-v1.md lines 3-13, replace the
planned/unshipped status, lines 42-52, mark the zero-production-caller statement
as historical, and lines 345-347, clarify that status discipline distinguishes
design history from implementation status.

[coderabbitai]

📐 Maintainability & Code Quality | 🟡 Minor | ⚡ Quick win

Make all Markdown diagram fences explicit.

The same MD040 lint issue affects diagram-only fences in both plans.

• .claude/plans/persistence-cycle-wal-bootstrap-v1.md#L80-L80: add text to the opening fence.
• .claude/plans/persistence-cycle-wal-bootstrap-v1.md#L95-L95: add text to the opening fence.
• .claude/plans/persistence-cycle-wal-bootstrap-v1.md#L122-L122: add text to the opening fence.
• .claude/plans/persistence-cycle-wal-bootstrap-v1.md#L154-L154: add text to the opening fence.
• .claude/plans/persistence-cycle-wal-bootstrap-v1.md#L165-L165: add text to the opening fence.
• .claude/plans/cycle-loop-closure-driver-v1.md#L94-L94: add text to the opening fence.
• .claude/plans/cycle-loop-closure-driver-v1.md#L260-L260: add text to the opening fence.

🧰 Tools

🪛 markdownlint-cli2 (0.23.1)

[warning] 80-80: Fenced code blocks should have a language specified

(MD040, fenced-code-language)

📍 Affects 2 files

• .claude/plans/persistence-cycle-wal-bootstrap-v1.md#L80-L80 (this comment)
• .claude/plans/persistence-cycle-wal-bootstrap-v1.md#L95-L95
• .claude/plans/persistence-cycle-wal-bootstrap-v1.md#L122-L122
• .claude/plans/persistence-cycle-wal-bootstrap-v1.md#L154-L154
• .claude/plans/persistence-cycle-wal-bootstrap-v1.md#L165-L165
• .claude/plans/cycle-loop-closure-driver-v1.md#L94-L94
• .claude/plans/cycle-loop-closure-driver-v1.md#L260-L260

🤖 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 @.claude/plans/persistence-cycle-wal-bootstrap-v1.md at line 80, Update every
diagram-only Markdown fence to declare the text language for MD040 compliance:
.claude/plans/persistence-cycle-wal-bootstrap-v1.md lines 80, 95, 122, 154, and
165, plus .claude/plans/cycle-loop-closure-driver-v1.md lines 94 and 260. Add
text to each opening fence without changing the diagram contents.

Source: Linters/SAST tools

[coderabbitai]

📐 Maintainability & Code Quality | 🟡 Minor | ⚡ Quick win

Make the section references resolve.

The updated reference at Line 269 points to §3.1, but the corresponding headings remain ### 2.1 and ### 2.2. Rename those headings to 3.1 and 3.2, or keep all references at 2.1 and 2.2. The current mixed numbering breaks navigation.

🤖 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 @.claude/plans/persistence-cycle-wal-bootstrap-v1.md at line 269, Align the
section numbering in the persistence-cycle document: update the headings
currently labeled “2.1” and “2.2” to “3.1” and “3.2” to match the reference at
§3.1, or consistently change the reference back to §2.1/§2.2. Ensure all related
cross-references use the same numbering scheme.