negentropy

Announce: Arc Close: 💎 Active Negentropy — We Now Crystallize Intent

You are now operating as a suspended scheduler that has switched to evaluation mode. This is not a formality. This is a phase transition from generator to the gatekeeper for a repository of clean code.

If the current Arc has not been bounded, then stop, perform a /checkpoint, and return here with /negentropy.

Now that you have completed the final checkpoint of the current task, we are now completing the Major Arc and entering the negentropy pass.

This is not a review. This is a restarting scheduler that re-evaluates the entire arc of work as a single demanded computation graph assembled from all /checkpoint derived traces.

When you do this right, no new disorder is introduced to the codebase.

Phase 1 — Assemble The DCG

Run $CLAUDE_ARCS_ROOT/tools/checkpoint-range.sh to collect the checkpoint range and rebase base. If the tool exits non-zero, there are no checkpoints to process — report this and stop.

List the collected commits (hash + subject) and the rebase base before proceeding.

For each collected checkpoint:

• Collect all Boundary and Frontier entries from every checkpoint message.
• Union the boundaries — this is your total modification surface.
• Union the frontiers — this is your total observation surface.
• Note the work descriptions — this is your crystallized intent.

The scope of this negentropy pass is the modification surface plus any frontier node that shares a dependency edge with a modified node.

List this scope explicitly before proceeding.

Phase 2 — Fixed-point Compression

Apply two lenses to the assembled scope: source entropy (the Compression Principle) and runtime entropy. This is an iterative process:

• Examine the modification surface for source entropy. Apply deletion challenges across checkpoint boundaries — redundancies invisible within a single checkpoint may be visible across the full arc.

• Examine the modification surface for runtime entropy. Source compression does not catch execution cost. Apply deletion challenges to:

  • Unnecessary work — redundant computation, repeated reads, N+1 patterns
  • Missed concurrency — independent operations forced sequential
  • Hot-path bloat — new blocking work in startup or per-request/per-render paths
  • Recurring no-op updates — state writes inside loops or handlers without change-detection guards (and updater/reducer wrappers that drop same-reference returns, silently defeating caller no-ops)
  • TOCTOU existence checks — pre-checking before the operation instead of operating and handling failure
  • Memory leaks — unbounded structures or leaked listeners
  • Overly broad operations — loading an entire file when a portion suffices

• Examine frontier nodes now in scope. If your modifications changed the contract or semantics of a boundary node, verify that frontier nodes still cohere. If a frontier node is now inconsistent, it enters the modification surface.

• If the modification surface expanded, repeat from the top.

• If the modification surface is stable, you have reached a fixed point. Stop.

This is convergence, not coverage. You do not expand indefinitely. You expand only where the lenses find purchase, and you stop when they don't. The width of the pass is an emergent property of the change set, not a parameter.

Phase 3 — Rebase Crystallized

All checkpoints collapse into a single commit. The archaeological record of hesitation is destroyed. The final diff should read as if it were written in one confident pass by someone who knew exactly what they were doing.

Using the commit set and rebase base identified in Phase 1, squash all commits between the base and HEAD into a single commit. If Phase 1 found no checkpoints, report "nothing to rebase" and stop. Everything between the base and HEAD — including non-checkpoint commits interleaved or trailing — collapses into a single commit.

Compose a single commit message from the full messages of every checkpoint in the range. The commit message describes what changed and why, not how you got there.

Format:

<imperative summary>

- <descriptive bullet points (exempt from the evergreen rule)>

Omit the Co-Authored-By trailer.

Squash:

git reset --soft <base-commit> && git commit

Verify with git log --oneline -5 after the commit.

If the final diff does not satisfy the Compression Principle — if there are lines you would challenge in code review, then you are not done.

After all phases complete, summarize what changed and resume the prior task.