diff --git a/README.md b/README.md
index c5dd4c4..a1c60df 100644
--- a/README.md
+++ b/README.md
@@ -43,6 +43,44 @@ pnpm test:e2e   # Playwright end-to-end tests
 pnpm benchmark:solve
 ```
 
+## Solver Analysis CLI
+
+`pnpm benchmark:solve` is the unified batch solver-analysis command. It scans
+`dataset/public` and local `dataset/private` manifests by default, runs each
+puzzle once, and writes timestamped text and TSV analysis artifacts under
+`benchmark-results/<dataset-id>/<timestamp>/`.
+
+Target specific datasets or puzzle IDs while developing:
+
+```bash
+pnpm benchmark:solve --dataset dataset/public/masyu.json --ids masyu-20x20-8268975,masyu-25x25-988309
+```
+
+Useful options:
+
+```text
+--dataset <path>       Repeatable manifest path
+--ids <a,b,c>          Repeatable puzzle-ID filter
+--max-steps <n>        Default: 2000
+--timeout-ms <n>       Per-puzzle timeout, default: 60000
+--telemetry <level>    off | summary, default: summary
+--format <mode>        text | tsv | both | json, default: both
+--out-dir <path>       Default: benchmark-results
+```
+
+The default `both` mode prints and saves `summary.txt`, then writes
+`puzzles.tsv`, `rule-attempts.tsv`, and `strong-inference.tsv`. These long-form
+tables are intended for spreadsheets, pivot tables, and scripts. With
+`--telemetry off`, only `puzzles.tsv` is generated. JSON is reserved for
+complete debugging output and is written only when explicitly requested with
+`--format json`.
+
+Summary telemetry reports rule attempts, misses, durations, and supported
+strong-inference work. Reports also list strong-inference rules whose detailed
+telemetry interface has not been implemented, so empty Strong data is not
+mistaken for a rule that never ran. Generated artifacts have no compatibility
+guarantee.
+
 ## App Surfaces
 
 - **Solver** (`/`): import a puzzle, run one deduction at a time, jump through the replay timeline, inspect explanations and strong-inference branches, view stats, and export supported states.
diff --git a/dataset/public/masyu.json b/dataset/public/masyu.json
index 4a17353..33164f8 100644
--- a/dataset/public/masyu.json
+++ b/dataset/public/masyu.json
@@ -498,6 +498,15 @@
       "height": 15,
       "tags": ["easy", "Medium"],
       "source": "example.txt"
+    },
+    {
+      "id": "masyu-25x25-1202688",
+      "puzzleType": "masyu",
+      "sourceUrl": "https://puzz.link/p?mashu/25/25/00k900o0j0la9a1120000000312la7b1i9036g6ii900110l303600i42102c953163101f179344169f01309119i300aa909221502f080c3f3079m20163l39f10a03p00300400163fi593j031039kj1i01600000c713b0e09190e23632f6099b040c0f999c020909p00",
+      "width": 25,
+      "height": 25,
+      "tags": ["hard", "Large"],
+      "source": "example.txt"
     }
   ]
 }
diff --git a/docs/PROJECT_GUIDE_EN.md b/docs/PROJECT_GUIDE_EN.md
index f66ebff..377694a 100644
--- a/docs/PROJECT_GUIDE_EN.md
+++ b/docs/PROJECT_GUIDE_EN.md
@@ -142,15 +142,45 @@ Run:
 pnpm benchmark:solve
 ```
 
-The benchmark runner scans public/private manifests, runs each puzzle with the default plugin rule order, and writes reports to `benchmark-results/<dataset-id>.report.json`.
+The unified solver-analysis runner scans public/private manifests, runs each
+puzzle once with the default plugin rule order, and writes timestamped analysis
+artifacts under `benchmark-results/<dataset-id>/<YYYYMMDD-HHmmss>/`.
 
 Default benchmark settings:
 
 - `maxSteps = 2000`
 - `timeoutMs = 60000`
 - `ruleProfile = "default"`
+- `telemetry = "summary"`
 
-Reports include per-puzzle status, step count, duration, terminal completion report, `ruleUsage`, and compact `ruleSteps`. Full `steps` are intentionally omitted to keep reports small.
+Targeted development runs can select explicit manifests and puzzle IDs:
+
+```bash
+pnpm benchmark:solve --dataset dataset/public/masyu.json --ids masyu-20x20-8268975,masyu-25x25-988309
+```
+
+CLI options:
+
+- `--dataset <path>` is repeatable; without it, public/private manifests are scanned.
+- `--ids <a,b,c>` is repeatable and filters selected manifests.
+- `--max-steps <n>` and `--timeout-ms <n>` set per-puzzle limits.
+- `--telemetry off | summary` controls observer collectors.
+- `--format text | tsv | both | json` controls generated artifacts; default
+  `both` means text plus TSV and never includes JSON.
+- `--out-dir <path>` changes the artifact output directory.
+
+The default run prints and saves `summary.txt`, plus three long-form tables:
+`puzzles.tsv` for one-row-per-puzzle outcomes, `rule-attempts.tsv` for per-rule
+cost and hit behavior, and `strong-inference.tsv` for detailed Strong work.
+When telemetry is off, only the puzzle table is generated. JSON retains the
+complete schema-v2 report for urgent debugging and is written only by explicit
+`--format json`.
+
+Rule attempt telemetry includes misses and the final no-hit scan. Strong
+inference telemetry includes explicit plugin-declared coverage, so unsupported
+collection interfaces are distinguishable from a run that produced no Strong
+events. Generated artifacts are development outputs with no compatibility
+guarantee. Full replay steps and rule-step locations are intentionally omitted.
 
 ## 8. AI Agent Quick Start
 
@@ -168,6 +198,7 @@ For targeted work:
 
 - Slitherlink rules: start at `src/domain/rules/slither/rules.ts`.
 - Masyu rules: start at `docs/MASYU_AGENT_BRIEF.md`, then inspect `src/domain/rules/masyu/rules.ts`.
+- Rule documentation: follow `docs/RULE_DOCUMENTATION_AGENT_WORKFLOW.md`.
 - Editor/UI work: inspect the relevant `src/features/*` component plus page tests.
 - Benchmark work: read `src/domain/benchmark/runner.ts` and `scripts/benchmark-solve.ts`.
 - Historical Masyu plans: check `docs/legacy/` only when old design context is useful.
diff --git a/docs/RULE_DOCUMENTATION_AGENT_WORKFLOW.md b/docs/RULE_DOCUMENTATION_AGENT_WORKFLOW.md
new file mode 100644
index 0000000..06b0626
--- /dev/null
+++ b/docs/RULE_DOCUMENTATION_AGENT_WORKFLOW.md
@@ -0,0 +1,363 @@
+# Rule Documentation Agent Workflow
+
+Use this workflow when documenting registered PuzzleKit solver rules. It is
+designed for AI agents that must read the production implementation, explain the
+deduction accurately, and add an in-app rule page without changing solver
+behavior.
+
+## Goal
+
+For each selected rule, produce documentation that lets a player answer three
+questions:
+
+1. **What it does:** What decisions can this rule add to the board?
+2. **When it triggers:** What exact board state allows the deduction?
+3. **Why it works:** Why would every alternative violate a puzzle rule?
+
+The production rule implementation is the source of truth. Existing names,
+messages, tests, technique notes, and external terminology are supporting
+evidence only.
+
+## Required Reading
+
+Read these files before documenting a rule:
+
+1. The rule factory and every helper that materially affects its trigger or
+   conclusion.
+2. The rule registration file to understand its order and puzzle family.
+3. Existing focused tests to see supported orientations, boundary cases, and
+   multi-match behavior.
+4. `src/features/docs/ruleDocRegistry.tsx`
+5. `src/features/docs/ruleExamples.ts`
+6. `src/features/docs/RuleExample.tsx`
+7. The `.rule-example*` styles in `src/app/workspace.css`
+8. Existing MDX documents under `docs/content/<puzzle>/rules/`
+
+Do not infer behavior from the rule name alone.
+
+## Workflow
+
+### 1. Build a Rule Fact Sheet
+
+Before editing, write a private fact sheet from the implementation:
+
+```text
+Rule ID:
+Current display name:
+Factory function:
+Puzzle family:
+Trigger:
+Conclusions:
+Orientations or mirrored forms:
+Existing-state requirements:
+Boundary behavior:
+Multiple matches in one application:
+Reason the deduction is valid:
+Related implementation helpers:
+```
+
+Resolve discrepancies by trusting current production code. If the code appears
+logically incorrect or broader than the intended technique, stop documenting
+and report the suspected rule issue separately.
+
+### 2. Review the User-Facing Name
+
+Prefer a short, recognizable technique name that describes the pattern or
+reasoning concept.
+
+- Change the display name when the current name is overly implementation-driven,
+  verbose, or ambiguous.
+- Preserve the rule ID and factory function by default. They may be referenced
+  by deep links, traces, tests, benchmarks, or external notes.
+- Update the solver-step message when the existing wording no longer matches the
+  improved name or explanation.
+- Keep the message concise and state the trigger plus conclusion. Do not attempt
+  to reproduce the full MDX explanation in the solver trace.
+
+### 3. Write the MDX Document
+
+Write in clear English. Every rule document must contain exactly these three
+sections:
+
+```md
+## What it does
+
+State the visible deductions the rule makes. Include distinct conclusion types
+in this section.
+
+## When it triggers
+
+State the minimum board conditions required before the rule can act. Explicitly
+say when no prior decisions are required.
+
+## Why it works
+
+Give the shortest complete logical argument. Explain which puzzle constraint
+would be violated by the alternatives.
+```
+
+Writing rules:
+
+- Use player-facing puzzle terms, not implementation variables.
+- Be precise about `line`, `crossed out`, `inside`, `outside`, clue values,
+  pearls, vertices, and cells.
+- Describe rotations and mirrored forms only when they materially clarify the
+  trigger.
+- Mention multiple subcases only when they share one compact explanation.
+- Avoid restating the same sentence in more than one section.
+- Do not add `Conclusions`, `Limits and related techniques`, or generic
+  background sections.
+- Do not claim a deduction is unconditional when it relies on the single-loop
+  rule, a non-empty remainder, uniqueness, or another global assumption.
+
+### 4. Decide Whether to Add a Canvas Example
+
+Classify the rule before creating example data. A rule does not need to fit into
+one Canvas to qualify. Prefer a small multi-Canvas group over omitting a useful
+deterministic explanation merely because the rule has several separable cases.
+
+The classifications are:
+
+- **Simple deterministic:** use one Canvas case.
+- **Separable deterministic:** use multiple Canvas cases.
+- **Strong inference:** never add Canvas cases.
+- **Too complex or too coupled:** defer the Canvas and leave an explicit
+  reminder for the author.
+
+#### A. Simple deterministic rule: add an example
+
+Add a Before/After Canvas example when all of these are true:
+
+- The trigger fits on one small board.
+- One static Before state makes the reason recognizable.
+- The complete conclusion is understandable in one After state.
+- The example does not need branch history, hidden candidates, or several
+  sequential deductions.
+
+Example requirements:
+
+- Use the smallest board that leaves comfortable visual padding.
+- Center the relevant pattern when practical.
+- Put prerequisite decisions in `before`.
+- Put only this rule's new decisions in `after`.
+- Do not highlight clue cells or add colored cell backgrounds.
+- Do not use inference overlays or dashed conclusion marks.
+- In the After view, highlight only newly decided edges or lines through the
+  standard board decision rendering. New lines remain solid; new crosses remain
+  visually distinct.
+- The caption should state the deduction, not repeat the full proof.
+
+#### B. Separable deterministic rule: add multiple Canvas cases
+
+A somewhat complex rule should still receive Canvas documentation when its
+important triggers or conclusions can be divided into independent,
+direct Before/After cases. Do not defer merely because one board cannot express
+the whole rule clearly.
+
+Use one case per distinct point that a reader needs to compare, such as:
+
+- Two equally important completion branches.
+- Distinct deterministic trigger shapes with the same underlying rule.
+- Different direct conclusion types that would be confusing on one board.
+
+Case-selection rules:
+
+- Prefer an even number of cases, normally `2` or `4`, because the desktop
+  layout uses two columns.
+- Do not invent a redundant or weak case solely to make the count even. A clear
+  three-case group is better than four cases with filler.
+- Normally stop at four representative cases. More than four is a strong signal
+  that the rule should be deferred or redesigned with author input.
+- Give every case a stable, descriptive `id`.
+- Give every case in a multi-case group a short, parallel title.
+- Use similarly sized puzzles where practical. Prefer matching dimensions; small
+  differences are acceptable when the Canvas cards still feel balanced.
+- Avoid grouping boards when the largest is roughly more than twice the width
+  or height of the smallest.
+- Keep every case independent. A reader must not need to understand one case as
+  an intermediate step or hidden prerequisite of another.
+
+Each case must still satisfy all visual and diff requirements from category A.
+
+#### C. Strong-inference rule: never add a Canvas example
+
+Do not create a Before/After Canvas example for strong inference, assumption
+inference, contradiction probing, or branch-comparison rules. A static pair
+hides the reasoning chain and can misrepresent why the conclusion is valid.
+
+This restriction overrides every other Canvas guideline. Even if a
+strong-inference rule appears easy to illustrate or can be divided into several
+small boards, leave its Canvas example empty. Document the rule in MDX and
+report:
+
+```text
+Canvas example deferred: this is a strong-inference rule whose explanation
+requires branch or contradiction history.
+```
+
+#### D. Complex rule: defer when unclear
+
+Defer the Canvas example when cases require intermediate history, branch
+reasoning, hidden candidate state, more than four representative cases, or
+cannot be understood as independent Before/After states. Also defer when the
+cases are too coupled, the necessary split is unclear, or implementing the
+group confidently would be disproportionately difficult.
+
+Do not invent an oversimplified example. Leave the rule's example registration
+empty and make the missing Canvas obvious:
+
+- Add a concise `TODO(rule-doc-canvas)` comment beside the relevant location in
+  `src/features/docs/ruleExamples.ts`. Include the puzzle ID, rule ID, and exact
+  blocker so a future author can find and resume the work.
+- Always state the deferral and exact blocker in the delivery report under
+  `Needs author input`.
+
+Use this wording:
+
+```text
+Canvas example deferred: <rule name> needs <number or description of cases>,
+but <coupling, hidden state, sequence, or case-count blocker>. Author input is
+needed before the Canvas group can be added.
+```
+
+#### E. Understand the Current Multi-Canvas Implementation
+
+All examples use one unified data shape in
+`src/features/docs/ruleExamples.ts`:
+
+```ts
+export type RuleExampleCaseData = {
+  id: string
+  title?: string
+  puzzle: PuzzleIR
+  before?: RuleDiff[]
+  after: RuleDiff[]
+  explanation: string
+}
+
+export type RuleExampleData = {
+  cases: [RuleExampleCaseData, ...RuleExampleCaseData[]]
+}
+```
+
+The `cases` tuple must contain at least one case. Existing single-Canvas
+examples are simply one-case groups; do not introduce a separate single-case
+shape or compatibility layer.
+
+A typical multi-case registration looks like:
+
+```ts
+{
+  cases: [
+    {
+      id: 'first-direct-branch',
+      title: 'First direct branch',
+      puzzle: firstPuzzle,
+      before: firstPrerequisiteDiffs,
+      after: firstConclusionDiffs,
+      explanation: '...',
+    },
+    {
+      id: 'second-direct-branch',
+      title: 'Second direct branch',
+      puzzle: secondPuzzle,
+      before: secondPrerequisiteDiffs,
+      after: secondConclusionDiffs,
+      explanation: '...',
+    },
+  ],
+}
+```
+
+`RuleExample` owns the complete example group's shared interaction:
+
+- One shared `view` switches every case between Before and After.
+- One shared playback timer moves every case from Before to After.
+- One shared `Before / After / Play deduction` toolbar is rendered for the
+  complete group.
+- Manual Before or After selection cancels active playback.
+
+The internal `RuleExampleCase` component owns one `<figure>`:
+
+- It applies that case's `before` diffs to its base puzzle.
+- It applies that case's `after` diffs on top of the Before state.
+- It highlights only that case's newly decided edges or lines in After.
+- It renders the optional title, one `CanvasBoard`, and one caption.
+- It derives a unique accessible Canvas label from the case title or ID.
+
+Layout behavior is already provided by `src/app/workspace.css`:
+
+- One case spans the full example width.
+- Two and four cases use a maximum of two columns on desktop.
+- An odd final case spans the next row and is centered.
+- At or below `820px`, every case becomes one full-width vertical item.
+- Case cards in one row stretch to equal height.
+- Each board is centered inside its card without resizing the Canvas.
+- Large boards scroll inside their own shells instead of widening the page.
+
+Do not change `CanvasBoard` rendering behavior to author an example. Build each
+case from a small `PuzzleIR`, prerequisite `before` diffs, and conclusion
+`after` diffs.
+
+### 5. Register the Documentation
+
+For a completed rule:
+
+1. Add the MDX file under `docs/content/<puzzle>/rules/`.
+2. Import it in `src/features/docs/ruleDocRegistry.tsx`.
+3. Add a concise one-sentence summary describing the rule's practical result.
+4. Add `RuleExampleData` only when the Canvas decision is category A or B.
+5. For a deferred category C or D Canvas, leave the example registration empty
+   and add the required reminder and delivery-report note.
+6. Keep the existing rule ID as the registry key and documentation deep-link
+   identifier.
+
+## Quality Review
+
+Before finishing, verify:
+
+- The MDX trigger matches the exact implementation conditions.
+- Every diff type the rule can produce is described.
+- The proof explains necessity, not merely observed behavior.
+- The display name and solver message use the same terminology as the MDX.
+- The document has exactly `What it does`, `When it triggers`, and
+  `Why it works`.
+- A Canvas example, if present, shows real board state rather than decorative
+  overlays.
+- Multi-case examples use independent cases with stable IDs, short titles,
+  similarly sized boards, and preferably an even case count.
+- All cases share exactly one Before, one After, and one Play deduction control.
+- Every case Canvas has a unique accessible label.
+- Strong-inference rules have no Canvas example, without exception.
+- Strong-inference and deferred examples are explicitly reported to the author.
+- No solver logic, rule order, rule ID, or factory name changed unintentionally.
+
+Run focused existing tests, formatting, lint, and build. When adding a
+multi-case example, verify the shared controls and inspect desktop and narrow
+layouts in the browser. Do not add tests solely for prose. Update existing
+assertions only when an approved display name or solver message changes.
+
+## Delivery Report
+
+End the task with a compact report:
+
+```text
+Documented:
+- <rule display name> (`<rule-id>`)
+
+Naming:
+- <kept or changed display name and why>
+- Rule ID and factory function preserved.
+
+Canvas:
+- Added: <case count and what each Before and After shows>
+or
+- Deferred: <strong-inference or complexity reason>
+
+Verification:
+- <commands and results>
+
+Needs author input:
+- <only unresolved Canvas or terminology decisions; omit when none>
+```
+
diff --git a/docs/content/masyu/rules/black-pearl-rule.mdx b/docs/content/masyu/rules/black-pearl-rule.mdx
index 964c3df..f1481dd 100644
--- a/docs/content/masyu/rules/black-pearl-rule.mdx
+++ b/docs/content/masyu/rules/black-pearl-rule.mdx
@@ -1,25 +1,17 @@
-## What this technique does
+## What it does
 
 A black pearl must be a turn in the loop. Each of the two exits from the pearl
-must continue straight through the next cell.
+must continue straight through the next cell. This can force the required
+straight extensions, cross out an opposite exit, or complete the only remaining
+turn around the pearl.
 
-## Trigger conditions
+## When it triggers
 
 The technique acts when an exit is known, a direction is blocked, or only one
 valid turning pair remains.
 
-## Conclusions
-
-It can force the required straight extensions, cross out an opposite exit, or
-complete the only remaining turn around the pearl.
-
 ## Why it works
 
 Using opposite exits would pass straight through the black pearl. Turning away
 immediately in a neighboring cell would violate the required straight
 continuation.
-
-## Limits and related techniques
-
-This technique checks direct pearl geometry. Black Pearl Candidate Pruning
-combines that geometry with broader local feasibility checks.
diff --git a/docs/content/masyu/rules/white-pearl-rule.mdx b/docs/content/masyu/rules/white-pearl-rule.mdx
index 8d3745e..05993f3 100644
--- a/docs/content/masyu/rules/white-pearl-rule.mdx
+++ b/docs/content/masyu/rules/white-pearl-rule.mdx
@@ -1,25 +1,17 @@
-## What this technique does
+## What it does
 
 A white pearl must be crossed by a straight section of the loop. The loop must
 also turn in at least one of the cells immediately before or after the pearl.
+This can force the opposite line through the pearl, cross out perpendicular
+exits, or reject a straight continuation that would make the required nearby
+turn impossible.
 
-## Trigger conditions
+## When it triggers
 
 The technique acts when a known line, blocked direction, or impossible adjacent
 turn leaves only one valid straight axis through the pearl.
 
-## Conclusions
-
-It can force the opposite line through the pearl, cross out perpendicular exits,
-or reject a straight continuation that would make the required nearby turn
-impossible.
-
 ## Why it works
 
 Any alternative would either turn on the white pearl or continue straight on
 both adjacent cells. Both outcomes violate the puzzle's white-pearl rule.
-
-## Limits and related techniques
-
-This is local deterministic reasoning. Candidate pruning and strong inference
-can resolve cases where more than one locally valid axis remains.
diff --git a/docs/content/slitherlink/rules/adjacent-threes.mdx b/docs/content/slitherlink/rules/adjacent-threes.mdx
new file mode 100644
index 0000000..b54ab6d
--- /dev/null
+++ b/docs/content/slitherlink/rules/adjacent-threes.mdx
@@ -0,0 +1,21 @@
+## What it does
+
+Two or more horizontally or vertically adjacent `3` clues force a repeating
+line pattern along the run. Every edge perpendicular to the run is a line,
+including the shared edges between neighboring `3` clues. Each shared edge is
+crossed out where it would continue straight beyond either side of the run.
+
+## When it triggers
+
+The technique acts whenever at least two `3` clues form one uninterrupted
+horizontal or vertical run. It does not require any edges to be decided first.
+
+## Why it works
+
+For a pair of adjacent `3` clues, leaving their shared edge unused would force
+the other six surrounding edges to form a closed loop around only those two
+cells, preventing any required loop elsewhere from joining it. In a standard
+Slitherlink puzzle, the shared edge must therefore be a line. Each clue then
+needs both of its edges perpendicular to the run. At either end of a shared
+edge, the loop already has two incident lines, so it cannot continue straight
+beyond the run.
diff --git a/docs/content/slitherlink/rules/adjacent-two-three-opposite-cross.mdx b/docs/content/slitherlink/rules/adjacent-two-three-opposite-cross.mdx
new file mode 100644
index 0000000..d66bdd9
--- /dev/null
+++ b/docs/content/slitherlink/rules/adjacent-two-three-opposite-cross.mdx
@@ -0,0 +1,24 @@
+## What it does
+
+When a `2` and a `3` are horizontally or vertically adjacent, and the edge on
+the `2` opposite their shared side is already crossed out, the edge on the `3`
+opposite their shared side is forced to be a line. The edges that continue
+straight along their shared side beyond the pair are crossed out. At a board
+edge, only the in-bounds extension is crossed out.
+
+## When it triggers
+
+The technique acts on a horizontally or vertically adjacent pair of numbered
+clues with values `2` and `3`, in either order. The edge on the `2` that lies
+on the side away from the `3` must already be crossed out. Unknown edges do not
+satisfy this prerequisite.
+
+## Why it works
+
+With its far-side edge crossed out, the `2` must take both of its lines from
+its shared edge with the `3` and from one of the two edges perpendicular to
+that shared side. That fixes how the loop passes through the pair, so the
+`3` must use its own far-side edge to reach three lines. If the loop also
+continued straight along the shared side beyond the pair, a vertex on that
+side would receive too many incident lines or the `3` could not reach its
+required count, so those extension edges must be crossed out.
diff --git a/docs/content/slitherlink/rules/cell-clue-completion.mdx b/docs/content/slitherlink/rules/cell-clue-completion.mdx
new file mode 100644
index 0000000..bad5fe3
--- /dev/null
+++ b/docs/content/slitherlink/rules/cell-clue-completion.mdx
@@ -0,0 +1,22 @@
+## What it does
+
+When a numbered clue already has enough lines among its four surrounding
+edges, every remaining unknown edge is crossed out. When every remaining
+unknown edge is needed to reach the clue count, all of them are marked as
+lines.
+
+## When it triggers
+
+The technique acts on a numbered cell that still has at least one unknown
+surrounding edge. Either the number of existing lines already equals the clue,
+or the number of existing lines plus the number of unknown edges equals the
+clue. No other prior decisions are required beyond the partial edge state
+around that cell.
+
+## Why it works
+
+A numbered cell must have exactly that many surrounding lines. If the clue is
+already satisfied, any additional line would exceed it, so every remaining
+unknown edge must be crossed out. If only as many unknown edges remain as are
+still needed, crossing out any one of them would leave the clue unsatisfied,
+so all of them must be lines.
diff --git a/docs/content/slitherlink/rules/clue-vertex-candidate-combination-pruning.mdx b/docs/content/slitherlink/rules/clue-vertex-candidate-combination-pruning.mdx
new file mode 100644
index 0000000..70950e4
--- /dev/null
+++ b/docs/content/slitherlink/rules/clue-vertex-candidate-combination-pruning.mdx
@@ -0,0 +1,62 @@
+## What it does
+
+This is an **internal solver rule**. It is correct and useful for a program, but
+humans seldom solve Slitherlink by explicitly listing every four-corner vertex
+assignment around a clue.
+
+For each numbered cell, the rule tries every **combination** of one vertex
+candidate per corner and keeps only combinations that could still be correct
+together. From the survivors it may:
+
+- **Narrow vertex candidates** at one or more corners (invisible on the board).
+- **Narrow sector masks** at one or more corner sectors (sometimes visible as
+  new sector marks).
+
+It does not mark edges directly.
+
+A human looking at the same deduction might say "clue 3 means this corner sector
+cannot be empty" after a short local argument. The solver reaches similar sector
+tightening by brute-force compatibility: enumerate four-corner states, filter by
+clue count, shared-edge agreement, and existing sector masks, then project what
+still survives. That is **computer-friendly** — uniform, exhaustive, and easy to
+compose with vertex-candidate pruning and trial search — but not a natural pen-and-
+paper workflow.
+
+## When it triggers
+
+The rule inspects every cell with a numeric clue (not `?`). It acts when at least
+one four-corner combination survives all filters below. That can happen on a
+fresh board with only the clue present: clue `0`, `1`, `2`, or `3` alone already
+eliminates impossible corner patterns.
+
+It also fires after earlier deductions have narrowed vertex candidates or sector
+masks, when some former combinations no longer satisfy the clue or a neighbor
+cell.
+
+Each combination must pass:
+
+- **Clue count:** the four cell edges contain exactly the clue number of lines.
+- **Shared-edge agreement:** each cell edge is used the same way by both corners
+  that touch it.
+- **Sector masks:** each corner sector's line count is still allowed.
+- **Early pruning:** partial assignments that already exceed the clue, or cannot
+  still reach it, are discarded before all four corners are chosen.
+
+## Why it works
+
+The four corners of one cell are not independent. Two corners sharing an edge
+must agree whether that edge is a line; the clue fixes the total number of lines
+on the four cell edges; sector masks add prior corner-sector restrictions.
+
+If a four-corner assignment breaks any of those checks, no valid solution can
+include it. Removing unsupported vertex candidates and tightening sector masks to
+counts that still appear in surviving combinations preserves every solution
+consistent with the current board.
+
+The proof is local and elementary; what is **not** human-typical is the method.
+Players tend to use **Sector Inference**, clue arithmetic, and vertex flow in
+separate steps they can narrate. This rule fuses those constraints into one
+compatibility sweep — better for a deterministic engine than for teaching a
+memorable player technique. Treat the trace as solver plumbing; compare visible
+sector changes with the documented sector rules when you want a human-readable
+story.
diff --git a/docs/content/slitherlink/rules/color-assumption-inference.mdx b/docs/content/slitherlink/rules/color-assumption-inference.mdx
new file mode 100644
index 0000000..9a2ad72
--- /dev/null
+++ b/docs/content/slitherlink/rules/color-assumption-inference.mdx
@@ -0,0 +1,44 @@
+## What it does
+
+Colors an unknown cell inside or outside when assuming the opposite color on that
+cell leads to a contradiction after deterministic propagation.
+
+The visible conclusion is a cell color change (green or yellow). When this rule
+fires in the solver, its step in **Reasoning Steps** includes a **View details**
+link. Click it to open the **Branch Inspector** and replay the green and yellow
+trial branches from the base puzzle through each deterministic step to the
+contradiction.
+
+![Branch Inspector replay for a color assumption step](https://cdn.jsdelivr.net/gh/SmilingWayne/picsrepo/20260616172416583.png)
+
+## When it triggers
+
+The rule runs only after every deterministic Slitherlink rule has been applied
+to a fixpoint. It then searches color-assumption candidates among cells that are
+still uncolored but touch at least one already colored neighbor.
+
+Candidates are grouped into parity components: cells linked by decided edges must
+take opposite colors across a line and the same color across a cross. One
+representative cell per component is tested, preferring cells with more decided
+edges, tighter sector constraints, and more colored neighbors.
+
+For each representative, the solver temporarily colors it green on one branch and
+yellow on the other, then runs the full deterministic rule list on each branch
+within a rising probe budget (24, 96, 384, then the maximum trial-step cap).
+The rule acts when exactly one branch reaches a hard contradiction and the
+other does not within the current budget. If both branches contradict, both
+remain feasible, or the time or step budget is exhausted, the rule makes no
+change.
+
+## Why it works
+
+Inside/outside coloring must stay consistent with every decided edge and with
+the single-loop geometry. If assuming one color on a cell forces a hard
+contradiction — such as a vertex-degree violation, clue mismatch, sector-mask
+conflict, premature loop, disconnected inside region, or a direct color-edge
+clash — that color cannot be correct. The surviving assumption is therefore
+forced on the real board.
+
+Because parity components already fix opposite colors across decided edges, one
+successful test on a component representative decides the color for every cell
+in that component.
diff --git a/docs/content/slitherlink/rules/color-clue-propagation.mdx b/docs/content/slitherlink/rules/color-clue-propagation.mdx
new file mode 100644
index 0000000..7f04173
--- /dev/null
+++ b/docs/content/slitherlink/rules/color-clue-propagation.mdx
@@ -0,0 +1,66 @@
+## What it does
+
+Inside/outside coloring labels each cell as inside or outside the loop. A
+numbered clue counts how many of its four side edges are lines. This rule uses
+those two views together: it may color the clue cell itself, or color unknown
+orthogonal neighbors once enough neighboring inside/outside cells are already
+known.
+
+Directions off the board count as outside neighbors. One application may update
+several cells when multiple numbered clues qualify at once.
+
+## When it triggers
+
+At least one numbered clue cell must participate, and at least one unknown cell
+color must follow from one of these patterns:
+
+**Contradiction on the clue cell**
+
+- The clue is smaller than the current inside-neighbor count, or larger than
+  `4 − outside-neighbor count`. The clue cell is colored inside.
+- The clue is smaller than the outside-neighbor count, or larger than
+  `4 − inside-neighbor count`. The clue cell is colored outside.
+
+**Clue 2 with two known outside neighbors**
+
+- Exactly two orthogonal neighbors are already outside. Every remaining unknown
+  neighbor is colored inside.
+
+**Clue 2 with two known inside neighbors**
+
+- Exactly two orthogonal neighbors are already inside. Every remaining unknown
+  neighbor is colored outside.
+
+**Clue cell already colored**
+
+- The clue cell is inside and already has as many outside neighbors as the clue
+  value. Every remaining unknown neighbor is inside.
+- The clue cell is outside and already has as many inside neighbors as the clue
+  value. Every remaining unknown neighbor is outside.
+- The clue cell is outside and the outside-neighbor count fixes how many more
+  inside neighbors are still required. Every remaining unknown neighbor is
+  inside.
+- The clue cell is inside and the inside-neighbor count fixes how many more
+  outside neighbors are still required. Every remaining unknown neighbor is
+  outside.
+
+Prior edge decisions are not required, but any already-colored neighbors are
+used in the counts. The rule does not overwrite an existing cell color.
+
+## Why it works
+
+A clue counts line edges around its cell. In a valid coloring, an outside
+neighbor sits across a crossed-out edge from the clue side that contributes no
+line, while an inside neighbor sits across a line edge. So the clue value limits
+how many neighbors can be outside versus inside.
+
+If the known neighbor counts already make the clue impossible for one side, the
+clue cell must be on the other side. For clue 2, two outside neighbors already
+use both non-line sides, so every remaining side must be a line and its neighbor
+inside — and the symmetric argument applies when two inside neighbors are known.
+When the clue cell’s own color is fixed, the same bookkeeping forces every
+still-unknown neighbor once the matching count is already saturated or the
+remaining requirement is fixed.
+
+Any other assignment would make the clue disagree with the loop’s
+inside/outside partition.
diff --git a/docs/content/slitherlink/rules/color-connectivity-cut-coloring.mdx b/docs/content/slitherlink/rules/color-connectivity-cut-coloring.mdx
new file mode 100644
index 0000000..654bd1e
--- /dev/null
+++ b/docs/content/slitherlink/rules/color-connectivity-cut-coloring.mdx
@@ -0,0 +1,56 @@
+## What it does
+
+Inside/outside coloring must stay connected: all inside cells belong to one
+inside region, and all outside cells connect to the exterior. This rule reasons
+about those connectivity requirements on the cell adjacency graph and may color
+unknown cells in four situations:
+
+- **Inside cut:** an unknown cell or narrow cell group is the only link between
+  two separated inside sources, so it must be inside.
+- **Outside cut:** an unknown bottleneck is the only link between the exterior
+  (or separated outside sources), so it must be outside.
+- **Unreachable from inside:** a cell group cannot connect to any inside source
+  without crossing a line edge, so every unknown cell in it is outside.
+- **Unreachable from outside:** a cell group cannot connect to the exterior or
+  any outside source without crossing a line edge, so every unknown cell in it
+  is inside.
+
+Crossed-out edges merge adjacent cells into the same color candidate group.
+Unknown edges still connect groups for reachability analysis but do not force
+same-color merging. Line edges are walls: they do not connect groups. Cells
+already colored the opposite role are excluded from each pass.
+
+One application runs an inside-targeted pass and an outside-targeted pass, and
+may combine several update types in a single step.
+
+## When it triggers
+
+At least one of these must be available:
+
+- Two or more separated inside sources that would disconnect unless an unknown
+  bottleneck is inside.
+- The exterior plus at least one outside source that would disconnect unless an
+  unknown bottleneck is outside.
+- Unknown cells in a component separated from all inside sources by line edges.
+- Unknown cells in a component separated from the exterior and all outside
+  sources by line edges.
+
+The rule only fills still-unknown cells. Clue **3** cells may be colored when
+they act as connectivity bottlenecks, but existing inside/outside colors are
+never overwritten.
+
+No numbered clue is required beyond the **3**-clue handling above.
+
+## Why it works
+
+Valid solutions induce a two-coloring where inside and outside are each
+connected regions (outside includes the off-board exterior). Consider only cells
+that could still take a given color, linked by adjacency across non-line edges.
+If two confirmed regions of that color would lie in different components unless
+some still-unknown cells take that color, those cells are articulation points:
+every completion must keep the color connected through them.
+
+Crossed-out edges already force same-color parity, so blank-compressed groups
+must decide together. Line edges are separators, so a component walled off from
+every inside source cannot be inside, and a component walled off from the
+exterior cannot be outside.
diff --git a/docs/content/slitherlink/rules/color-edge-propagation.mdx b/docs/content/slitherlink/rules/color-edge-propagation.mdx
new file mode 100644
index 0000000..271bd13
--- /dev/null
+++ b/docs/content/slitherlink/rules/color-edge-propagation.mdx
@@ -0,0 +1,48 @@
+## What it does
+
+Inside/outside coloring treats every cell as either inside the loop or
+outside it. This rule keeps that coloring aligned with edge decisions. It may
+mark a shared edge as a line or as crossed out, decide boundary edges from a
+colored border cell, or color an unknown neighbor once one side of an edge is
+already known.
+
+Concretely, it can:
+
+- Mark a boundary edge as a line when the adjacent cell is inside, or crossed
+  out when that cell is outside.
+- Cross out an interior edge when both adjacent cells have the same color, or
+  mark it as a line when their colors differ.
+- Color the unknown side of an edge as inside or outside when the edge and the
+  other adjacent cell are already decided.
+
+## When it triggers
+
+At least one unknown edge or unknown cell color must be reachable through these
+patterns. No numbered clue is required.
+
+**Color to edge**
+
+- A boundary cell is colored inside or outside, and its outer boundary edge is
+  still unknown.
+- Two orthogonally adjacent cells are both colored, and the edge between them
+  is still unknown.
+
+**Edge to color**
+
+- An edge is already a line or crossed out, exactly one adjacent cell is
+  colored, and the other adjacent cell is still unknown.
+
+The rule may apply several independent updates in one step when multiple edges
+or cells satisfy these conditions at once.
+
+## Why it works
+
+Inside and outside are two regions separated by the loop. A line edge sits on
+the border between them, so cells on opposite sides of a line must have
+opposite colors. A crossed-out edge does not separate the regions, so cells on
+both sides must share the same color.
+
+A boundary edge has only one adjacent cell on the board. That outer side is
+outside the puzzle, so an inside cell must meet the boundary with a line and an
+outside cell must meet it with a crossed-out edge. Any update that violates
+these relations would disagree with the loop's inside/outside partition.
diff --git a/docs/content/slitherlink/rules/color-orthogonal-consensus-propagation.mdx b/docs/content/slitherlink/rules/color-orthogonal-consensus-propagation.mdx
new file mode 100644
index 0000000..2b7c8de
--- /dev/null
+++ b/docs/content/slitherlink/rules/color-orthogonal-consensus-propagation.mdx
@@ -0,0 +1,40 @@
+## What it does
+
+Inside/outside coloring labels each cell as inside or outside the loop. When
+every orthogonal neighbor of an unknown cell already shares one color, this rule
+colors that cell to match them. Directions off the board count as outside
+neighbors.
+
+One application may color several cells when multiple unknown cells qualify at
+once, including cases where an earlier inference in the same step unlocks the
+next one.
+
+## When it triggers
+
+At least one unknown cell must have a full orthogonal neighborhood where every
+neighbor is already decided:
+
+- For an interior cell, all four in-bounds orthogonal neighbors must already be
+  colored inside or outside.
+- For a boundary cell, every in-bounds orthogonal neighbor must be decided, and
+  each missing board direction counts as outside.
+
+All decided neighbors in that neighborhood must share the same color. If any
+in-bounds neighbor is still unknown, or the neighbors disagree, the cell is
+skipped. The rule does not overwrite an existing cell color.
+
+No numbered clue or edge decision is required.
+
+## Why it works
+
+Inside and outside are the two regions separated by the loop. Orthogonally
+adjacent cells can share a color only when the edge between them is crossed
+out, not when it is a line.
+
+If every orthogonal neighbor of an unknown cell is inside, drawing that cell as
+outside would require a line on each shared side to separate the regions. Four
+such lines would already enclose the cell, so it would be inside the loop after
+all. The symmetric argument applies when every neighbor is outside.
+
+At the puzzle boundary, the off-board side is outside, so a corner or edge cell
+surrounded only by outside neighbors must also be outside.
diff --git a/docs/content/slitherlink/rules/color-outside-seeding.mdx b/docs/content/slitherlink/rules/color-outside-seeding.mdx
new file mode 100644
index 0000000..338de1e
--- /dev/null
+++ b/docs/content/slitherlink/rules/color-outside-seeding.mdx
@@ -0,0 +1,46 @@
+## What it does
+
+Inside/outside coloring must stay consistent across the whole grid. This rule
+colors unknown cells that belong to the same parity component as an already
+anchored region.
+
+A parity component is a connected group of cells linked by decided edges:
+cells separated by a crossed-out edge must share a color, and cells separated
+by a line must have opposite colors. Once any cell in that component is fixed
+as inside or outside — either directly or through a boundary edge — every other
+still-unknown cell in the same consistent component receives the matching
+color.
+
+## When it triggers
+
+At least one unknown cell must belong to a parity component that already has a
+valid anchor. An anchor can come from:
+
+- A cell that is already colored inside or outside.
+- A decided boundary edge: a crossed-out boundary edge fixes the adjacent cell
+  as outside, and a line on the boundary fixes it as inside.
+
+The rule also needs a consistent color assignment for that component. It does
+not act when:
+
+- No anchor exists for the component.
+- Different anchors in the same component demand conflicting colors.
+
+No numbered clue is required. One application may color every qualifying
+unknown cell in every anchored component on the board.
+
+## Why it works
+
+Valid Slitherlink solutions induce a two-coloring of the cells: inside the loop
+versus outside it. Crossed-out edges connect cells in the same region; line
+edges connect cells in opposite regions. Those relations define parity within
+each connected component.
+
+If at least one cell in a component is fixed, parity determines the color of
+every other cell in that component. Boundary edges are anchors because the
+exterior is outside: a crossed-out outer edge touches an outside cell, and a
+line on the outer border separates the exterior from an inside cell.
+
+When anchors agree, each unknown cell in the component has only one color
+compatible with the loop partition. Conflicting anchors signal an impossible
+state, so the rule leaves that component unchanged.
diff --git a/docs/content/slitherlink/rules/color-sector-mask-propagation.mdx b/docs/content/slitherlink/rules/color-sector-mask-propagation.mdx
new file mode 100644
index 0000000..a0a9ecf
--- /dev/null
+++ b/docs/content/slitherlink/rules/color-sector-mask-propagation.mdx
@@ -0,0 +1,57 @@
+## What it does
+
+Each cell corner has a corner sector with two edges. The two cells that sit
+just outside that corner — one above or below and one left or right — are the
+sector’s outside neighbors. This rule keeps sector line-count constraints and
+those neighbors’ inside/outside colors aligned.
+
+It may:
+
+- Color an unknown outside neighbor once the sector already requires its two
+  neighbors to match or to differ, and the other neighbor’s color is known.
+- Narrow a sector’s allowed line count when both outside neighbors are already
+  colored: matching colors forbid exactly one sector line, and opposite colors
+  require exactly one.
+
+Off-board outside-neighbor directions count as outside. Sector masks that already
+forbid a count of one line — including masks that fix zero or two lines — are
+treated like a “not exactly one” constraint for the color link. One
+application may update several cells and sectors independently.
+
+## When it triggers
+
+At least one corner sector must satisfy one of these patterns:
+
+**Sector mask to color**
+
+- The sector is narrowed to exactly one line, or it forbids exactly one line
+  (including masks that already fix zero or two lines).
+- Exactly one in-bounds outside neighbor is still unknown; the other neighbor
+  is known, or is off-board and treated as outside.
+- The unknown neighbor receives the color forced by the sector relation.
+
+**Color to sector mask**
+
+- Both outside neighbors have known colors, or one is off-board and treated as
+  outside.
+- The sector is not already narrowed to only one line or to forbid one line.
+- Matching neighbor colors narrow the sector so it cannot have exactly one
+  line; opposite colors narrow it to exactly one line.
+
+The rule does not act when both outside neighbors are unknown and in bounds, when
+both are already colored and the sector is already in one of the narrowed
+states, or when a proposed mask intersection would be empty. It does not
+overwrite an existing cell color.
+
+## Why it works
+
+A corner sector has only two edges, so its line count is 0, 1, or 2. The two
+outside neighbors lie on opposite sides of those edges. If they have opposite
+inside/outside colors, the loop border runs between them and exactly one sector
+edge must be a line — so the sector count is 1. If they share a color, both
+sector edges must be lines or both must be crosses, so the sector cannot end
+with exactly one line.
+
+Once a sector is narrowed to one of those relations, a single unknown neighbor
+has only one compatible color. Conversely, once both neighbor colors are fixed,
+only one sector mask remains compatible with the corner geometry.
diff --git a/docs/content/slitherlink/rules/diagonal-threes.mdx b/docs/content/slitherlink/rules/diagonal-threes.mdx
new file mode 100644
index 0000000..f667fac
--- /dev/null
+++ b/docs/content/slitherlink/rules/diagonal-threes.mdx
@@ -0,0 +1,18 @@
+## What it does
+
+Two diagonally adjacent `3` clues force the two edges at each clue's outer
+corner. The result is four lines: two meeting at the corner of each `3` that
+faces away from their shared vertex.
+
+## When it triggers
+
+The technique acts whenever two `3` clues occupy opposite cells of the same
+`2 x 2` block. It does not require any edges to be decided first.
+
+## Why it works
+
+A `3` has exactly one unused edge. If either outer-corner edge of one clue were
+unused, its other three edges would be lines. At the vertex shared by the two
+clues, that forces the diagonal clue to leave too many of its surrounding edges
+unused to reach three lines. Therefore neither clue can use an outer-corner
+edge as its single unused edge.
diff --git a/docs/content/slitherlink/rules/inside-reachability-coloring.mdx b/docs/content/slitherlink/rules/inside-reachability-coloring.mdx
new file mode 100644
index 0000000..e07e71e
--- /dev/null
+++ b/docs/content/slitherlink/rules/inside-reachability-coloring.mdx
@@ -0,0 +1,40 @@
+## What it does
+
+Inside/outside coloring labels each cell as inside or outside the loop. This
+rule floods outward from every known inside cell through passages that are not
+line edges, then colors every still-unknown cell that the flood never reaches as
+outside.
+
+A passage is any shared edge that is still unknown or crossed out. Line edges
+block the flood. Existing outside cells and clue **3** cells also block the
+flood and are never recolored by this rule.
+
+One application may color many cells when several pockets are sealed off from
+all inside sources at once.
+
+## When it triggers
+
+At least one cell must already be colored inside. The rule does nothing when no
+inside anchor exists.
+
+From those anchors, it walks to orthogonally adjacent cells across non-line
+edges, skipping:
+
+- Cells already colored outside.
+- Clue **3** cells (whether or not they are colored yet).
+
+Every remaining unknown cell that never joins the flood is colored outside. The
+rule does not overwrite cells that already have a color.
+
+No numbered clue is required beyond the implicit **3**-clue barrier behavior.
+
+## Why it works
+
+The loop separates the grid into an inside region and an outside region. Cells
+in the same region can be reached from one another without crossing a line edge,
+because a line is the border between opposite colors.
+
+If a cell cannot be reached from any known inside cell without crossing a line,
+it cannot lie on an inside-connected path. Every valid completion keeps such a
+cell outside. Outside cells and **3** clues are hard barriers because they
+already fix the parity on their side of the loop.
diff --git a/docs/content/slitherlink/rules/outside-reachability-coloring.mdx b/docs/content/slitherlink/rules/outside-reachability-coloring.mdx
new file mode 100644
index 0000000..6dd6d34
--- /dev/null
+++ b/docs/content/slitherlink/rules/outside-reachability-coloring.mdx
@@ -0,0 +1,42 @@
+## What it does
+
+Inside/outside coloring labels each cell as inside or outside the loop. This
+rule floods inward from the exterior and from every known outside cell through
+passages that are not line edges, then colors every still-unknown cell the flood
+never reaches as inside.
+
+The exterior seeds any border cell whose outer edge is still unknown or crossed
+out. Existing outside cells are additional seeds. A passage is any shared edge
+that is still unknown or crossed out; line edges block the flood. Existing
+inside cells and clue **3** cells block the flood and are never recolored.
+
+One application may color many cells when several enclosed pockets remain
+unreachable from the exterior at once.
+
+## When it triggers
+
+At least one flood seed must exist:
+
+- A cell already colored outside, or
+- A border cell that can still reach off the board through a non-line boundary
+  edge.
+
+If every border cell is already walled off by lines on all outward edges and no
+outside-colored cell is present, the rule does nothing.
+
+From the seeds, it walks to orthogonally adjacent cells across non-line edges,
+skipping inside cells and clue **3** cells. Every remaining unknown cell that
+never joins the flood is colored inside. The rule does not overwrite cells that
+already have a color.
+
+## Why it works
+
+The puzzle exterior is outside the loop. From any outside-colored cell or any
+border opening, cells in the same outside region are reachable without crossing
+a line, because lines separate opposite colors.
+
+If an unknown cell cannot be reached from the exterior or from any known
+outside cell without crossing a line, it sits in a sealed pocket. In every valid
+completion that pocket is surrounded by loop edges, so its cells are inside.
+Inside cells and **3** clues are hard barriers for the same parity reasons as in
+the complementary inside flood.
diff --git a/docs/content/slitherlink/rules/prevent-premature-loop.mdx b/docs/content/slitherlink/rules/prevent-premature-loop.mdx
new file mode 100644
index 0000000..2e325e1
--- /dev/null
+++ b/docs/content/slitherlink/rules/prevent-premature-loop.mdx
@@ -0,0 +1,27 @@
+## What it does
+
+Slitherlink must end with one continuous loop. While the path is still growing,
+this rule crosses out any unknown edge that would close a smaller loop before
+the full answer is complete.
+
+One application may cross out several such edges when multiple premature
+closures are visible at once.
+
+## When it triggers
+
+At least one unknown edge must connect two vertices that are already linked by
+existing line edges through other paths. No numbered clue is required.
+
+The rule looks only at edges already marked as lines, builds the connected
+paths they form, and then checks each still-unknown edge. If that edge's two
+endpoints already belong to the same path component, it qualifies.
+
+## Why it works
+
+The final solution has exactly one loop. If an unknown edge joins two vertices
+that are already connected by confirmed lines, using it would complete a
+separate small loop while other confirmed line segments remain outside that
+loop.
+
+That would leave at least two disjoint loop pieces, which cannot be merged into
+one simple loop later. So the closing edge must be crossed out.
diff --git a/docs/content/slitherlink/rules/sector-clue-one-three-intra-cell-propagation.mdx b/docs/content/slitherlink/rules/sector-clue-one-three-intra-cell-propagation.mdx
new file mode 100644
index 0000000..9fbbe33
--- /dev/null
+++ b/docs/content/slitherlink/rules/sector-clue-one-three-intra-cell-propagation.mdx
@@ -0,0 +1,38 @@
+## What it does
+
+When a numbered cell's clue is **1** or **3** and one corner sector is already
+known to contain **exactly one line**, this rule decides the cell's two
+**opposite** edges — the edges that do not belong to that sector.
+
+- Clue **1**: both opposite edges are crossed out.
+- Clue **3**: both opposite edges are marked as lines.
+
+It does not change sector masks or vertex candidates.
+
+## When it triggers
+
+The rule inspects every cell with numeric clue **1** or **3**. For each corner
+sector of that cell whose constraint has already been narrowed to **exactly one
+line**, it looks at the two cell edges that are not part of that sector.
+
+It acts when at least one of those opposite edges is still unknown. The sector
+must already be at exactly-one-line from earlier sector reasoning; this rule
+does not infer new sector masks.
+
+If the sector is not exactly one line, or both opposite edges are already
+decided, the case is skipped.
+
+## Why it works
+
+A corner sector has two edges. If sector reasoning has fixed that sector to
+exactly one line, that line already accounts for part of the cell's clue count.
+
+For clue **1**, the cell needs only one line in total. The sector's one line
+already satisfies the clue, so the two remaining cell edges — the opposite pair
+— cannot also be lines.
+
+For clue **3**, the cell needs three lines. The sector contributes one, so the
+opposite pair must supply the other two. Both must be lines.
+
+Any other assignment would give the wrong total around the clue while still
+violating the fixed sector count.
diff --git a/docs/content/slitherlink/rules/sector-constraint-edge-propagation.mdx b/docs/content/slitherlink/rules/sector-constraint-edge-propagation.mdx
new file mode 100644
index 0000000..bb96489
--- /dev/null
+++ b/docs/content/slitherlink/rules/sector-constraint-edge-propagation.mdx
@@ -0,0 +1,45 @@
+## What it does
+
+Each numbered cell has four corner sectors. A corner sector is the pair of
+edges that meet at that cell corner. When a sector's line count has been
+narrowed by earlier sector reasoning, this rule completes the sector's two
+edges: it may mark every remaining unknown sector edge as a line or as crossed
+out, or force the last undecided sector edge when the other sector edge is
+already decided.
+
+## When it triggers
+
+The technique acts on a corner sector whose constraint has already been reduced
+to one exact count or to a forbidden count of one line. At least one of the
+sector's two edges must still be unknown. The rule applies when the partial
+edge state matches one of these cases:
+
+- The sector must contain exactly two lines. Every unknown sector edge is
+  marked as a line.
+- The sector must contain exactly zero lines. Every unknown sector edge is
+  crossed out.
+- The sector must contain exactly one line, one sector edge is already a line,
+  and the other is the only remaining unknown edge. That unknown edge is crossed
+  out.
+- The sector must contain exactly one line, one sector edge is already crossed
+  out, and the other is the only remaining unknown edge. That unknown edge is
+  marked as a line.
+- The sector cannot contain exactly one line, one sector edge is already a
+  line, and the other is the only remaining unknown edge. That unknown edge is
+  also marked as a line.
+- The sector cannot contain exactly one line, one sector edge is already crossed
+  out, and the other is the only remaining unknown edge. That unknown edge is
+  also crossed out.
+
+The sector constraint itself must come from earlier sector inference on the
+board. This rule does not infer new sector masks.
+
+## Why it works
+
+Each corner sector has only two edges, so its line count can only be 0, 1, or
+2. If sector reasoning has already fixed that count, any remaining unknown
+edges must complete it. For an exact count, once enough lines or crosses are
+already present, the last unknown edge is forced. For a forbidden count of
+one line, the two sector edges must be either both lines or both crosses; once
+one edge is decided, the other must match it so the sector does not end with
+exactly one line.
diff --git a/docs/content/slitherlink/rules/sector-diagonal-shared-vertex-propagation.mdx b/docs/content/slitherlink/rules/sector-diagonal-shared-vertex-propagation.mdx
new file mode 100644
index 0000000..13d3330
--- /dev/null
+++ b/docs/content/slitherlink/rules/sector-diagonal-shared-vertex-propagation.mdx
@@ -0,0 +1,40 @@
+## What it does
+
+Two corner sectors on diagonally adjacent cells can share the same grid vertex.
+When one of those sectors has already been narrowed to a strong line-count
+constraint, this rule copies a compatible constraint to the opposite diagonal
+sector at that vertex.
+
+The propagated relations are:
+
+- exactly one line on the source sector forces exactly one line on the target;
+- forbidding exactly one line on the source does the same on the target;
+- forbidding zero lines on the source forbids two lines on the target.
+
+Only sector masks change. This rule does not mark edges directly.
+
+## When it triggers
+
+The source sector must already be narrowed to exactly one of these masks:
+
+- exactly one line;
+- cannot have exactly one line;
+- cannot have zero lines.
+
+The diagonally opposite cell must be in bounds. The target sector must still
+allow a tighter mask after intersection. The rule does not act when the target is
+already equally constrained, or when the combined masks would contradict each
+other.
+
+No edge or clue decisions are required beyond the source sector mask itself.
+
+## Why it works
+
+At an interior vertex, the four incident edges split into two diagonal corner
+sectors. Each sector owns one pair of opposite edges around the vertex. Those
+two pairs partition the vertex completely: if one pair contains zero lines, both
+of its edges are crossed out, so the other pair must supply both lines to reach
+vertex degree two. That opposite pair then has two lines, not zero. The same
+vertex geometry makes an exact-one-line constraint and a not-exactly-one-line
+constraint pass unchanged across the diagonal pair, because both sectors are
+describing the same corner vertex from opposite sides.
diff --git a/docs/content/slitherlink/rules/sector-inference.mdx b/docs/content/slitherlink/rules/sector-inference.mdx
new file mode 100644
index 0000000..1e8138d
--- /dev/null
+++ b/docs/content/slitherlink/rules/sector-inference.mdx
@@ -0,0 +1,68 @@
+## What it does
+
+Each numbered cell has four corner sectors. A corner sector is the pair of edges
+that meet at that cell corner. This rule narrows how many of those two edges may
+be lines, without drawing or crossing them out directly.
+
+One application may update several sectors. The allowed counts it can enforce
+include:
+
+- exactly zero, one, or two sector lines;
+- forbidding exactly one sector line;
+- forbidding zero sector lines;
+- forbidding two sector lines.
+
+## When it triggers
+
+The rule inspects every corner sector. It acts when existing board evidence
+narrows the sector below its current mask. No prior sector mask is required;
+boundary geometry alone can start the deduction.
+
+Evidence comes from three local sources, combined for that sector:
+
+**Sector edges already decided**
+
+- If both sector edges are decided, the sector is narrowed to that exact line
+  count.
+
+**Vertex flow at the shared corner vertex**
+
+- A board corner with only the two sector edges incident: the sector cannot have
+  exactly one line.
+- Exactly one non-sector edge at the vertex is crossed out: the sector cannot
+  have exactly one line.
+- Exactly one non-sector edge is a line, and every remaining unknown edge at the
+  vertex lies in this sector: the sector must have exactly one line.
+- Two non-sector edges are lines: the sector must have zero lines.
+- Two non-sector edges are crossed out: the sector cannot have exactly one line.
+- One sector edge is crossed out: the sector cannot have two lines.
+
+**Numbered clue on the cell**
+
+- If the cell's decided edge lines already equal the clue, the sector is
+  narrowed to its own decided line count.
+- Clue 3 with both diagonal (non-sector) edges already lines: the sector must
+  have exactly one line.
+- Clue 2 with one diagonal line and one diagonal cross: the sector must have
+  exactly one line.
+- Clue 1 with both diagonal edges crossed out: the sector must have exactly one
+  line.
+- Clue 3, or one sector edge already a line: the sector cannot have zero lines.
+- Clue 1: the sector cannot have two lines.
+
+The rule only tightens masks. It never relaxes a sector that is already more
+specific, and it skips any intersection that would become empty.
+
+## Why it works
+
+A corner sector has only two edges, so its line count is 0, 1, or 2. Vertex
+degree limits how those two edges can combine with the other edges at the same
+corner vertex: a valid loop gives every used vertex degree two, so the sector
+edges and the non-sector edges at that vertex must agree on how many lines
+remain. Board corners and single-edge vertices rule out a lone sector line when
+the geometry cannot support it.
+
+Clue arithmetic applies the same idea at the cell level. Once enough edges
+around the clue are fixed — including the two sector edges and the two diagonal
+edges opposite them — only one sector line count stays compatible with the clue
+and with forbidden totals.
diff --git a/docs/content/slitherlink/rules/sector-not-one-clue-two-propagation.mdx b/docs/content/slitherlink/rules/sector-not-one-clue-two-propagation.mdx
new file mode 100644
index 0000000..d0f61f2
--- /dev/null
+++ b/docs/content/slitherlink/rules/sector-not-one-clue-two-propagation.mdx
@@ -0,0 +1,44 @@
+## What it does
+
+On a cell with clue **2**, when one corner sector cannot contain exactly one
+line and the **diagonally opposite** corner sector already has a line on at
+least one of its two edges, this rule crosses out every still-unknown edge in
+the first sector.
+
+It may blank both edges of the target corner sector in one application. It does
+not draw new lines and does not change sector masks.
+
+## When it triggers
+
+The rule inspects every cell with numeric clue **2**. For each of the four
+corner-sector pairs (northwest versus southeast, northeast versus southwest) it
+checks:
+
+1. The **target** corner sector's constraint forbids exactly one line (the mask
+   does not allow a count of 1).
+2. At least one edge of the **opposite** diagonal corner sector is already a
+   line.
+3. The target corner sector has no line yet on either of its two edges.
+4. At least one target-sector edge is still unknown.
+
+All four diagonal orientations are tried independently. If the target sector
+already has a line, the opposite sector has no line, the target sector still
+allows exactly one line, or every target edge is already decided, that
+orientation is skipped.
+
+## Why it works
+
+Clue **2** needs exactly two lines on the four cell edges. The two corner
+sectors on one diagonal each contribute their own pair of edges; the opposite
+edges of the cell form the other diagonal pair.
+
+If the opposite diagonal sector already uses a line, part of the clue count is
+committed away from the target sector's corner. If the target sector **cannot**
+have exactly one line, its only legal totals are zero or two lines. With the
+opposite diagonal already contributing a line toward the cell total, giving the
+target sector any line would push the cell over two lines or force the target
+sector into the forbidden count of one when combined with the remaining cell
+edges.
+
+So every surviving solution leaves both target-sector edges crossed out. Marking
+them blank is safe and may enable later sector or clue propagation.
diff --git a/docs/content/slitherlink/rules/sector-parity-inference.mdx b/docs/content/slitherlink/rules/sector-parity-inference.mdx
new file mode 100644
index 0000000..ba03b9c
--- /dev/null
+++ b/docs/content/slitherlink/rules/sector-parity-inference.mdx
@@ -0,0 +1,52 @@
+## What it does
+
+Decides the two edges of a corner sector that is forbidden from having exactly
+one line.
+
+Depending on the trial outcome, the rule may:
+
+- draw both sector edges or cross out both of them when one parity branch
+  contradicts the puzzle; or
+- fix any additional edges that both parity branches force to the same decision
+  downstream.
+
+When this rule fires in the solver, its step in **Reasoning Steps** includes a
+**View details** link. Click it to open the **Branch Inspector** and replay the
+line-parity and blank-parity trial branches through deterministic propagation.
+
+## When it triggers
+
+The rule runs only after every deterministic Slitherlink rule has been applied
+to a fixpoint. It inspects corner sectors whose mask already forbids exactly one
+line, with both sector edges still unknown.
+
+For each such sector, the solver tries two parity branches: both sector edges as
+lines, and both as crosses. Each branch is propagated with the full
+deterministic rule list within a rising probe budget (24, 96, 384, then the
+maximum trial-step cap).
+
+The rule acts in either of these cases:
+
+- **Opposite-branch conclusion:** one parity branch reaches a hard contradiction
+  and the other does not. The surviving branch's initial edge assignment is
+  applied to the real board.
+- **Shared-consequence conclusion:** neither branch contradicts within the budget,
+  but deterministic propagation fixes the same additional unknown edge on both
+  branches. Those shared edge decisions are applied to the real board.
+
+If both branches contradict, both remain feasible without a shared consequence,
+or the time or step budget is exhausted, the rule makes no change.
+
+## Why it works
+
+A sector with two edges can have zero, one, or two lines. When sector reasoning
+has already ruled out exactly one line, only two parity patterns remain: both
+lines or both crosses.
+
+If assuming one parity pattern leads to a hard contradiction — for example a
+vertex-degree violation, clue mismatch, sector-mask conflict, or premature
+loop — that pattern is impossible and the opposite parity is forced.
+
+If both patterns remain locally feasible but every deterministic continuation
+agrees on further edge decisions, those consequences do not depend on which
+parity was chosen and are safe to apply.
diff --git a/docs/content/slitherlink/rules/strong-inference.mdx b/docs/content/slitherlink/rules/strong-inference.mdx
new file mode 100644
index 0000000..9dd24fa
--- /dev/null
+++ b/docs/content/slitherlink/rules/strong-inference.mdx
@@ -0,0 +1,63 @@
+## What it does
+
+Makes edge decisions by probing bounded trial branches on high-value local
+candidates.
+
+Depending on the trial outcome, the rule may:
+
+- force one of two mutually exclusive edge assignments when one branch
+  contradicts the puzzle; or
+- fix any additional edges that both branches force to the same decision
+  downstream.
+
+Candidate shapes include:
+
+- a corner sector constrained to exactly one line, with both sector edges still
+  unknown;
+- a vertex that already has one line and exactly two unknown continuations; and
+- any remaining unknown edge not already covered by a sector-only-one pair.
+
+When this rule fires in the solver, its step in **Reasoning Steps** includes a
+**View details** link. Click it to open the **Branch Inspector** and replay
+Branch A and Branch B from the base puzzle through deterministic propagation.
+
+## When it triggers
+
+The rule runs only after every deterministic Slitherlink rule has been applied
+to a fixpoint, and after Color Assumption Inference and Sector Parity Inference
+have had their turn on the same state.
+
+Candidates are collected in priority order: vertex two-choice cases first, then
+sector-only-one cases, then standalone unknown edges. For a binary pair, Branch
+A assumes the first edge is a line and the second is a cross; Branch B assumes
+the opposite. For a standalone edge, Branch A assumes a line and Branch B
+assumes a cross.
+
+Each candidate is tested with the full deterministic rule list within a rising
+probe budget (24, 96, 384, then the maximum trial-step cap).
+
+The rule acts in either of these cases:
+
+- **Opposite-branch conclusion:** one branch reaches a hard contradiction and
+  the other does not. The surviving branch's initial edge assignment is applied
+  to the real board.
+- **Shared-consequence conclusion:** neither branch contradicts within the
+  budget, but deterministic propagation fixes the same additional unknown edge
+  on both branches. Those shared edge decisions are applied to the real board.
+
+If both branches contradict, both remain feasible without a shared consequence,
+or the time or step budget is exhausted, the rule makes no change.
+
+## Why it works
+
+Each trial branch temporarily commits to one local edge pattern and asks whether
+the rest of the puzzle can still satisfy Slitherlink's loop, clue, sector, and
+color constraints after full deterministic propagation.
+
+If one pattern reaches a hard contradiction, that pattern is impossible and the
+alternative assignment is forced. If both patterns remain feasible but every
+continuation agrees on further edge decisions, those consequences are
+independent of which branch was assumed and are safe to apply.
+
+The search is bounded by candidate count, trial steps, and elapsed time, so the
+solver only reports conclusions that are found within those limits.
diff --git a/docs/content/slitherlink/rules/vertex-candidate-edge-pruning.mdx b/docs/content/slitherlink/rules/vertex-candidate-edge-pruning.mdx
new file mode 100644
index 0000000..05cd962
--- /dev/null
+++ b/docs/content/slitherlink/rules/vertex-candidate-edge-pruning.mdx
@@ -0,0 +1,56 @@
+## What it does
+
+This is an **internal solver rule**, not a technique most players would name or
+apply by hand. It maintains **vertex candidates** at each grid vertex: the edge
+pairs (or empty pair for degree zero) that could still satisfy the loop's
+degree-zero / degree-two constraint.
+
+Each pass may:
+
+1. **Prune** candidates that disagree with edges already marked as a line or
+   crossed out.
+2. **Force** an unknown incident edge when every remaining candidate agrees it
+   must be a line or must be crossed out.
+
+The main work is (1), which updates invisible solver state. Step (2) is the only
+part that can show up as a normal line or cross on the board — and when the
+candidate set is still the full initial one, that conclusion usually matches
+what **Vertex Degree** would already deduce from line counts alone.
+
+Humans reason about vertex flow directly ("two lines here, so the rest are
+crosses"). A computer prefers an explicit list of surviving degree states and
+cheap set operations over re-deriving the same facts in several ad hoc cases.
+This rule is that bookkeeping layer: mechanical, exhaustive, and easy to chain
+into later propagation and trial contradiction checks.
+
+## When it triggers
+
+The rule scans every vertex on each application. It acts when at least one of
+these holds:
+
+- A known line or cross removes at least one vertex candidate.
+- After pruning, every surviving candidate includes the same still-unknown edge
+  (that edge is marked as a line).
+- After pruning, no surviving candidate includes the same still-unknown edge
+  (that edge is crossed out).
+
+No prior pruning step is required. A fresh puzzle already starts with the full
+degree-zero / degree-two candidate set at each vertex.
+
+The interesting cases are usually invisible: candidates were narrowed earlier by
+**Clue Combination Pruning** or a previous pass, so several unknown edges remain
+but only one combined degree state is still legal. Vertex Degree may not fire
+because the line count alone does not look decisive.
+
+## Why it works
+
+Vertex degree is a hard loop rule. Storing legal edge pairs is equivalent to that
+constraint while edges are still open. Any candidate that includes a crossed-out
+edge, or omits a drawn line, is impossible and is removed.
+
+If every remaining legal state uses the same unknown edge, that edge is necessary;
+if none use it, it is forbidden. The logic is sound but **computer-oriented**:
+humans rarely maintain enumerated candidate sets; they apply the same facts through
+local vertex-degree reasoning or sector/clue patterns. The solver keeps both views
+in sync so propagation rules and bounded inference can detect dead ends when no
+feasible degree state remains at a vertex.
diff --git a/docs/content/slitherlink/rules/vertex-degree.mdx b/docs/content/slitherlink/rules/vertex-degree.mdx
index 249718e..92380d3 100644
--- a/docs/content/slitherlink/rules/vertex-degree.mdx
+++ b/docs/content/slitherlink/rules/vertex-degree.mdx
@@ -1,25 +1,28 @@
-## What this technique does
+## What it does
 
-Every Slitherlink vertex belongs to either zero or two loop edges. A vertex may
-never become a dead end or a branch.
+Every Slitherlink vertex belongs to either zero or two loop edges. At a vertex
+with at least one unknown incident edge, the rule may cross out every remaining
+unknown edge, force the only remaining unknown edge to be a line, or cross out
+that last unknown edge when using it would create a dead end.
 
-## Trigger conditions
+## When it triggers
 
-The technique acts when the decided edges around a vertex determine the
-remaining unknown edges.
+The technique acts on a vertex that still has at least one unknown incident
+edge. No numbered clue is required. One of these partial states must hold:
 
-## Conclusions
-
-If two lines already meet at a vertex, every other incident edge is crossed out.
-If one line and only one unknown edge remain, that unknown edge is forced.
-If no lines and only one unknown edge remain, it is crossed out.
+- Two incident edges are already lines. Every other incident edge at that
+  vertex is still unknown.
+- Exactly one incident edge is a line, every other decided incident edge is
+  crossed out, and exactly one unknown edge remains.
+- No incident edge is a line, every other decided incident edge is crossed
+  out, and exactly one unknown edge remains.
 
 ## Why it works
 
-A single used edge creates a dead end, while three or more used edges create a
-branch. Neither can be part of one continuous loop.
-
-## Limits and related techniques
-
-This rule enforces local degree only. Prevent Premature Loop and connectivity
-rules handle larger loop structure.
+A valid loop gives every used vertex degree two. A single used edge creates a
+dead end, while three or more used edges create a branch. If two lines already
+meet at a vertex, any additional line would exceed degree two, so every
+remaining unknown edge must be crossed out. If one line is already present and
+only one unknown edge remains, that edge must complete the vertex to degree
+two. If no line is present and only one unknown edge remains, marking it as a
+line would leave a degree-one dead end, so it must be crossed out.
diff --git a/docs/content/slitherlink/rules/vertex-onlyone-non-sector-balance.mdx b/docs/content/slitherlink/rules/vertex-onlyone-non-sector-balance.mdx
new file mode 100644
index 0000000..04be72d
--- /dev/null
+++ b/docs/content/slitherlink/rules/vertex-onlyone-non-sector-balance.mdx
@@ -0,0 +1,53 @@
+## What it does
+
+When a corner sector at a vertex is known to contain **exactly one line**, this
+rule completes the vertex's **non-sector** edges — the incident edges that are
+not part of that sector.
+
+Depending on the partial state it may:
+
+- mark the only remaining non-sector edge as a **line**;
+- mark one unknown non-sector edge as a **line** when another non-sector edge is
+  already crossed out;
+- cross out one unknown non-sector edge when another non-sector edge is already
+  a line.
+
+It does not change sector masks.
+
+## When it triggers
+
+The rule scans every grid vertex and every corner sector that touches it. It
+acts when that sector's constraint has already been narrowed to **exactly one
+line** and one of these local patterns appears among the vertex's non-sector
+edges:
+
+- **Single outside edge:** exactly one incident edge is not in the sector, and
+  it is still unknown. That edge is marked as a line so the vertex can still
+  reach degree two.
+- **Two outside edges, one blank:** two non-sector edges are incident, one is
+  crossed out, one is unknown. The unknown edge is marked as a line.
+- **Two outside edges, one line:** two non-sector edges are incident, one is a
+  line, one is unknown. The unknown edge is crossed out.
+
+The exactly-one sector constraint must come from earlier sector reasoning. If the
+sector is not exactly one line, or the non-sector pattern does not match one of
+the cases above, the vertex-sector pair is skipped.
+
+## Why it works
+
+A valid loop gives every used vertex degree two. A corner sector's two edges are
+only part of that accounting; the other edges at the same vertex must supply the
+rest.
+
+If the sector is fixed at exactly one line, that line uses one of the vertex's
+two allowed lines. The non-sector edges must provide the other line — or none,
+if the sector line is the only one the vertex needs.
+
+When only one non-sector edge exists at the vertex, it must be the completing
+line. When two non-sector edges remain open, a crossed-out edge means the vertex
+still needs its second line on the other; an existing line means the sector line
+and that line already satisfy degree two, so the last unknown non-sector edge
+must be crossed out.
+
+Any other mark would leave the vertex with degree one or degree three at that
+corner.
diff --git a/docs/techniques/slitherlink.md b/docs/techniques/slitherlink.md
index 1d9ecb9..3499893 100644
--- a/docs/techniques/slitherlink.md
+++ b/docs/techniques/slitherlink.md
@@ -28,7 +28,7 @@ PuzzleKit represents Slitherlink with a grid-edge model:
 - Import from `puzz.link` Slitherlink URLs and Penpa inputs.
 - Create and edit Slitherlink puzzles in the editor.
 - Render clues, lines, crosses, colors, sectors, and solver highlights.
-- Replay deterministic and conservative branch-based solving steps with
-  explanations.
+- Replay deterministic and bounded strong-inference solving steps with
+  explanations and branch inspection.
 - Analyze completion for one valid loop satisfying all numbered clues.
 
diff --git a/scripts/benchmark-solve.test.ts b/scripts/benchmark-solve.test.ts
new file mode 100644
index 0000000..6b22a84
--- /dev/null
+++ b/scripts/benchmark-solve.test.ts
@@ -0,0 +1,158 @@
+import { mkdtemp, readdir } from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { describe, expect, it } from 'vitest'
+import { runBenchmarkManifest } from '../src/domain/benchmark'
+import {
+  createRunDirectory,
+  formatRunTimestamp,
+  parseBenchmarkCliArgs,
+  selectManifestItems,
+  writeBenchmarkOutputs,
+} from './benchmark-solve'
+import type { BenchmarkDatasetManifest } from '../src/domain/benchmark'
+
+const manifest: BenchmarkDatasetManifest = {
+  schemaVersion: 1,
+  id: 'sample',
+  title: 'Sample',
+  puzzleType: 'slitherlink',
+  items: [
+    {
+      id: 'a',
+      puzzleType: 'slitherlink',
+      sourceUrl: 'https://puzz.link/p?slither/1/1/0',
+      width: 1,
+      height: 1,
+      tags: [],
+    },
+    {
+      id: 'b',
+      puzzleType: 'slitherlink',
+      sourceUrl: 'https://puzz.link/p?slither/1/1/1',
+      width: 1,
+      height: 1,
+      tags: [],
+    },
+  ],
+}
+
+describe('benchmark solve CLI', () => {
+  it('defaults to text plus TSV output', () => {
+    expect(parseBenchmarkCliArgs([]).format).toBe('both')
+  })
+
+  it('parses repeatable datasets and comma-separated IDs', () => {
+    expect(
+      parseBenchmarkCliArgs([
+        '--dataset',
+        'a.json',
+        '--dataset',
+        'b.json',
+        '--ids',
+        'a,b',
+        '--ids',
+        'c',
+        '--max-steps',
+        '12',
+        '--timeout-ms',
+        '34',
+        '--telemetry',
+        'off',
+        '--format',
+        'both',
+        '--out-dir',
+        'out',
+      ]),
+    ).toEqual({
+      datasetPaths: ['a.json', 'b.json'],
+      ids: ['a', 'b', 'c'],
+      maxSteps: 12,
+      timeoutMs: 34,
+      telemetry: 'off',
+      format: 'both',
+      outDir: 'out',
+    })
+  })
+
+  it('rejects invalid values and unknown options', () => {
+    expect(() => parseBenchmarkCliArgs(['--max-steps', '0'])).toThrow(
+      '--max-steps must be a positive integer',
+    )
+    expect(() => parseBenchmarkCliArgs(['--telemetry', 'details'])).toThrow(
+      '--telemetry must be one of off, summary',
+    )
+    expect(() => parseBenchmarkCliArgs(['--unknown'])).toThrow(
+      'Invalid benchmark arguments',
+    )
+  })
+
+  it('filters manifests and rejects duplicate or unmatched selections', () => {
+    expect(
+      selectManifestItems([manifest], ['b'])[0].items.map((item) => item.id),
+    ).toEqual(['b'])
+    expect(() => selectManifestItems([manifest], ['missing'])).toThrow(
+      'No puzzles matched',
+    )
+    expect(() => selectManifestItems([manifest, { ...manifest }], [])).toThrow(
+      'Duplicate dataset ID',
+    )
+  })
+
+  it('formats local timestamps and avoids overwriting same-second runs', async () => {
+    const outDir = await mkdtemp(path.join(os.tmpdir(), 'benchmark-output-'))
+    const timestamp = formatRunTimestamp(new Date(2026, 5, 12, 19, 45, 7))
+
+    expect(timestamp).toBe('20260612-194507')
+    expect(
+      path.basename(await createRunDirectory(outDir, 'sample', timestamp)),
+    ).toBe(timestamp)
+    expect(
+      path.basename(await createRunDirectory(outDir, 'sample', timestamp)),
+    ).toBe(`${timestamp}-2`)
+  })
+
+  it('writes only the files selected by each format', async () => {
+    const outDir = await mkdtemp(path.join(os.tmpdir(), 'benchmark-output-'))
+    const report = runBenchmarkManifest(manifest, {
+      maxSteps: 1,
+      telemetry: 'summary',
+    })
+    const expected = {
+      both: [
+        'puzzles.tsv',
+        'rule-attempts.tsv',
+        'strong-inference.tsv',
+        'summary.txt',
+      ],
+      text: ['summary.txt'],
+      tsv: ['puzzles.tsv', 'rule-attempts.tsv', 'strong-inference.tsv'],
+      json: ['report.json'],
+    } as const
+
+    for (const format of ['both', 'text', 'tsv', 'json'] as const) {
+      const timestamp = `20260612-19450${Object.keys(expected).indexOf(format)}`
+      await writeBenchmarkOutputs(report, { format, outDir }, timestamp)
+      expect(
+        (
+          await readdir(path.join(outDir, report.run.datasetId, timestamp))
+        ).sort(),
+      ).toEqual([...expected[format]].sort())
+    }
+  })
+
+  it('writes only puzzles.tsv when TSV telemetry is off', async () => {
+    const outDir = await mkdtemp(path.join(os.tmpdir(), 'benchmark-output-'))
+    const report = runBenchmarkManifest(manifest, {
+      maxSteps: 1,
+      telemetry: 'off',
+    })
+    const timestamp = '20260612-194510'
+
+    await writeBenchmarkOutputs(report, { format: 'tsv', outDir }, timestamp)
+
+    expect(
+      await readdir(path.join(outDir, report.run.datasetId, timestamp)),
+    ).toEqual(['puzzles.tsv'])
+  })
+})
diff --git a/scripts/benchmark-solve.ts b/scripts/benchmark-solve.ts
index 13a8a18..0b37e64 100644
--- a/scripts/benchmark-solve.ts
+++ b/scripts/benchmark-solve.ts
@@ -1,22 +1,151 @@
 import type { Dirent } from 'node:fs'
 import { mkdir, readFile, readdir, writeFile } from 'node:fs/promises'
 import path from 'node:path'
-import { fileURLToPath } from 'node:url'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { parseArgs } from 'node:util'
 import {
+  formatBenchmarkReportText,
+  formatBenchmarkReportTsv,
   runBenchmarkManifest,
   validateBenchmarkManifest,
 } from '../src/domain/benchmark'
+import type {
+  BenchmarkDatasetManifest,
+  BenchmarkReport,
+  BenchmarkTelemetryLevel,
+} from '../src/domain/benchmark'
 
 const DATASET_DIRS = ['dataset/public', 'dataset/private']
-const OUTPUT_DIR = 'benchmark-results'
+const DEFAULT_OUTPUT_DIR = 'benchmark-results'
+
+export type BenchmarkOutputFormat = 'json' | 'text' | 'tsv' | 'both'
 
-const projectRoot = path.resolve(
+export type BenchmarkCliOptions = {
+  datasetPaths: string[]
+  ids: string[]
+  maxSteps: number
+  timeoutMs: number
+  telemetry: BenchmarkTelemetryLevel
+  format: BenchmarkOutputFormat
+  outDir: string
+}
+
+export const projectRoot = path.resolve(
   path.dirname(fileURLToPath(import.meta.url)),
   '..',
 )
 
-const findJsonFiles = async (dir: string): Promise<string[]> => {
-  const absoluteDir = path.join(projectRoot, dir)
+const parsePositiveInteger = (
+  name: string,
+  value: string | undefined,
+  fallback: number,
+) => {
+  if (value === undefined) return fallback
+  const parsed = Number(value)
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(
+      `--${name} must be a positive integer; received "${value}".`,
+    )
+  }
+  return parsed
+}
+
+const parseEnum = <T extends string>(
+  name: string,
+  value: string | undefined,
+  allowed: readonly T[],
+  fallback: T,
+): T => {
+  if (value === undefined) return fallback
+  if (!allowed.includes(value as T)) {
+    throw new Error(
+      `--${name} must be one of ${allowed.join(', ')}; received "${value}".`,
+    )
+  }
+  return value as T
+}
+
+const flattenCsvValues = (values: string[] | undefined): string[] =>
+  (values ?? [])
+    .flatMap((value) => value.split(','))
+    .map((value) => value.trim())
+    .filter(Boolean)
+
+const getString = (
+  values: ReturnType<typeof parseArgs>['values'],
+  key: string,
+): string | undefined => {
+  const value = values[key]
+  return typeof value === 'string' ? value : undefined
+}
+
+const getStrings = (
+  values: ReturnType<typeof parseArgs>['values'],
+  key: string,
+): string[] | undefined => {
+  const value = values[key]
+  return Array.isArray(value)
+    ? value.filter((entry): entry is string => typeof entry === 'string')
+    : undefined
+}
+
+export const parseBenchmarkCliArgs = (args: string[]): BenchmarkCliOptions => {
+  let values: ReturnType<typeof parseArgs>['values']
+  try {
+    ;({ values } = parseArgs({
+      args,
+      strict: true,
+      allowPositionals: false,
+      options: {
+        dataset: { type: 'string', multiple: true },
+        ids: { type: 'string', multiple: true },
+        'max-steps': { type: 'string' },
+        'timeout-ms': { type: 'string' },
+        telemetry: { type: 'string' },
+        format: { type: 'string' },
+        'out-dir': { type: 'string' },
+      },
+    }))
+  } catch (error) {
+    throw new Error(
+      `Invalid benchmark arguments: ${error instanceof Error ? error.message : String(error)}`,
+    )
+  }
+
+  return {
+    datasetPaths: getStrings(values, 'dataset') ?? [],
+    ids: flattenCsvValues(getStrings(values, 'ids')),
+    maxSteps: parsePositiveInteger(
+      'max-steps',
+      getString(values, 'max-steps'),
+      2000,
+    ),
+    timeoutMs: parsePositiveInteger(
+      'timeout-ms',
+      getString(values, 'timeout-ms'),
+      60_000,
+    ),
+    telemetry: parseEnum(
+      'telemetry',
+      getString(values, 'telemetry'),
+      ['off', 'summary'] as const,
+      'summary',
+    ),
+    format: parseEnum(
+      'format',
+      getString(values, 'format'),
+      ['json', 'text', 'tsv', 'both'] as const,
+      'both',
+    ),
+    outDir: getString(values, 'out-dir') ?? DEFAULT_OUTPUT_DIR,
+  }
+}
+
+const resolveProjectPath = (targetPath: string): string =>
+  path.isAbsolute(targetPath) ? targetPath : path.join(projectRoot, targetPath)
+
+export const findJsonFiles = async (dir: string): Promise<string[]> => {
+  const absoluteDir = resolveProjectPath(dir)
   let entries: Dirent<string>[]
   try {
     entries = await readdir(absoluteDir, { withFileTypes: true })
@@ -29,54 +158,216 @@ const findJsonFiles = async (dir: string): Promise<string[]> => {
 
   const files: string[] = []
   for (const entry of entries) {
-    const relativePath = path.join(dir, entry.name)
+    const entryPath = path.join(absoluteDir, entry.name)
     if (entry.isDirectory()) {
-      files.push(...(await findJsonFiles(relativePath)))
+      files.push(...(await findJsonFiles(entryPath)))
     } else if (entry.isFile() && entry.name.endsWith('.json')) {
-      files.push(relativePath)
+      files.push(entryPath)
     }
   }
   return files.sort()
 }
 
-const readManifest = async (manifestPath: string) => {
-  const raw = await readFile(path.join(projectRoot, manifestPath), 'utf8')
-  return validateBenchmarkManifest(JSON.parse(raw))
+export const readManifest = async (
+  manifestPath: string,
+): Promise<BenchmarkDatasetManifest> => {
+  const absolutePath = resolveProjectPath(manifestPath)
+  let raw: string
+  try {
+    raw = await readFile(absolutePath, 'utf8')
+  } catch (error) {
+    throw new Error(
+      `Unable to read dataset "${manifestPath}": ${error instanceof Error ? error.message : String(error)}`,
+    )
+  }
+  try {
+    return validateBenchmarkManifest(JSON.parse(raw))
+  } catch (error) {
+    throw new Error(
+      `Invalid dataset "${manifestPath}": ${error instanceof Error ? error.message : String(error)}`,
+    )
+  }
+}
+
+export const selectManifestItems = (
+  manifests: BenchmarkDatasetManifest[],
+  ids: string[],
+): BenchmarkDatasetManifest[] => {
+  const duplicateIds = manifests
+    .map((manifest) => manifest.id)
+    .filter((id, index, all) => all.indexOf(id) !== index)
+  if (duplicateIds.length > 0) {
+    throw new Error(
+      `Duplicate dataset ID(s): ${Array.from(new Set(duplicateIds)).join(', ')}.`,
+    )
+  }
+  if (ids.length === 0) return manifests
+
+  const selectedIds = new Set(ids)
+  const filtered = manifests.flatMap((manifest) => {
+    const items = manifest.items.filter((item) => selectedIds.has(item.id))
+    return items.length > 0 ? [{ ...manifest, items }] : []
+  })
+  if (filtered.length === 0) {
+    throw new Error(`No puzzles matched --ids ${ids.join(', ')}.`)
+  }
+  return filtered
+}
+
+export const formatRunTimestamp = (date: Date): string => {
+  const pad = (value: number): string => String(value).padStart(2, '0')
+  return [
+    date.getFullYear(),
+    pad(date.getMonth() + 1),
+    pad(date.getDate()),
+    '-',
+    pad(date.getHours()),
+    pad(date.getMinutes()),
+    pad(date.getSeconds()),
+  ].join('')
 }
 
-const writeReport = async (
+export const createRunDirectory = async (
+  outDir: string,
   datasetId: string,
-  report: unknown,
+  timestamp: string,
+): Promise<string> => {
+  const datasetDir = path.join(resolveProjectPath(outDir), datasetId)
+  await mkdir(datasetDir, { recursive: true })
+  for (let suffix = 1; ; suffix += 1) {
+    const name = suffix === 1 ? timestamp : `${timestamp}-${suffix}`
+    const runDir = path.join(datasetDir, name)
+    try {
+      await mkdir(runDir)
+      return runDir
+    } catch (error) {
+      if (
+        error instanceof Error &&
+        'code' in error &&
+        error.code === 'EEXIST'
+      ) {
+        continue
+      }
+      throw error
+    }
+  }
+}
+
+const writeArtifact = async (
+  runDir: string,
+  filename: string,
+  content: string,
 ): Promise<string> => {
-  const outPath = path.join(OUTPUT_DIR, `${datasetId}.report.json`)
-  const absoluteOutPath = path.join(projectRoot, outPath)
-  await mkdir(path.dirname(absoluteOutPath), { recursive: true })
-  await writeFile(absoluteOutPath, `${JSON.stringify(report, null, 2)}\n`)
-  return outPath
+  const absolutePath = path.join(runDir, filename)
+  await writeFile(absolutePath, content)
+  return path.relative(projectRoot, absolutePath)
 }
 
-const main = async (): Promise<void> => {
-  const manifestPaths = (
-    await Promise.all(DATASET_DIRS.map((dir) => findJsonFiles(dir)))
-  ).flat()
+export const writeBenchmarkOutputs = async (
+  report: BenchmarkReport,
+  options: Pick<BenchmarkCliOptions, 'format' | 'outDir'>,
+  timestamp: string,
+): Promise<string[]> => {
+  const runDir = await createRunDirectory(
+    options.outDir,
+    report.run.datasetId,
+    timestamp,
+  )
+  if (options.format === 'json') {
+    return [
+      await writeArtifact(
+        runDir,
+        'report.json',
+        `${JSON.stringify(report, null, 2)}\n`,
+      ),
+    ]
+  }
+
+  const outputPaths: string[] = []
+  if (options.format === 'text' || options.format === 'both') {
+    outputPaths.push(
+      await writeArtifact(
+        runDir,
+        'summary.txt',
+        `${formatBenchmarkReportText(report)}\n`,
+      ),
+    )
+  }
+  if (options.format === 'tsv' || options.format === 'both') {
+    const tables = formatBenchmarkReportTsv(report)
+    outputPaths.push(await writeArtifact(runDir, 'puzzles.tsv', tables.puzzles))
+    if (tables.ruleAttempts && tables.strongInference) {
+      outputPaths.push(
+        await writeArtifact(runDir, 'rule-attempts.tsv', tables.ruleAttempts),
+        await writeArtifact(
+          runDir,
+          'strong-inference.tsv',
+          tables.strongInference,
+        ),
+      )
+    }
+  }
+  return outputPaths
+}
 
+export const runBenchmarkCli = async (
+  options: BenchmarkCliOptions,
+): Promise<void> => {
+  const manifestPaths =
+    options.datasetPaths.length > 0
+      ? options.datasetPaths
+      : (
+          await Promise.all(DATASET_DIRS.map((dir) => findJsonFiles(dir)))
+        ).flat()
   if (manifestPaths.length === 0) {
     throw new Error(
       `No benchmark manifests found under ${DATASET_DIRS.join(' or ')}.`,
     )
   }
 
-  for (const manifestPath of manifestPaths) {
-    const manifest = await readManifest(manifestPath)
-    const report = runBenchmarkManifest(manifest)
-    const outPath = await writeReport(manifest.id, report)
-    console.log(
-      `Wrote ${manifest.id}: ${report.summary.total} puzzle(s), ${outPath}`,
+  const manifests = selectManifestItems(
+    await Promise.all(manifestPaths.map(readManifest)),
+    options.ids,
+  )
+  const runTimestamp = formatRunTimestamp(new Date())
+  for (const manifest of manifests) {
+    const report = runBenchmarkManifest(manifest, {
+      maxSteps: options.maxSteps,
+      timeoutMs: options.timeoutMs,
+      telemetry: options.telemetry,
+    })
+    if (options.format === 'text' || options.format === 'both') {
+      console.log(formatBenchmarkReportText(report))
+    }
+    if (
+      (options.format === 'tsv' || options.format === 'both') &&
+      options.telemetry === 'off'
+    ) {
+      console.log(
+        `${manifest.id}: telemetry is off; rule-attempts.tsv and strong-inference.tsv were not generated.`,
+      )
+    }
+    const outputPaths = await writeBenchmarkOutputs(
+      report,
+      options,
+      runTimestamp,
     )
+    console.log(`Wrote ${manifest.id}: ${report.summary.total} puzzle(s)`)
+    for (const outputPath of outputPaths) {
+      console.log(`  ${outputPath}`)
+    }
   }
 }
 
-main().catch((error: unknown) => {
-  console.error(error instanceof Error ? error.message : String(error))
-  process.exitCode = 1
-})
+const isMain = process.argv[1]
+  ? import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href
+  : false
+
+if (isMain) {
+  runBenchmarkCli(parseBenchmarkCliArgs(process.argv.slice(2))).catch(
+    (error: unknown) => {
+      console.error(error instanceof Error ? error.message : String(error))
+      process.exitCode = 1
+    },
+  )
+}
diff --git a/src/app/DatasetPage.test.tsx b/src/app/DatasetPage.test.tsx
index afdf75d..9e19816 100644
--- a/src/app/DatasetPage.test.tsx
+++ b/src/app/DatasetPage.test.tsx
@@ -79,7 +79,7 @@ describe('DatasetPage', () => {
     expect(
       screen.getByLabelText(/slitherlink-10x10-0001 dataset preview/i),
     ).toHaveClass('dataset-preview-canvas')
-    expect(screen.getByText(/showing 56 \/ 111 puzzles/i)).toBeInTheDocument()
+    expect(screen.getByText(/showing 56 \/ 112 puzzles/i)).toBeInTheDocument()
   })
 
   it('filters by search text, size, and tag', () => {
@@ -98,7 +98,7 @@ describe('DatasetPage', () => {
     expect(
       screen.queryByRole('heading', { name: 'slitherlink-10x10-0001' }),
     ).not.toBeInTheDocument()
-    expect(screen.getByText(/showing 1 \/ 111 puzzles/i)).toBeInTheDocument()
+    expect(screen.getByText(/showing 1 \/ 112 puzzles/i)).toBeInTheDocument()
 
     fireEvent.change(
       screen.getByPlaceholderText(/name, tag, size, type, or url/i),
@@ -119,13 +119,13 @@ describe('DatasetPage', () => {
     expect(
       screen.queryByRole('heading', { name: 'slitherlink-10x10-0001' }),
     ).not.toBeInTheDocument()
-    expect(screen.getByText(/showing 2 \/ 111 puzzles/i)).toBeInTheDocument()
+    expect(screen.getByText(/showing 2 \/ 112 puzzles/i)).toBeInTheDocument()
 
     fireEvent.click(screen.getByRole('button', { name: /auto-imported/i }))
     expect(
       screen.getByRole('button', { name: /auto-imported/i }),
     ).toHaveAttribute('data-active', 'true')
-    expect(screen.getByText(/showing 2 \/ 111 puzzles/i)).toBeInTheDocument()
+    expect(screen.getByText(/showing 2 \/ 112 puzzles/i)).toBeInTheDocument()
   })
 
   it('enables Masyu datasets and resets type-specific filters', () => {
@@ -143,7 +143,7 @@ describe('DatasetPage', () => {
     fireEvent.click(screen.getByRole('button', { name: /auto-imported/i }))
     fireEvent.change(typeSelect, { target: { value: 'masyu' } })
 
-    expect(screen.getByText(/showing 55 \/ 111 puzzles/i)).toBeInTheDocument()
+    expect(screen.getByText(/showing 56 \/ 112 puzzles/i)).toBeInTheDocument()
     expect(
       screen.getByRole('heading', { name: 'masyu-25x25-0001' }),
     ).toBeInTheDocument()
@@ -162,7 +162,7 @@ describe('DatasetPage', () => {
     fireEvent.change(screen.getByLabelText(/^size$/i), {
       target: { value: '20 x 20' },
     })
-    expect(screen.getByText(/showing 2 \/ 111 puzzles/i)).toBeInTheDocument()
+    expect(screen.getByText(/showing 2 \/ 112 puzzles/i)).toBeInTheDocument()
     expect(
       screen.getByRole('heading', { name: 'masyu-20x20-6613546' }),
     ).toBeInTheDocument()
@@ -179,7 +179,7 @@ describe('DatasetPage', () => {
         target: { value: 'masyu-20x20-6613546' },
       },
     )
-    expect(screen.getByText(/showing 1 \/ 111 puzzles/i)).toBeInTheDocument()
+    expect(screen.getByText(/showing 1 \/ 112 puzzles/i)).toBeInTheDocument()
   })
 
   it('filters Masyu datasets by difficulty and area tags', () => {
@@ -190,19 +190,19 @@ describe('DatasetPage', () => {
     })
 
     fireEvent.click(screen.getByRole('button', { name: 'easy' }))
-    expect(screen.getByText(/showing 18 \/ 111 puzzles/i)).toBeInTheDocument()
+    expect(screen.getByText(/showing 18 \/ 112 puzzles/i)).toBeInTheDocument()
 
     fireEvent.click(screen.getByRole('button', { name: 'Small' }))
-    expect(screen.getByText(/showing 7 \/ 111 puzzles/i)).toBeInTheDocument()
+    expect(screen.getByText(/showing 7 \/ 112 puzzles/i)).toBeInTheDocument()
 
     fireEvent.click(screen.getByRole('button', { name: 'Medium' }))
-    expect(screen.getByText(/showing 7 \/ 111 puzzles/i)).toBeInTheDocument()
+    expect(screen.getByText(/showing 7 \/ 112 puzzles/i)).toBeInTheDocument()
 
     fireEvent.click(screen.getByRole('button', { name: 'Large' }))
-    expect(screen.getByText(/showing 41 \/ 111 puzzles/i)).toBeInTheDocument()
+    expect(screen.getByText(/showing 42 \/ 112 puzzles/i)).toBeInTheDocument()
 
     fireEvent.click(screen.getByRole('button', { name: 'hard' }))
-    expect(screen.getByText(/showing 37 \/ 111 puzzles/i)).toBeInTheDocument()
+    expect(screen.getByText(/showing 38 \/ 112 puzzles/i)).toBeInTheDocument()
   })
 
   it('renders compact action links for each dataset puzzle', () => {
diff --git a/src/app/DocsPage.test.tsx b/src/app/DocsPage.test.tsx
index b90aac6..0739d03 100644
--- a/src/app/DocsPage.test.tsx
+++ b/src/app/DocsPage.test.tsx
@@ -45,7 +45,7 @@ describe('DocsPage', () => {
       screen.getByRole('button', { name: 'Play deduction' }),
     ).toBeInTheDocument()
     expect(
-      screen.getByLabelText('Rule documentation example'),
+      screen.getByLabelText('Rule documentation example: horizontal-exit'),
     ).toBeInTheDocument()
   })
 })
diff --git a/src/app/EditorPage.test.tsx b/src/app/EditorPage.test.tsx
index 107aae1..e0b2b20 100644
--- a/src/app/EditorPage.test.tsx
+++ b/src/app/EditorPage.test.tsx
@@ -437,7 +437,11 @@ describe('EditorPage', () => {
 
     fireEvent.click(screen.getByRole('button', { name: /show masyu legend/i }))
     const legend = screen.getByRole('dialog', { name: /masyu legend/i })
-    expect(within(legend).getByText(/white and black pearls/i)).toBeInTheDocument()
+    expect(within(legend).getByText('Black & White')).toBeInTheDocument()
+    expect(within(legend).getByText('Cross & Line')).toBeInTheDocument()
+    expect(within(legend).getByText('Green Tile')).toBeInTheDocument()
+    expect(within(legend).getByText('Yellow Tile')).toBeInTheDocument()
+    expect(within(legend).getByText(/white pearls go straight/i)).toBeInTheDocument()
     fireEvent.click(within(legend).getByRole('button', { name: /close masyu legend/i }))
 
     fireEvent.focus(screen.getByRole('button', { name: /show puzzle stats/i }))
diff --git a/src/app/WorkspacePage.test.tsx b/src/app/WorkspacePage.test.tsx
index 588f1db..952cf9f 100644
--- a/src/app/WorkspacePage.test.tsx
+++ b/src/app/WorkspacePage.test.tsx
@@ -174,6 +174,27 @@ describe('WorkspacePage', () => {
     expect(screen.queryByRole('dialog', { name: /slitherlink legend/i })).not.toBeInTheDocument()
   })
 
+  it('opens masyu board legend with pearl, line, cross, and tile examples', async () => {
+    renderWorkspace()
+
+    fireEvent.change(screen.getByDisplayValue('Slitherlink'), { target: { value: 'masyu' } })
+    await waitFor(() => expect(useSolverStore.getState().pluginId).toBe('masyu'))
+
+    fireEvent.click(screen.getByRole('button', { name: /show masyu legend/i }))
+
+    const legendDialog = screen.getByRole('dialog', { name: /masyu legend/i })
+    expect(legendDialog).toBeInTheDocument()
+    expect(within(legendDialog).getByText('Black & White')).toBeInTheDocument()
+    expect(within(legendDialog).getByText('Cross & Line')).toBeInTheDocument()
+    expect(within(legendDialog).getByText('Green Tile')).toBeInTheDocument()
+    expect(within(legendDialog).getByText('Yellow Tile')).toBeInTheDocument()
+    expect(within(legendDialog).getByText(/white pearls go straight/i)).toBeInTheDocument()
+    expect(within(legendDialog).getByText(/cross out center connections/i)).toBeInTheDocument()
+    expect(within(legendDialog).getByText(/inside of the final loop/i)).toBeInTheDocument()
+    expect(within(legendDialog).getByText(/outside of the final loop/i)).toBeInTheDocument()
+    expect(within(legendDialog).getAllByLabelText(/legend canvas/i)).toHaveLength(4)
+  })
+
   it('keeps rules and legend popovers exclusive in the puzzle type row', () => {
     renderWorkspace()
 
diff --git a/src/app/workspace.css b/src/app/workspace.css
index 8380b83..296b71a 100644
--- a/src/app/workspace.css
+++ b/src/app/workspace.css
@@ -254,9 +254,34 @@
   margin: 8px 0;
 }
 
+.docs-prose img {
+  display: block;
+  max-width: 100%;
+  height: auto;
+  margin: 16px auto;
+  border: 1px solid #e2e8f0;
+  border-radius: 8px;
+}
+
+.docs-prose .docs-figure-scroll {
+  overflow-x: auto;
+  margin: 16px 0;
+  border: 1px solid #e2e8f0;
+  border-radius: 8px;
+  background: #f8fafc;
+}
+
+.docs-prose .docs-figure-scroll img {
+  max-width: none;
+  width: auto;
+  margin: 0;
+  border: 0;
+  border-radius: 0;
+}
+
 .rule-example {
   display: grid;
-  gap: 10px;
+  gap: 12px;
   margin: 28px 0 0;
   border: 1px solid #dbeafe;
   border-radius: 10px;
@@ -276,24 +301,81 @@
   gap: 6px;
 }
 
-.rule-example .surface-board {
+.rule-example-cases {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 12px;
+  align-items: stretch;
+}
+
+.rule-example-case {
+  display: grid;
+  grid-template-rows: auto minmax(0, 1fr) auto;
+  gap: 10px;
+  min-width: 0;
+  min-height: 0;
+  margin: 0;
+  border: 1px solid #e2e8f0;
+  border-radius: 8px;
+  background: #ffffff;
+  padding: 12px;
+}
+
+.rule-example-case:only-child,
+.rule-example-case:nth-last-child(1):nth-child(odd) {
+  grid-column: 1 / -1;
+}
+
+.rule-example-case:nth-last-child(1):nth-child(odd):not(:only-child) {
+  width: calc(50% - 6px);
+  justify-self: center;
+}
+
+.rule-example-case h3 {
+  margin: 0;
+  color: #1e293b;
+  font-size: 0.95rem;
+}
+
+.rule-example-board {
+  display: grid;
+  min-width: 0;
+  min-height: 0;
+  place-items: center;
+}
+
+.rule-example-case .surface-board {
   display: grid;
   gap: 8px;
+  max-width: 100%;
 }
 
-.rule-example .surface-board-tools {
+.rule-example-case .surface-board-tools {
   display: none;
 }
 
-.rule-example .board-scroll-shell {
+.rule-example-case .board-scroll-shell {
+  max-width: 100%;
   max-height: 430px;
 }
 
-.rule-example figcaption {
+.rule-example-case figcaption {
   color: #475569;
   font-size: 0.88rem;
 }
 
+@media (max-width: 820px) {
+  .rule-example-cases {
+    grid-template-columns: minmax(0, 1fr);
+  }
+
+  .rule-example-case,
+  .rule-example-case:nth-last-child(1):nth-child(odd):not(:only-child) {
+    grid-column: auto;
+    width: auto;
+  }
+}
+
 .workspace-grid {
   display: grid;
   grid-template-columns: minmax(0, 2.25fr) minmax(300px, 0.9fr);
diff --git a/src/domain/benchmark/aggregation.test.ts b/src/domain/benchmark/aggregation.test.ts
new file mode 100644
index 0000000..cfb7c26
--- /dev/null
+++ b/src/domain/benchmark/aggregation.test.ts
@@ -0,0 +1,75 @@
+import { describe, expect, it } from 'vitest'
+import {
+  aggregateRuleAttemptSummaries,
+  aggregateStrongCoverage,
+  aggregateStrongInferenceSummaries,
+} from './aggregation'
+
+describe('benchmark telemetry aggregation', () => {
+  it('sums rule attempts and drops per-item final scans', () => {
+    const summary = aggregateRuleAttemptSummaries([
+      {
+        totalAttemptCount: 2,
+        rules: {
+          a: {
+            ruleId: 'a',
+            ruleName: 'A',
+            attemptCount: 2,
+            hitCount: 1,
+            missCount: 1,
+            hitRate: 0.5,
+            totalDurationMs: 6,
+            hitDurationMs: 4,
+            missDurationMs: 2,
+            averageDurationMs: 3,
+            producedDiffCount: 2,
+          },
+        },
+        finalNoHitScan: {
+          solverStepNumber: 2,
+          totalDurationMs: 2,
+          attemptCount: 1,
+          rules: [{ ruleId: 'a', ruleName: 'A', durationMs: 2 }],
+        },
+      },
+    ])
+
+    expect(summary.rules.a.hitRate).toBe(0.5)
+    expect(summary.finalNoHitScan).toBeNull()
+  })
+
+  it('aggregates strong work and coverage', () => {
+    const summary = aggregateStrongInferenceSummaries([
+      {
+        totals: {
+          attemptCount: 1,
+          hitCount: 1,
+          missCount: 0,
+          timeoutCount: 0,
+          hitRate: 1,
+          candidateCount: 2,
+          probeCount: 3,
+          trialStepCount: 4,
+          probeDurationMs: 5,
+          producedDiffCount: 1,
+        },
+        rules: [],
+      },
+    ])
+    const coverage = aggregateStrongCoverage([
+      {
+        status: 'full',
+        supportedRules: [{ ruleId: 'a', ruleName: 'A', supported: true }],
+        unsupportedRules: [],
+      },
+      {
+        status: 'none',
+        supportedRules: [],
+        unsupportedRules: [{ ruleId: 'b', ruleName: 'B', supported: false }],
+      },
+    ])
+
+    expect(summary.totals.probeCount).toBe(3)
+    expect(coverage.status).toBe('partial')
+  })
+})
diff --git a/src/domain/benchmark/aggregation.ts b/src/domain/benchmark/aggregation.ts
new file mode 100644
index 0000000..bf711bf
--- /dev/null
+++ b/src/domain/benchmark/aggregation.ts
@@ -0,0 +1,206 @@
+import type {
+  RuleAttemptRuleSummary,
+  RuleAttemptSummary,
+} from '../rules/ruleAttemptSummaryCollector'
+import type {
+  StrongInferenceRuleSummary,
+  StrongInferenceSummary,
+  StrongInferenceTotals,
+} from '../rules/strongInferenceSummaryCollector'
+import type {
+  BenchmarkStrongInferenceTelemetry,
+  BenchmarkTelemetrySummary,
+  StrongTelemetryCoverage,
+} from './types'
+
+const addRecordCounts = (
+  target: Record<string, number>,
+  source: Record<string, number>,
+): void => {
+  for (const [key, value] of Object.entries(source)) {
+    target[key] = (target[key] ?? 0) + value
+  }
+}
+
+export const aggregateRuleUsage = (
+  records: Array<Record<string, number>>,
+): Record<string, number> => {
+  const result: Record<string, number> = {}
+  for (const record of records) addRecordCounts(result, record)
+  return result
+}
+
+export const ruleUsageFromAttempts = (
+  summary: RuleAttemptSummary,
+): Record<string, number> =>
+  Object.fromEntries(
+    Object.values(summary.rules)
+      .filter((rule) => rule.hitCount > 0)
+      .map((rule) => [rule.ruleId, rule.hitCount]),
+  )
+
+export const aggregateRuleAttemptSummaries = (
+  summaries: RuleAttemptSummary[],
+): RuleAttemptSummary => {
+  const mutable = new Map<
+    string,
+    Omit<RuleAttemptRuleSummary, 'hitRate' | 'averageDurationMs'>
+  >()
+  let totalAttemptCount = 0
+  for (const summary of summaries) {
+    totalAttemptCount += summary.totalAttemptCount
+    for (const rule of Object.values(summary.rules)) {
+      const target = mutable.get(rule.ruleId) ?? {
+        ruleId: rule.ruleId,
+        ruleName: rule.ruleName,
+        attemptCount: 0,
+        hitCount: 0,
+        missCount: 0,
+        totalDurationMs: 0,
+        hitDurationMs: 0,
+        missDurationMs: 0,
+        producedDiffCount: 0,
+      }
+      target.attemptCount += rule.attemptCount
+      target.hitCount += rule.hitCount
+      target.missCount += rule.missCount
+      target.totalDurationMs += rule.totalDurationMs
+      target.hitDurationMs += rule.hitDurationMs
+      target.missDurationMs += rule.missDurationMs
+      target.producedDiffCount += rule.producedDiffCount
+      mutable.set(rule.ruleId, target)
+    }
+  }
+  return {
+    totalAttemptCount,
+    rules: Object.fromEntries(
+      Array.from(mutable, ([ruleId, rule]) => [
+        ruleId,
+        {
+          ...rule,
+          hitRate:
+            rule.attemptCount === 0 ? 0 : rule.hitCount / rule.attemptCount,
+          averageDurationMs:
+            rule.attemptCount === 0
+              ? 0
+              : rule.totalDurationMs / rule.attemptCount,
+        },
+      ]),
+    ),
+    finalNoHitScan: null,
+  }
+}
+
+const emptyStrongTotals = (): Omit<StrongInferenceTotals, 'hitRate'> => ({
+  attemptCount: 0,
+  hitCount: 0,
+  missCount: 0,
+  timeoutCount: 0,
+  candidateCount: 0,
+  probeCount: 0,
+  trialStepCount: 0,
+  probeDurationMs: 0,
+  producedDiffCount: 0,
+})
+
+const addStrongTotals = (
+  target: Omit<StrongInferenceTotals, 'hitRate'>,
+  source: StrongInferenceTotals,
+): void => {
+  target.attemptCount += source.attemptCount
+  target.hitCount += source.hitCount
+  target.missCount += source.missCount
+  target.timeoutCount += source.timeoutCount
+  target.candidateCount += source.candidateCount
+  target.probeCount += source.probeCount
+  target.trialStepCount += source.trialStepCount
+  target.probeDurationMs += source.probeDurationMs
+  target.producedDiffCount += source.producedDiffCount
+}
+
+const snapshotStrongTotals = (
+  totals: Omit<StrongInferenceTotals, 'hitRate'>,
+): StrongInferenceTotals => ({
+  ...totals,
+  hitRate:
+    totals.attemptCount === 0 ? 0 : totals.hitCount / totals.attemptCount,
+})
+
+export const aggregateStrongInferenceSummaries = (
+  summaries: StrongInferenceSummary[],
+): StrongInferenceSummary => {
+  const totals = emptyStrongTotals()
+  const rules = new Map<string, Omit<StrongInferenceRuleSummary, 'hitRate'>>()
+  for (const summary of summaries) {
+    addStrongTotals(totals, summary.totals)
+    for (const rule of summary.rules) {
+      const target = rules.get(rule.ruleId) ?? {
+        ...emptyStrongTotals(),
+        ruleId: rule.ruleId,
+        ruleName: rule.ruleName,
+      }
+      addStrongTotals(target, rule)
+      rules.set(rule.ruleId, target)
+    }
+  }
+  return {
+    totals: snapshotStrongTotals(totals),
+    rules: Array.from(rules.values(), (rule) => ({
+      ruleId: rule.ruleId,
+      ruleName: rule.ruleName,
+      ...snapshotStrongTotals(rule),
+    })),
+  }
+}
+
+export const aggregateStrongCoverage = (
+  coverages: StrongTelemetryCoverage[],
+): StrongTelemetryCoverage => {
+  const rules = new Map<
+    string,
+    StrongTelemetryCoverage['supportedRules'][number]
+  >()
+  for (const coverage of coverages) {
+    for (const rule of [
+      ...coverage.supportedRules,
+      ...coverage.unsupportedRules,
+    ]) {
+      const existing = rules.get(rule.ruleId)
+      rules.set(rule.ruleId, {
+        ...rule,
+        supported: Boolean(existing?.supported || rule.supported),
+      })
+    }
+  }
+  const supportedRules = Array.from(rules.values()).filter(
+    (rule) => rule.supported,
+  )
+  const unsupportedRules = Array.from(rules.values()).filter(
+    (rule) => !rule.supported,
+  )
+  const status =
+    rules.size === 0
+      ? 'not-applicable'
+      : unsupportedRules.length === 0
+        ? 'full'
+        : supportedRules.length === 0
+          ? 'none'
+          : 'partial'
+  return { status, supportedRules, unsupportedRules }
+}
+
+export const aggregateTelemetrySummaries = (
+  summaries: BenchmarkTelemetrySummary[],
+): BenchmarkTelemetrySummary => ({
+  ruleAttempts: aggregateRuleAttemptSummaries(
+    summaries.map((summary) => summary.ruleAttempts),
+  ),
+  strongInference: {
+    coverage: aggregateStrongCoverage(
+      summaries.map((summary) => summary.strongInference.coverage),
+    ),
+    summary: aggregateStrongInferenceSummaries(
+      summaries.map((summary) => summary.strongInference.summary),
+    ),
+  } satisfies BenchmarkStrongInferenceTelemetry,
+})
diff --git a/src/domain/benchmark/index.ts b/src/domain/benchmark/index.ts
index 95db03e..3a5ba4c 100644
--- a/src/domain/benchmark/index.ts
+++ b/src/domain/benchmark/index.ts
@@ -1,5 +1,7 @@
 export { validateBenchmarkManifest } from './manifest'
 export { runBenchmarkItem, runBenchmarkManifest } from './runner'
+export { formatBenchmarkReportText } from './textFormatter'
+export { formatBenchmarkReportTsv, serializeTsv } from './tsvFormatter'
 export type {
   BenchmarkDatasetItem,
   BenchmarkDatasetManifest,
@@ -7,4 +9,5 @@ export type {
   BenchmarkPuzzleStatus,
   BenchmarkReport,
   BenchmarkRunnerOptions,
+  BenchmarkTelemetryLevel,
 } from './types'
diff --git a/src/domain/benchmark/runner.test.ts b/src/domain/benchmark/runner.test.ts
index 561b0c0..d633c77 100644
--- a/src/domain/benchmark/runner.test.ts
+++ b/src/domain/benchmark/runner.test.ts
@@ -16,18 +16,36 @@ describe('benchmark runner', () => {
     vi.restoreAllMocks()
   })
 
-  it('reports step-capped runs when maxSteps is reached before completion', () => {
-    const result = runBenchmarkItem(validItem, {
+  it('emits schema-v2 compact results and preserves off/summary outcomes', () => {
+    const off = runBenchmarkItem(validItem, {
       maxSteps: 1,
       timeoutMs: 60_000,
+      telemetry: 'off',
     })
-
-    expect(result.status).toBe('step-capped')
-    expect(result.stepCount).toBe(1)
-    expect(result.steps).toEqual([])
-    expect(result.ruleSteps).toEqual({
-      [Object.keys(result.ruleUsage)[0]]: [1],
+    const summary = runBenchmarkItem(validItem, {
+      maxSteps: 1,
+      timeoutMs: 60_000,
+      telemetry: 'summary',
     })
+
+    expect(summary.status).toBe(off.status)
+    expect(summary.stepCount).toBe(off.stepCount)
+    expect(summary.terminal).toEqual(off.terminal)
+    expect(summary.ruleUsage).toEqual(off.ruleUsage)
+    expect(summary).not.toHaveProperty('steps')
+    expect(summary).not.toHaveProperty('ruleSteps')
+    expect(off.telemetry).toBeUndefined()
+    expect(summary.telemetry?.ruleAttempts.totalAttemptCount).toBeGreaterThan(0)
+    expect(summary.telemetry?.strongInference.coverage.status).toBe('none')
+    expect(
+      summary.telemetry?.strongInference.coverage.unsupportedRules.map(
+        (rule) => rule.ruleId,
+      ),
+    ).toEqual([
+      'color-assumption-inference',
+      'sector-parity-inference',
+      'strong-inference',
+    ])
   })
 
   it('reports time-capped runs without crashing', () => {
@@ -36,12 +54,44 @@ describe('benchmark runner', () => {
       .mockReturnValueOnce(2)
       .mockReturnValueOnce(2)
 
-    const result = runBenchmarkItem(validItem, { maxSteps: 2000, timeoutMs: 1 })
+    const result = runBenchmarkItem(validItem, {
+      maxSteps: 2000,
+      timeoutMs: 1,
+      telemetry: 'summary',
+    })
 
     expect(result.status).toBe('time-capped')
     expect(result.stepCount).toBe(0)
   })
 
+  it('keeps collectors isolated and aggregates item summaries', () => {
+    const manifest: BenchmarkDatasetManifest = {
+      schemaVersion: 1,
+      id: 'two-items',
+      title: 'Two Items',
+      puzzleType: 'slitherlink',
+      items: [validItem, { ...validItem, id: 'second' }],
+    }
+    const report = runBenchmarkManifest(manifest, {
+      maxSteps: 1,
+      timeoutMs: 60_000,
+      telemetry: 'summary',
+    })
+    const [first, second] = report.items
+
+    expect(report.schemaVersion).toBe(2)
+    expect(Object.keys(first.telemetry?.ruleAttempts.rules ?? {})).toEqual(
+      Object.keys(second.telemetry?.ruleAttempts.rules ?? {}),
+    )
+    expect(first.telemetry?.ruleAttempts.totalAttemptCount).toBe(
+      second.telemetry?.ruleAttempts.totalAttemptCount,
+    )
+    expect(report.summary.telemetry?.ruleAttempts.totalAttemptCount).toBe(
+      (first.telemetry?.ruleAttempts.totalAttemptCount ?? 0) * 2,
+    )
+    expect(report.summary.telemetry?.ruleAttempts.finalNoHitScan).toBeNull()
+  })
+
   it('keeps running after per-item parse errors', () => {
     const manifest: BenchmarkDatasetManifest = {
       schemaVersion: 1,
@@ -61,6 +111,7 @@ describe('benchmark runner', () => {
     const report = runBenchmarkManifest(manifest, {
       maxSteps: 1,
       timeoutMs: 60_000,
+      telemetry: 'summary',
     })
 
     expect(report.summary.total).toBe(2)
diff --git a/src/domain/benchmark/runner.ts b/src/domain/benchmark/runner.ts
index 7d49701..5a64230 100644
--- a/src/domain/benchmark/runner.ts
+++ b/src/domain/benchmark/runner.ts
@@ -1,8 +1,15 @@
 import type { PuzzleIR } from '../ir/types'
 import { puzzleRegistry } from '../plugins/registry'
 import { analyzePuzzleCompletion } from '../rules/completion'
+import { composeSolverObservers } from '../rules/composeSolverObservers'
 import { runNextRule } from '../rules/engine'
-import { addRuleUsage } from '../difficulty/traceStats'
+import { createRuleAttemptSummaryCollector } from '../rules/ruleAttemptSummaryCollector'
+import { createStrongInferenceSummaryCollector } from '../rules/strongInferenceSummaryCollector'
+import {
+  aggregateRuleUsage,
+  aggregateTelemetrySummaries,
+  ruleUsageFromAttempts,
+} from './aggregation'
 import type {
   BenchmarkDatasetItem,
   BenchmarkDatasetManifest,
@@ -11,10 +18,13 @@ import type {
   BenchmarkReport,
   BenchmarkRunnerOptions,
   BenchmarkSummary,
+  BenchmarkTelemetryLevel,
 } from './types'
+import { getStrongTelemetryCoverage } from './types'
 
 const DEFAULT_MAX_STEPS = 2000
 const DEFAULT_TIMEOUT_MS = 60_000
+const DEFAULT_TELEMETRY: BenchmarkTelemetryLevel = 'summary'
 
 const normalizeLimit = (
   value: number | undefined,
@@ -26,11 +36,15 @@ const normalizeLimit = (
   return Math.max(1, Math.floor(value))
 }
 
-const getTerminal = (puzzleType: string, puzzle: PuzzleIR) => analyzePuzzleCompletion(puzzleType, puzzle)
+const getTerminal = (puzzleType: string, puzzle: PuzzleIR) =>
+  analyzePuzzleCompletion(puzzleType, puzzle)
 
 const getStatusCountKey = (
   status: BenchmarkPuzzleStatus,
-): keyof Omit<BenchmarkSummary, 'total' | 'totalDurationMs' | 'ruleUsage'> => {
+): keyof Omit<
+  BenchmarkSummary,
+  'total' | 'totalDurationMs' | 'ruleUsage' | 'telemetry'
+> => {
   if (status === 'parse-error') return 'parseError'
   if (status === 'runtime-error') return 'runtimeError'
   if (status === 'step-capped') return 'stepCapped'
@@ -40,33 +54,63 @@ const getStatusCountKey = (
 
 export const runBenchmarkItem = (
   item: BenchmarkDatasetItem,
-  options: Required<BenchmarkRunnerOptions>,
+  options: BenchmarkRunnerOptions = {},
 ): BenchmarkPuzzleResult => {
+  const maxSteps = normalizeLimit(options.maxSteps, DEFAULT_MAX_STEPS)
+  const timeoutMs = normalizeLimit(options.timeoutMs, DEFAULT_TIMEOUT_MS)
+  const telemetry = options.telemetry ?? DEFAULT_TELEMETRY
   const startedAt = performance.now()
-  const ruleUsage: Record<string, number> = {}
-  const ruleSteps: Record<string, number[]> = {}
+  const plugin = puzzleRegistry.get(item.puzzleType)
+  const ruleAttemptCollector =
+    telemetry === 'summary' ? createRuleAttemptSummaryCollector() : undefined
+  const strongInferenceCollector =
+    telemetry === 'summary'
+      ? createStrongInferenceSummaryCollector()
+      : undefined
+  const observer =
+    telemetry === 'summary'
+      ? composeSolverObservers([
+          ruleAttemptCollector?.observer,
+          strongInferenceCollector?.observer,
+        ])
+      : undefined
+  const offRuleUsage: Record<string, number> = {}
   let stepCount = 0
+
   const finish = (
     status: BenchmarkPuzzleStatus,
     terminal: BenchmarkPuzzleResult['terminal'],
     error?: string,
-  ): BenchmarkPuzzleResult => ({
-    id: item.id,
-    puzzleType: item.puzzleType,
-    sourceUrl: item.sourceUrl,
-    width: item.width,
-    height: item.height,
-    status,
-    stepCount,
-    durationMs: Math.max(0, performance.now() - startedAt),
-    ruleUsage,
-    ruleSteps,
-    terminal,
-    steps: [],
-    ...(error ? { error } : {}),
-  })
+  ): BenchmarkPuzzleResult => {
+    const ruleAttempts = ruleAttemptCollector?.getSummary()
+    const telemetry =
+      ruleAttempts && strongInferenceCollector
+        ? {
+            ruleAttempts,
+            strongInference: {
+              coverage: getStrongTelemetryCoverage(plugin?.strongTelemetry),
+              summary: strongInferenceCollector.getSummary(),
+            },
+          }
+        : undefined
+    return {
+      id: item.id,
+      puzzleType: item.puzzleType,
+      sourceUrl: item.sourceUrl,
+      width: item.width,
+      height: item.height,
+      status,
+      stepCount,
+      durationMs: Math.max(0, performance.now() - startedAt),
+      ruleUsage: ruleAttempts
+        ? ruleUsageFromAttempts(ruleAttempts)
+        : offRuleUsage,
+      terminal,
+      ...(telemetry ? { telemetry } : {}),
+      ...(error ? { error } : {}),
+    }
+  }
 
-  const plugin = puzzleRegistry.get(item.puzzleType)
   if (!plugin) {
     return finish('parse-error', null, `Plugin "${item.puzzleType}" not found.`)
   }
@@ -84,11 +128,11 @@ export const runBenchmarkItem = (
 
   const rules = plugin.getRules()
   while (true) {
-    if (performance.now() - startedAt >= options.timeoutMs) {
+    if (performance.now() - startedAt >= timeoutMs) {
       return finish('time-capped', getTerminal(item.puzzleType, puzzle))
     }
 
-    if (stepCount >= options.maxSteps) {
+    if (stepCount >= maxSteps) {
       const terminal = getTerminal(item.puzzleType, puzzle)
       return finish(
         terminal?.status === 'solved' ? 'solved' : 'step-capped',
@@ -98,7 +142,7 @@ export const runBenchmarkItem = (
 
     let result: ReturnType<typeof runNextRule>
     try {
-      result = runNextRule(puzzle, rules, stepCount + 1)
+      result = runNextRule(puzzle, rules, stepCount + 1, { observer })
     } catch (error) {
       return finish(
         'runtime-error',
@@ -114,7 +158,10 @@ export const runBenchmarkItem = (
 
     puzzle = result.nextPuzzle
     stepCount += 1
-    addRuleUsage(ruleUsage, ruleSteps, result.step, stepCount)
+    if (telemetry === 'off') {
+      offRuleUsage[result.step.ruleId] =
+        (offRuleUsage[result.step.ruleId] ?? 0) + 1
+    }
   }
 }
 
@@ -124,9 +171,10 @@ export const runBenchmarkManifest = (
 ): BenchmarkReport => {
   const maxSteps = normalizeLimit(options.maxSteps, DEFAULT_MAX_STEPS)
   const timeoutMs = normalizeLimit(options.timeoutMs, DEFAULT_TIMEOUT_MS)
+  const telemetry = options.telemetry ?? DEFAULT_TELEMETRY
   const startedAt = new Date().toISOString()
   const items = manifest.items.map((item) =>
-    runBenchmarkItem(item, { maxSteps, timeoutMs }),
+    runBenchmarkItem(item, { maxSteps, timeoutMs, telemetry }),
   )
   const summary: BenchmarkSummary = {
     total: items.length,
@@ -137,19 +185,23 @@ export const runBenchmarkManifest = (
     stepCapped: 0,
     timeCapped: 0,
     totalDurationMs: 0,
-    ruleUsage: {},
+    ruleUsage: aggregateRuleUsage(items.map((item) => item.ruleUsage)),
+    ...(telemetry === 'summary'
+      ? {
+          telemetry: aggregateTelemetrySummaries(
+            items.flatMap((item) => (item.telemetry ? [item.telemetry] : [])),
+          ),
+        }
+      : {}),
   }
 
   for (const item of items) {
     summary[getStatusCountKey(item.status)] += 1
     summary.totalDurationMs += item.durationMs
-    for (const [ruleId, count] of Object.entries(item.ruleUsage)) {
-      summary.ruleUsage[ruleId] = (summary.ruleUsage[ruleId] ?? 0) + count
-    }
   }
 
   return {
-    schemaVersion: 1,
+    schemaVersion: 2,
     run: {
       datasetId: manifest.id,
       startedAt,
@@ -157,6 +209,7 @@ export const runBenchmarkManifest = (
       maxSteps,
       timeoutMs,
       ruleProfile: 'default',
+      telemetry,
     },
     summary,
     items,
diff --git a/src/domain/benchmark/textFormatter.test.ts b/src/domain/benchmark/textFormatter.test.ts
new file mode 100644
index 0000000..427d089
--- /dev/null
+++ b/src/domain/benchmark/textFormatter.test.ts
@@ -0,0 +1,98 @@
+import { describe, expect, it } from 'vitest'
+import { formatBenchmarkReportText } from './textFormatter'
+import type { BenchmarkReport } from './types'
+
+const report: BenchmarkReport = {
+  schemaVersion: 2,
+  run: {
+    datasetId: 'sample',
+    startedAt: '2026-01-01T00:00:00.000Z',
+    completedAt: '2026-01-01T00:00:01.000Z',
+    maxSteps: 10,
+    timeoutMs: 1000,
+    ruleProfile: 'default',
+    telemetry: 'summary',
+  },
+  summary: {
+    total: 1,
+    solved: 1,
+    stalled: 0,
+    parseError: 0,
+    runtimeError: 0,
+    stepCapped: 0,
+    timeCapped: 0,
+    totalDurationMs: 10,
+    ruleUsage: { a: 1 },
+    telemetry: {
+      ruleAttempts: {
+        totalAttemptCount: 2,
+        rules: {
+          a: {
+            ruleId: 'a',
+            ruleName: 'A',
+            attemptCount: 2,
+            hitCount: 1,
+            missCount: 1,
+            hitRate: 0.5,
+            totalDurationMs: 5,
+            hitDurationMs: 3,
+            missDurationMs: 2,
+            averageDurationMs: 2.5,
+            producedDiffCount: 1,
+          },
+        },
+        finalNoHitScan: null,
+      },
+      strongInference: {
+        coverage: {
+          status: 'none',
+          supportedRules: [],
+          unsupportedRules: [
+            { ruleId: 'strong', ruleName: 'Strong', supported: false },
+          ],
+        },
+        summary: {
+          totals: {
+            attemptCount: 0,
+            hitCount: 0,
+            missCount: 0,
+            timeoutCount: 0,
+            hitRate: 0,
+            candidateCount: 0,
+            probeCount: 0,
+            trialStepCount: 0,
+            probeDurationMs: 0,
+            producedDiffCount: 0,
+          },
+          rules: [],
+        },
+      },
+    },
+  },
+  items: [
+    {
+      id: 'puzzle',
+      puzzleType: 'slitherlink',
+      sourceUrl: 'url',
+      width: 1,
+      height: 1,
+      status: 'solved',
+      stepCount: 1,
+      durationMs: 10,
+      ruleUsage: { a: 1 },
+      terminal: null,
+    },
+  ],
+}
+
+describe('benchmark text formatter', () => {
+  it('highlights status, expensive rules, and missing strong telemetry', () => {
+    const text = formatBenchmarkReportText(report)
+
+    expect(text).toContain('1 solved')
+    expect(text).toContain('Most expensive rules')
+    expect(text).toContain('Strong inference (none coverage)')
+    expect(text).toContain('Telemetry not implemented')
+    expect(text).toContain('strong (Strong)')
+  })
+})
diff --git a/src/domain/benchmark/textFormatter.ts b/src/domain/benchmark/textFormatter.ts
new file mode 100644
index 0000000..49ecd50
--- /dev/null
+++ b/src/domain/benchmark/textFormatter.ts
@@ -0,0 +1,72 @@
+import type { BenchmarkReport } from './types'
+
+const formatDuration = (durationMs: number): string =>
+  durationMs >= 1000
+    ? `${(durationMs / 1000).toFixed(2)}s`
+    : `${durationMs.toFixed(1)}ms`
+
+const formatRuleRows = (
+  report: BenchmarkReport,
+  kind: 'duration' | 'misses',
+): string[] => {
+  const rules = Object.values(
+    report.summary.telemetry?.ruleAttempts.rules ?? {},
+  )
+  const sorted = [...rules]
+    .sort((left, right) =>
+      kind === 'duration'
+        ? right.totalDurationMs - left.totalDurationMs
+        : right.missCount - left.missCount ||
+          right.missDurationMs - left.missDurationMs,
+    )
+    .slice(0, 5)
+  if (sorted.length === 0) return ['  (no rule-attempt telemetry)']
+  return sorted.map(
+    (rule) =>
+      `  ${rule.ruleId}: ${formatDuration(rule.totalDurationMs)}, ${rule.hitCount}/${rule.attemptCount} hits, ${rule.missCount} misses`,
+  )
+}
+
+export const formatBenchmarkReportText = (report: BenchmarkReport): string => {
+  const { summary } = report
+  const lines = [
+    `${report.run.datasetId} (schema v${report.schemaVersion}, telemetry ${report.run.telemetry})`,
+    `Status: ${summary.solved} solved, ${summary.stalled} stalled, ${summary.parseError} parse errors, ${summary.runtimeError} runtime errors, ${summary.stepCapped} step capped, ${summary.timeCapped} time capped`,
+    `Total: ${summary.total} puzzles, ${formatDuration(summary.totalDurationMs)}`,
+    '',
+    'Puzzles:',
+    ...report.items.map(
+      (item) =>
+        `  ${item.id}: ${item.status}, ${item.stepCount} steps, ${formatDuration(item.durationMs)}`,
+    ),
+  ]
+
+  if (!summary.telemetry) return lines.join('\n')
+
+  lines.push(
+    '',
+    'Most expensive rules:',
+    ...formatRuleRows(report, 'duration'),
+    '',
+    'Most frequently missed rules:',
+    ...formatRuleRows(report, 'misses'),
+  )
+
+  const strong = summary.telemetry.strongInference
+  const totals = strong.summary.totals
+  lines.push(
+    '',
+    `Strong inference (${strong.coverage.status} coverage): ${totals.attemptCount} attempts, ${totals.hitCount} hits, ${totals.missCount} misses, ${totals.timeoutCount} timeouts`,
+    `  ${totals.probeCount} probes, ${totals.trialStepCount} trial steps, ${formatDuration(totals.probeDurationMs)} probe time`,
+  )
+  if (strong.coverage.unsupportedRules.length > 0) {
+    lines.push(
+      '  Telemetry not implemented:',
+      ...strong.coverage.unsupportedRules.map(
+        (rule) => `    ${rule.ruleId} (${rule.ruleName})`,
+      ),
+    )
+  }
+
+  return lines.join('\n')
+}
diff --git a/src/domain/benchmark/tsvFormatter.test.ts b/src/domain/benchmark/tsvFormatter.test.ts
new file mode 100644
index 0000000..690048f
--- /dev/null
+++ b/src/domain/benchmark/tsvFormatter.test.ts
@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest'
+import { runBenchmarkManifest } from './runner'
+import { formatBenchmarkReportTsv, serializeTsv } from './tsvFormatter'
+import type { BenchmarkDatasetManifest } from './types'
+
+const manifest: BenchmarkDatasetManifest = {
+  schemaVersion: 1,
+  id: 'sample',
+  title: 'Sample',
+  puzzleType: 'slitherlink',
+  items: [
+    {
+      id: 'slitherlink-3x3-0001',
+      puzzleType: 'slitherlink',
+      sourceUrl: 'https://puzz.link/p?slither/3/3/g0h',
+      width: 3,
+      height: 3,
+      tags: [],
+    },
+  ],
+}
+
+describe('benchmark TSV formatter', () => {
+  it('serializes stable columns, empty values, booleans, tabs, and newlines', () => {
+    expect(
+      serializeTsv(
+        ['a', 'b', 'c', 'd'],
+        [
+          {
+            a: true,
+            b: null,
+            c: 'tab\tand\n"quoted" line',
+            d: 1.23456789,
+          },
+        ],
+      ),
+    ).toBe('a\tb\tc\td\ntrue\t\ttab and "quoted" line\t1.234568\n')
+  })
+
+  it('builds puzzle and long rule tables with unattempted rules', () => {
+    const report = runBenchmarkManifest(manifest, {
+      maxSteps: 1,
+      telemetry: 'summary',
+    })
+    const tables = formatBenchmarkReportTsv(report)
+    const puzzleLines = tables.puzzles.trimEnd().split('\n')
+    const ruleLines = tables.ruleAttempts!.trimEnd().split('\n')
+    const strongLines = tables.strongInference!.trimEnd().split('\n')
+
+    expect(puzzleLines).toHaveLength(2)
+    expect(puzzleLines[0]).toContain('strong_coverage')
+    expect(
+      ruleLines.some((line) => line.includes('\tfalse\t0\t0\t0\t0\t')),
+    ).toBe(true)
+    expect(strongLines).toHaveLength(4)
+    expect(strongLines[1]).toContain('\tfalse\t\t\t\t\t\t\t')
+  })
+
+  it('only builds the puzzle table when telemetry is off', () => {
+    const report = runBenchmarkManifest(manifest, {
+      maxSteps: 1,
+      telemetry: 'off',
+    })
+    const tables = formatBenchmarkReportTsv(report)
+
+    expect(tables.ruleAttempts).toBeUndefined()
+    expect(tables.strongInference).toBeUndefined()
+    expect(tables.puzzles.split('\n')[1]).toContain('\toff\t')
+  })
+})
diff --git a/src/domain/benchmark/tsvFormatter.ts b/src/domain/benchmark/tsvFormatter.ts
new file mode 100644
index 0000000..b0b13c9
--- /dev/null
+++ b/src/domain/benchmark/tsvFormatter.ts
@@ -0,0 +1,293 @@
+import { puzzleRegistry } from '../plugins/registry'
+import type { RuleAttemptRuleSummary } from '../rules/ruleAttemptSummaryCollector'
+import type { StrongInferenceRuleSummary } from '../rules/strongInferenceSummaryCollector'
+import type { BenchmarkPuzzleResult, BenchmarkReport } from './types'
+
+type TsvValue = string | number | boolean | null | undefined
+type TsvRow = Record<string, TsvValue>
+
+export type BenchmarkTsvTables = {
+  puzzles: string
+  ruleAttempts?: string
+  strongInference?: string
+}
+
+const PUZZLE_HEADERS = [
+  'dataset_id',
+  'run_started_at',
+  'puzzle_id',
+  'puzzle_type',
+  'source_url',
+  'width',
+  'height',
+  'status',
+  'solved',
+  'step_count',
+  'duration_ms',
+  'terminal_status',
+  'terminal_decided_ratio',
+  'terminal_unknown_units',
+  'error',
+  'telemetry_level',
+  'total_rule_attempts',
+  'total_rule_hits',
+  'total_rule_misses',
+  'total_rule_duration_ms',
+  'final_no_hit_scan_attempts',
+  'final_no_hit_scan_duration_ms',
+  'strong_coverage',
+  'strong_attempts',
+  'strong_hits',
+  'strong_misses',
+  'strong_timeouts',
+  'strong_candidates',
+  'strong_probes',
+  'strong_trial_steps',
+  'strong_probe_duration_ms',
+  'strong_produced_diffs',
+] as const
+
+const RULE_ATTEMPT_HEADERS = [
+  'dataset_id',
+  'puzzle_id',
+  'puzzle_type',
+  'puzzle_status',
+  'rule_id',
+  'rule_name',
+  'attempted',
+  'attempt_count',
+  'hit_count',
+  'miss_count',
+  'hit_rate',
+  'total_duration_ms',
+  'hit_duration_ms',
+  'miss_duration_ms',
+  'average_duration_ms',
+  'produced_diff_count',
+] as const
+
+const STRONG_INFERENCE_HEADERS = [
+  'dataset_id',
+  'puzzle_id',
+  'puzzle_type',
+  'puzzle_status',
+  'coverage_status',
+  'rule_id',
+  'rule_name',
+  'telemetry_supported',
+  'attempted',
+  'attempt_count',
+  'hit_count',
+  'miss_count',
+  'timeout_count',
+  'hit_rate',
+  'candidate_count',
+  'probe_count',
+  'trial_step_count',
+  'probe_duration_ms',
+  'produced_diff_count',
+] as const
+
+const serializeTsvValue = (value: TsvValue): string => {
+  if (value === null || value === undefined) return ''
+  if (typeof value === 'number' && !Number.isInteger(value)) {
+    return String(Number(value.toFixed(6)))
+  }
+  return String(value).replaceAll('\t', ' ').replaceAll(/\r?\n/g, ' ')
+}
+
+export const serializeTsv = (
+  headers: readonly string[],
+  rows: TsvRow[],
+): string =>
+  [
+    headers.join('\t'),
+    ...rows.map((row) =>
+      headers.map((header) => serializeTsvValue(row[header])).join('\t'),
+    ),
+  ].join('\n') + '\n'
+
+const sumRuleMetric = (
+  item: BenchmarkPuzzleResult,
+  metric: keyof Pick<
+    RuleAttemptRuleSummary,
+    'hitCount' | 'missCount' | 'totalDurationMs'
+  >,
+): number | undefined => {
+  if (!item.telemetry) return undefined
+  return Object.values(item.telemetry.ruleAttempts.rules).reduce(
+    (total, rule) => total + rule[metric],
+    0,
+  )
+}
+
+const buildPuzzleRow = (
+  report: BenchmarkReport,
+  item: BenchmarkPuzzleResult,
+): TsvRow => {
+  const strong = item.telemetry?.strongInference
+  const strongTotals = strong?.summary.totals
+  const finalScan = item.telemetry?.ruleAttempts.finalNoHitScan
+  return {
+    dataset_id: report.run.datasetId,
+    run_started_at: report.run.startedAt,
+    puzzle_id: item.id,
+    puzzle_type: item.puzzleType,
+    source_url: item.sourceUrl,
+    width: item.width,
+    height: item.height,
+    status: item.status,
+    solved: item.status === 'solved',
+    step_count: item.stepCount,
+    duration_ms: item.durationMs,
+    terminal_status: item.terminal?.status,
+    terminal_decided_ratio: item.terminal?.stats.decidedRatio,
+    terminal_unknown_units: item.terminal?.stats.unknownUnits,
+    error: item.error,
+    telemetry_level: report.run.telemetry,
+    total_rule_attempts: item.telemetry?.ruleAttempts.totalAttemptCount,
+    total_rule_hits: sumRuleMetric(item, 'hitCount'),
+    total_rule_misses: sumRuleMetric(item, 'missCount'),
+    total_rule_duration_ms: sumRuleMetric(item, 'totalDurationMs'),
+    final_no_hit_scan_attempts: finalScan?.attemptCount,
+    final_no_hit_scan_duration_ms: finalScan?.totalDurationMs,
+    strong_coverage: strong?.coverage.status,
+    strong_attempts: strongTotals?.attemptCount,
+    strong_hits: strongTotals?.hitCount,
+    strong_misses: strongTotals?.missCount,
+    strong_timeouts: strongTotals?.timeoutCount,
+    strong_candidates: strongTotals?.candidateCount,
+    strong_probes: strongTotals?.probeCount,
+    strong_trial_steps: strongTotals?.trialStepCount,
+    strong_probe_duration_ms: strongTotals?.probeDurationMs,
+    strong_produced_diffs: strongTotals?.producedDiffCount,
+  }
+}
+
+const emptyRuleSummary = (
+  ruleId: string,
+  ruleName: string,
+): RuleAttemptRuleSummary => ({
+  ruleId,
+  ruleName,
+  attemptCount: 0,
+  hitCount: 0,
+  missCount: 0,
+  hitRate: 0,
+  totalDurationMs: 0,
+  hitDurationMs: 0,
+  missDurationMs: 0,
+  averageDurationMs: 0,
+  producedDiffCount: 0,
+})
+
+const buildRuleAttemptRows = (
+  report: BenchmarkReport,
+  item: BenchmarkPuzzleResult,
+): TsvRow[] => {
+  if (!item.telemetry) return []
+  const pluginRules = puzzleRegistry.get(item.puzzleType)?.getRules() ?? []
+  const observedRules = item.telemetry.ruleAttempts.rules
+  const ruleOrder = new Map(pluginRules.map((rule, index) => [rule.id, index]))
+  const rules = new Map(
+    pluginRules.map((rule) => [
+      rule.id,
+      observedRules[rule.id] ?? emptyRuleSummary(rule.id, rule.name),
+    ]),
+  )
+  for (const rule of Object.values(observedRules)) {
+    if (!rules.has(rule.ruleId)) rules.set(rule.ruleId, rule)
+  }
+
+  return Array.from(rules.values())
+    .sort(
+      (left, right) =>
+        (ruleOrder.get(left.ruleId) ?? Number.MAX_SAFE_INTEGER) -
+          (ruleOrder.get(right.ruleId) ?? Number.MAX_SAFE_INTEGER) ||
+        left.ruleId.localeCompare(right.ruleId),
+    )
+    .map((rule) => ({
+      dataset_id: report.run.datasetId,
+      puzzle_id: item.id,
+      puzzle_type: item.puzzleType,
+      puzzle_status: item.status,
+      rule_id: rule.ruleId,
+      rule_name: rule.ruleName,
+      attempted: rule.attemptCount > 0,
+      attempt_count: rule.attemptCount,
+      hit_count: rule.hitCount,
+      miss_count: rule.missCount,
+      hit_rate: rule.hitRate,
+      total_duration_ms: rule.totalDurationMs,
+      hit_duration_ms: rule.hitDurationMs,
+      miss_duration_ms: rule.missDurationMs,
+      average_duration_ms: rule.averageDurationMs,
+      produced_diff_count: rule.producedDiffCount,
+    }))
+}
+
+const buildStrongInferenceRows = (
+  report: BenchmarkReport,
+  item: BenchmarkPuzzleResult,
+): TsvRow[] => {
+  const strong = item.telemetry?.strongInference
+  if (!strong) return []
+  const observed = new Map(
+    strong.summary.rules.map((rule) => [rule.ruleId, rule]),
+  )
+  const declaredRules = [
+    ...strong.coverage.supportedRules,
+    ...strong.coverage.unsupportedRules,
+  ]
+  return declaredRules.map((declared) => {
+    const rule: StrongInferenceRuleSummary | undefined = observed.get(
+      declared.ruleId,
+    )
+    const supported = declared.supported
+    return {
+      dataset_id: report.run.datasetId,
+      puzzle_id: item.id,
+      puzzle_type: item.puzzleType,
+      puzzle_status: item.status,
+      coverage_status: strong.coverage.status,
+      rule_id: declared.ruleId,
+      rule_name: declared.ruleName,
+      telemetry_supported: supported,
+      attempted: supported ? (rule?.attemptCount ?? 0) > 0 : undefined,
+      attempt_count: supported ? (rule?.attemptCount ?? 0) : undefined,
+      hit_count: supported ? (rule?.hitCount ?? 0) : undefined,
+      miss_count: supported ? (rule?.missCount ?? 0) : undefined,
+      timeout_count: supported ? (rule?.timeoutCount ?? 0) : undefined,
+      hit_rate: supported ? (rule?.hitRate ?? 0) : undefined,
+      candidate_count: supported ? (rule?.candidateCount ?? 0) : undefined,
+      probe_count: supported ? (rule?.probeCount ?? 0) : undefined,
+      trial_step_count: supported ? (rule?.trialStepCount ?? 0) : undefined,
+      probe_duration_ms: supported ? (rule?.probeDurationMs ?? 0) : undefined,
+      produced_diff_count: supported
+        ? (rule?.producedDiffCount ?? 0)
+        : undefined,
+    }
+  })
+}
+
+export const formatBenchmarkReportTsv = (
+  report: BenchmarkReport,
+): BenchmarkTsvTables => {
+  const puzzles = serializeTsv(
+    PUZZLE_HEADERS,
+    report.items.map((item) => buildPuzzleRow(report, item)),
+  )
+  if (report.run.telemetry === 'off') return { puzzles }
+
+  return {
+    puzzles,
+    ruleAttempts: serializeTsv(
+      RULE_ATTEMPT_HEADERS,
+      report.items.flatMap((item) => buildRuleAttemptRows(report, item)),
+    ),
+    strongInference: serializeTsv(
+      STRONG_INFERENCE_HEADERS,
+      report.items.flatMap((item) => buildStrongInferenceRows(report, item)),
+    ),
+  }
+}
diff --git a/src/domain/benchmark/types.ts b/src/domain/benchmark/types.ts
index de662ce..2a3975e 100644
--- a/src/domain/benchmark/types.ts
+++ b/src/domain/benchmark/types.ts
@@ -1,4 +1,10 @@
+import type {
+  PuzzleStrongTelemetryConfig,
+  StrongTelemetryRule,
+} from '../plugins/types'
 import type { CompletionReport } from '../rules/completion'
+import type { RuleAttemptSummary } from '../rules/ruleAttemptSummaryCollector'
+import type { StrongInferenceSummary } from '../rules/strongInferenceSummaryCollector'
 
 export type BenchmarkDatasetItem = {
   id: string
@@ -26,6 +32,30 @@ export type BenchmarkPuzzleStatus =
   | 'step-capped'
   | 'time-capped'
 
+export type BenchmarkTelemetryLevel = 'off' | 'summary'
+
+export type StrongTelemetryCoverageStatus =
+  | 'full'
+  | 'partial'
+  | 'none'
+  | 'not-applicable'
+
+export type StrongTelemetryCoverage = {
+  status: StrongTelemetryCoverageStatus
+  supportedRules: StrongTelemetryRule[]
+  unsupportedRules: StrongTelemetryRule[]
+}
+
+export type BenchmarkStrongInferenceTelemetry = {
+  coverage: StrongTelemetryCoverage
+  summary: StrongInferenceSummary
+}
+
+export type BenchmarkTelemetrySummary = {
+  ruleAttempts: RuleAttemptSummary
+  strongInference: BenchmarkStrongInferenceTelemetry
+}
+
 export type BenchmarkPuzzleResult = {
   id: string
   puzzleType: string
@@ -36,9 +66,8 @@ export type BenchmarkPuzzleResult = {
   stepCount: number
   durationMs: number
   ruleUsage: Record<string, number>
-  ruleSteps: Record<string, number[]>
   terminal: CompletionReport | null
-  steps: []
+  telemetry?: BenchmarkTelemetrySummary
   error?: string
 }
 
@@ -49,6 +78,7 @@ export type BenchmarkRunConfig = {
   maxSteps: number
   timeoutMs: number
   ruleProfile: 'default'
+  telemetry: BenchmarkTelemetryLevel
 }
 
 export type BenchmarkSummary = {
@@ -61,10 +91,11 @@ export type BenchmarkSummary = {
   timeCapped: number
   totalDurationMs: number
   ruleUsage: Record<string, number>
+  telemetry?: BenchmarkTelemetrySummary
 }
 
 export type BenchmarkReport = {
-  schemaVersion: 1
+  schemaVersion: 2
   run: BenchmarkRunConfig
   summary: BenchmarkSummary
   items: BenchmarkPuzzleResult[]
@@ -73,4 +104,23 @@ export type BenchmarkReport = {
 export type BenchmarkRunnerOptions = {
   maxSteps?: number
   timeoutMs?: number
+  telemetry?: BenchmarkTelemetryLevel
+}
+
+export const getStrongTelemetryCoverage = (
+  config: PuzzleStrongTelemetryConfig | undefined,
+): StrongTelemetryCoverage => {
+  const rules = config?.rules ?? []
+  const supportedRules = rules.filter((rule) => rule.supported)
+  const unsupportedRules = rules.filter((rule) => !rule.supported)
+  const status: StrongTelemetryCoverageStatus =
+    rules.length === 0
+      ? 'not-applicable'
+      : unsupportedRules.length === 0
+        ? 'full'
+        : supportedRules.length === 0
+          ? 'none'
+          : 'partial'
+
+  return { status, supportedRules, unsupportedRules }
 }
diff --git a/src/domain/plugins/masyuPlugin.ts b/src/domain/plugins/masyuPlugin.ts
index 55564d1..a861b8c 100644
--- a/src/domain/plugins/masyuPlugin.ts
+++ b/src/domain/plugins/masyuPlugin.ts
@@ -55,20 +55,90 @@ const masyuLegend: PuzzleLegendContent = {
   title: 'Masyu Legend',
   items: [
     {
-      label: 'Pearls',
-      description: 'White and black pearls are shown in the centers of cells.',
+      label: 'Black & White',
+      description:
+        'White pearls go straight through; black pearls turn and continue straight after the turn.',
       example: {
         rows: 3,
         cols: 3,
+        pearls: [
+          { row: 1, col: 0, color: 'white' },
+          { row: 2, col: 2, color: 'black' },
+        ],
+        lines: [
+          { edge: [[0, 0], [1, 0]], mark: 'line' },
+          { edge: [[1, 0], [2, 0]], mark: 'line' },
+          { edge: [[2, 1], [2, 2]], mark: 'line' },
+          { edge: [[2, 0], [2, 1]], mark: 'line' },
+          { edge: [[1, 2], [2, 2]], mark: 'line' },
+          { edge: [[0, 2], [1, 2]], mark: 'line' },
+        ],
       },
     },
     {
-      label: 'Lines and Crosses',
+      label: 'Cross & Line',
       description:
-        'Lines connect cell centers. Crosses mark center connections that cannot be used.',
+        'Player marks draw center lines and cross out center connections that cannot be used.',
+      example: {
+        rows: 3,
+        cols: 3,
+        pearls: [{ row: 1, col: 1, color: 'white' }],
+        lines: [
+          { edge: [[0, 1], [1, 1]], mark: 'line' },
+          { edge: [[1, 1], [2, 1]], mark: 'line' },
+          { edge: [[1, 0], [1, 1]], mark: 'blank' },
+          { edge: [[1, 1], [1, 2]], mark: 'blank' },
+        ],
+      },
+    },
+    {
+      label: 'Green Tile',
+      description: 'Green tiles mark the inside of the final loop.',
+      example: {
+        rows: 3,
+        cols: 3,
+        filledTiles: [
+          { row: 1, col: 1, fill: 'green' },
+          { row: 1, col: 2, fill: 'green' },
+          { row: 2, col: 1, fill: 'green' },
+          { row: 2, col: 2, fill: 'green' },
+        ],
+        lines: [
+          { edge: [[0, 0], [0, 1]], mark: 'line' },
+          { edge: [[0, 1], [0, 2]], mark: 'line' },
+          { edge: [[0, 2], [1, 2]], mark: 'line' },
+          { edge: [[1, 2], [2, 2]], mark: 'line' },
+          { edge: [[2, 2], [2, 1]], mark: 'line' },
+          { edge: [[2, 1], [2, 0]], mark: 'line' },
+          { edge: [[2, 0], [1, 0]], mark: 'line' },
+          { edge: [[1, 0], [0, 0]], mark: 'line' },
+        ],
+      },
+    },
+    {
+      label: 'Yellow Tile',
+      description: 'Yellow tiles mark the outside of the final loop.',
       example: {
         rows: 3,
         cols: 3,
+        filledTiles: [
+          { row: 0, col: 1, fill: 'yellow' },
+          { row: 0, col: 2, fill: 'yellow' },
+          { row: 1, col: 0, fill: 'yellow' },
+          { row: 2, col: 0, fill: 'yellow' },
+          { row: 3, col: 1, fill: 'yellow' },
+          { row: 3, col: 2, fill: 'yellow' },
+        ],
+        lines: [
+          { edge: [[0, 0], [0, 1]], mark: 'line' },
+          { edge: [[0, 1], [0, 2]], mark: 'line' },
+          { edge: [[0, 2], [1, 2]], mark: 'line' },
+          { edge: [[1, 2], [2, 2]], mark: 'line' },
+          { edge: [[2, 2], [2, 1]], mark: 'line' },
+          { edge: [[2, 1], [2, 0]], mark: 'line' },
+          { edge: [[2, 0], [1, 0]], mark: 'line' },
+          { edge: [[1, 0], [0, 0]], mark: 'line' },
+        ],
       },
     },
   ],
@@ -127,6 +197,25 @@ export const getMasyuStats = (puzzle: PuzzleIR): PuzzleStatsContent => {
 export const masyuPlugin: PuzzlePlugin = {
   id: 'masyu',
   displayName: 'Masyu',
+  strongTelemetry: {
+    rules: [
+      {
+        ruleId: 'masyu-black-pearl-strong-inference',
+        ruleName: 'Black Pearl Strong Inference',
+        supported: true,
+      },
+      {
+        ruleId: 'masyu-line-component-endpoint-strong-inference',
+        ruleName: 'Masyu Line Component Endpoint Strong Inference',
+        supported: true,
+      },
+      {
+        ruleId: 'masyu-white-pearl-strong-inference',
+        ruleName: 'White Pearl Strong Inference',
+        supported: true,
+      },
+    ],
+  },
   liveStats: {
     coverageTitle: 'Inference Coverage',
     coverageDescription: 'Decided or colored Masyu state',
@@ -139,7 +228,11 @@ export const masyuPlugin: PuzzlePlugin = {
   legend: masyuLegend,
   displayOptions: [
     { id: 'showTiles', label: 'Show Tiles', enabledByDefault: true },
-    { id: 'showLineCrosses', label: 'Show Line Crosses', enabledByDefault: true },
+    {
+      id: 'showLineCrosses',
+      label: 'Show Line Crosses',
+      enabledByDefault: true,
+    },
     { id: 'showHighlights', label: 'Show Highlights', enabledByDefault: true },
     { id: 'showGridLabels', label: 'Show Grid Labels', enabledByDefault: true },
     { id: 'showGrid', label: 'Show Grid', enabledByDefault: true },
diff --git a/src/domain/plugins/slitherPlugin.ts b/src/domain/plugins/slitherPlugin.ts
index 0ed0001..5c43efb 100644
--- a/src/domain/plugins/slitherPlugin.ts
+++ b/src/domain/plugins/slitherPlugin.ts
@@ -261,6 +261,25 @@ export const getSlitherStats = (puzzle: PuzzleIR): PuzzleStatsContent => {
 export const slitherPlugin: PuzzlePlugin = {
   id: 'slitherlink',
   displayName: 'Slitherlink',
+  strongTelemetry: {
+    rules: [
+      {
+        ruleId: 'color-assumption-inference',
+        ruleName: 'Color Assumption Inference',
+        supported: false,
+      },
+      {
+        ruleId: 'sector-parity-inference',
+        ruleName: 'Sector Parity Inference',
+        supported: false,
+      },
+      {
+        ruleId: 'strong-inference',
+        ruleName: 'Strong Inference',
+        supported: false,
+      },
+    ],
+  },
   liveStats: {
     coverageTitle: 'Inference Coverage',
     coverageDescription: 'Decided or narrowed Slitherlink state',
diff --git a/src/domain/plugins/types.ts b/src/domain/plugins/types.ts
index 0677cac..926baf0 100644
--- a/src/domain/plugins/types.ts
+++ b/src/domain/plugins/types.ts
@@ -27,7 +27,10 @@ export type PuzzleLegendExample = {
   cols: number
   clues?: Array<{ row: number; col: number; value: number | '?' }>
   edges?: PuzzleHelpExampleEdge[]
+  lines?: PuzzleHelpExampleEdge[]
+  pearls?: Array<{ row: number; col: number; color: 'white' | 'black' }>
   filledCells?: Array<{ row: number; col: number; fill: 'green' | 'yellow' }>
+  filledTiles?: Array<{ row: number; col: number; fill: 'green' | 'yellow' }>
   sectors?: PuzzleLegendSectorMarker[]
 }
 
@@ -98,6 +101,16 @@ export type PuzzleLiveStatsConfig = {
   coverageSeries: LiveStatsCoverageSeries[]
 }
 
+export type StrongTelemetryRule = {
+  ruleId: string
+  ruleName: string
+  supported: boolean
+}
+
+export type PuzzleStrongTelemetryConfig = {
+  rules: StrongTelemetryRule[]
+}
+
 export interface PuzzlePlugin {
   id: string
   displayName: string
@@ -105,6 +118,7 @@ export interface PuzzlePlugin {
   legend?: PuzzleLegendContent
   displayOptions?: PuzzleDisplayOption[]
   liveStats?: PuzzleLiveStatsConfig
+  strongTelemetry?: PuzzleStrongTelemetryConfig
   getStats?: (puzzle: PuzzleIR) => PuzzleStatsContent | null
   parse: (input: string) => PuzzleIR
   encode: (puzzle: PuzzleIR) => string
diff --git a/src/domain/rules/composeSolverObservers.test.ts b/src/domain/rules/composeSolverObservers.test.ts
new file mode 100644
index 0000000..a086003
--- /dev/null
+++ b/src/domain/rules/composeSolverObservers.test.ts
@@ -0,0 +1,66 @@
+import { describe, expect, it, vi } from 'vitest'
+import { composeSolverObservers } from './composeSolverObservers'
+import type { RuleAttemptEvent, StrongInferenceCompletedEvent } from './types'
+
+const ruleAttempt: RuleAttemptEvent = {
+  solverStepNumber: 1,
+  ruleId: 'rule-a',
+  ruleName: 'Rule A',
+  durationMs: 2,
+  hit: true,
+  producedDiffCount: 1,
+}
+
+const strongInference: StrongInferenceCompletedEvent = {
+  solverStepNumber: 1,
+  ruleId: 'rule-a',
+  ruleName: 'Rule A',
+  candidateCount: 1,
+  probeCount: 2,
+  trialStepCount: 3,
+  probeDurationMs: 4,
+  outcome: 'hit',
+  producedDiffCount: 1,
+}
+
+describe('compose solver observers', () => {
+  it('fans out events in registration order', () => {
+    const calls: string[] = []
+    const observer = composeSolverObservers([
+      {
+        onRuleAttemptCompleted: () => calls.push('first-rule'),
+        onStrongInferenceCompleted: () => calls.push('first-strong'),
+      },
+      undefined,
+      {
+        onRuleAttemptCompleted: () => calls.push('second-rule'),
+        onStrongInferenceCompleted: () => calls.push('second-strong'),
+      },
+    ])
+
+    observer.onRuleAttemptCompleted?.(ruleAttempt)
+    observer.onStrongInferenceCompleted?.(strongInference)
+
+    expect(calls).toEqual([
+      'first-rule',
+      'second-rule',
+      'first-strong',
+      'second-strong',
+    ])
+  })
+
+  it('isolates observer failures', () => {
+    const laterObserver = vi.fn()
+    const observer = composeSolverObservers([
+      {
+        onRuleAttemptCompleted: () => {
+          throw new Error('collector failed')
+        },
+      },
+      { onRuleAttemptCompleted: laterObserver },
+    ])
+
+    expect(() => observer.onRuleAttemptCompleted?.(ruleAttempt)).not.toThrow()
+    expect(laterObserver).toHaveBeenCalledWith(ruleAttempt)
+  })
+})
diff --git a/src/domain/rules/composeSolverObservers.ts b/src/domain/rules/composeSolverObservers.ts
new file mode 100644
index 0000000..09af76e
--- /dev/null
+++ b/src/domain/rules/composeSolverObservers.ts
@@ -0,0 +1,30 @@
+import type { SolverObserver } from './types'
+
+export const composeSolverObservers = (
+  observers: Array<SolverObserver | undefined>,
+): SolverObserver => {
+  const activeObservers = observers.filter(
+    (observer): observer is SolverObserver => observer !== undefined,
+  )
+
+  return {
+    onRuleAttemptCompleted: (event) => {
+      for (const observer of activeObservers) {
+        try {
+          observer.onRuleAttemptCompleted?.(event)
+        } catch {
+          // Observability must never affect solver behavior.
+        }
+      }
+    },
+    onStrongInferenceCompleted: (event) => {
+      for (const observer of activeObservers) {
+        try {
+          observer.onStrongInferenceCompleted?.(event)
+        } catch {
+          // Observability must never affect solver behavior.
+        }
+      }
+    },
+  }
+}
diff --git a/src/domain/rules/engine.test.ts b/src/domain/rules/engine.test.ts
index 29710e5..113c9ea 100644
--- a/src/domain/rules/engine.test.ts
+++ b/src/domain/rules/engine.test.ts
@@ -1,12 +1,16 @@
-import { describe, expect, it } from 'vitest'
+import { afterEach, describe, expect, it, vi } from 'vitest'
 import { decodeSlitherFromPuzzlink } from '../parsers/puzzlink'
 import { tileKey, vertexKey } from '../ir/keys'
 import { createMasyuPuzzle } from '../ir/masyu'
 import { applyRuleDiffs, revertRuleDiffs, runNextRule } from './engine'
 import { slitherRules } from './slither/rules'
-import type { Rule, RuleDiff } from './types'
+import type { Rule, RuleAttemptEvent, RuleDiff, SolverObserver } from './types'
 
 describe('rule engine', () => {
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
   it('finds at least one step for simple zero clue puzzle', () => {
     const puzzle = decodeSlitherFromPuzzlink(
       'https://puzz.link/p?slither/3/3/g0h',
@@ -58,6 +62,149 @@ describe('rule engine', () => {
     ])
   })
 
+  it('provides the step number and observer through the runtime context', () => {
+    const puzzle = createMasyuPuzzle(1, 2)
+    const observer: SolverObserver = {}
+    const seen: Array<{
+      solverStepNumber: number | undefined
+      observer: SolverObserver | undefined
+    }> = []
+    const rules: Rule[] = [
+      {
+        id: 'context',
+        name: 'Context',
+        apply: (_puzzle, runtimeContext) => {
+          seen.push({
+            solverStepNumber: runtimeContext?.solverStepNumber,
+            observer: runtimeContext?.observer,
+          })
+          return null
+        },
+      },
+    ]
+
+    runNextRule(puzzle, rules, 17, { observer })
+
+    expect(seen).toEqual([{ solverStepNumber: 17, observer }])
+  })
+
+  it('reports ordered miss and hit rule attempts through an optional observer', () => {
+    vi.spyOn(performance, 'now')
+      .mockReturnValueOnce(0)
+      .mockReturnValueOnce(1)
+      .mockReturnValueOnce(3)
+      .mockReturnValueOnce(5)
+      .mockReturnValueOnce(8)
+      .mockReturnValueOnce(10)
+
+    const puzzle = createMasyuPuzzle(1, 2)
+    const line = Object.keys(puzzle.lines)[0]
+    const events: RuleAttemptEvent[] = []
+    const rules: Rule[] = [
+      { id: 'miss', name: 'Miss', apply: () => null },
+      {
+        id: 'hit',
+        name: 'Hit',
+        apply: () => ({
+          message: 'hit',
+          diffs: [{ kind: 'line', lineKey: line, from: 'unknown', to: 'line' }],
+          affectedCells: [],
+        }),
+      },
+    ]
+
+    const result = runNextRule(puzzle, rules, 7, {
+      observer: {
+        onRuleAttemptCompleted: (event) => events.push(event),
+      },
+    })
+
+    expect(result.step?.ruleId).toBe('hit')
+    expect(events).toEqual([
+      {
+        solverStepNumber: 7,
+        ruleId: 'miss',
+        ruleName: 'Miss',
+        hit: false,
+        durationMs: 2,
+        producedDiffCount: 0,
+      },
+      {
+        solverStepNumber: 7,
+        ruleId: 'hit',
+        ruleName: 'Hit',
+        hit: true,
+        durationMs: 3,
+        producedDiffCount: 1,
+      },
+    ])
+  })
+
+  it('reports every rule in a final no-hit scan', () => {
+    const puzzle = createMasyuPuzzle(1, 2)
+    const events: RuleAttemptEvent[] = []
+    const rules: Rule[] = [
+      { id: 'miss-null', name: 'Miss Null', apply: () => null },
+      {
+        id: 'miss-empty',
+        name: 'Miss Empty',
+        apply: () => ({
+          message: 'empty',
+          diffs: [],
+          affectedCells: [],
+        }),
+      },
+    ]
+
+    const result = runNextRule(puzzle, rules, 9, {
+      observer: {
+        onRuleAttemptCompleted: (event) => events.push(event),
+      },
+    })
+
+    expect(result).toEqual({ nextPuzzle: puzzle, step: null })
+    expect(
+      events.map(({ ruleId, hit, producedDiffCount }) => ({
+        ruleId,
+        hit,
+        producedDiffCount,
+      })),
+    ).toEqual([
+      { ruleId: 'miss-null', hit: false, producedDiffCount: 0 },
+      { ruleId: 'miss-empty', hit: false, producedDiffCount: 0 },
+    ])
+  })
+
+  it('isolates observer callback errors from solver behavior', () => {
+    const puzzle = createMasyuPuzzle(1, 2)
+    const line = Object.keys(puzzle.lines)[0]
+    const rules: Rule[] = [
+      { id: 'miss', name: 'Miss', apply: () => null },
+      {
+        id: 'hit',
+        name: 'Hit',
+        apply: () => ({
+          message: 'hit',
+          diffs: [{ kind: 'line', lineKey: line, from: 'unknown', to: 'line' }],
+          affectedCells: [],
+        }),
+      },
+    ]
+
+    const baseline = runNextRule(puzzle, rules, 1)
+    const observed = runNextRule(puzzle, rules, 1, {
+      observer: {
+        onRuleAttemptCompleted: () => {
+          throw new Error('observer failed')
+        },
+      },
+    })
+
+    expect(observed.step?.ruleId).toBe(baseline.step?.ruleId)
+    expect(observed.step?.diffs).toEqual(baseline.step?.diffs)
+    expect(observed.nextPuzzle).toEqual(baseline.nextPuzzle)
+  })
+
   it('applies and reverts diffs without mutating input puzzle', () => {
     const puzzle = decodeSlitherFromPuzzlink(
       'https://puzz.link/p?slither/3/3/g0h',
diff --git a/src/domain/rules/engine.ts b/src/domain/rules/engine.ts
index 3763260..7c67bd4 100644
--- a/src/domain/rules/engine.ts
+++ b/src/domain/rules/engine.ts
@@ -2,9 +2,12 @@ import type { PuzzleIR } from '../ir/types'
 import type {
   Rule,
   RuleAttempt,
+  RuleAttemptEvent,
   RuleDiff,
+  RunNextRuleOptions,
   RuleRuntimeContext,
   RuleStep,
+  StrongInferenceCompletedEvent,
 } from './types'
 
 type WritableBuckets = {
@@ -157,14 +160,42 @@ export const rewindPuzzleByStep = (
   return revertRuleDiffs(puzzle, step.diffs)
 }
 
+const notifyRuleAttemptCompleted = (
+  options: RunNextRuleOptions,
+  event: RuleAttemptEvent,
+): void => {
+  try {
+    options.observer?.onRuleAttemptCompleted?.(event)
+  } catch {
+    // Observability must never affect solver behavior.
+  }
+}
+
+export const notifyStrongInferenceCompleted = (
+  runtimeContext: RuleRuntimeContext | undefined,
+  event: Omit<StrongInferenceCompletedEvent, 'solverStepNumber'>,
+): void => {
+  try {
+    runtimeContext?.observer?.onStrongInferenceCompleted?.({
+      solverStepNumber: runtimeContext.solverStepNumber,
+      ...event,
+    })
+  } catch {
+    // Observability must never affect solver behavior.
+  }
+}
+
 export const runNextRule = (
   puzzle: PuzzleIR,
   rules: Rule[],
   stepNumber: number,
+  options: RunNextRuleOptions = {},
 ): { nextPuzzle: PuzzleIR; step: RuleStep | null } => {
   const startedAt = performance.now()
   const runtimeContext: RuleRuntimeContext = {
     cache: new Map<string, unknown>(),
+    solverStepNumber: stepNumber,
+    observer: options.observer,
   }
   const attempts: RuleAttempt[] = []
   for (const rule of rules) {
@@ -178,6 +209,14 @@ export const runNextRule = (
       durationMs: ruleApplyMs,
       hit,
     })
+    notifyRuleAttemptCompleted(options, {
+      solverStepNumber: stepNumber,
+      ruleId: rule.id,
+      ruleName: rule.name,
+      durationMs: ruleApplyMs,
+      hit,
+      producedDiffCount: hit ? (result?.diffs.length ?? 0) : 0,
+    })
     if (!result || result.diffs.length === 0) {
       continue
     }
diff --git a/src/domain/rules/masyu/rules/blackPearlStrongInference.ts b/src/domain/rules/masyu/rules/blackPearlStrongInference.ts
index 3b725a8..3467a78 100644
--- a/src/domain/rules/masyu/rules/blackPearlStrongInference.ts
+++ b/src/domain/rules/masyu/rules/blackPearlStrongInference.ts
@@ -1,8 +1,6 @@
 import type { PuzzleIR } from '../../../ir/types'
-import type { Rule, RuleApplication } from '../../types'
-import {
-  runMasyuTrialUntilFixpoint,
-} from './trial'
+import type { Rule, RuleApplication, RuleRuntimeContext } from '../../types'
+import { runMasyuTrialUntilFixpoint } from './trial'
 import { getMasyuBlackPearlKeys } from './pearlSelectors'
 import {
   formatMasyuCellKeyLabel,
@@ -17,6 +15,7 @@ import {
 import {
   buildMasyuStrongBranch,
   buildMasyuInferenceDetails,
+  createMasyuStrongInferenceTracker,
   deriveMasyuStrongProbeBudgets,
   describeMasyuStrongTrialResult,
   immediateMasyuStrongContradictionResult,
@@ -91,78 +90,112 @@ const buildBranch = (
 export const createBlackPearlStrongInferenceRule = (
   getDeterministicRules: () => Rule[],
   options: MasyuStrongInferenceOptions = {},
-): Rule => ({
-  id: 'masyu-black-pearl-strong-inference',
-  name: 'Black Pearl Strong Inference',
-  apply: (puzzle: PuzzleIR): RuleApplication | null => {
-    const deterministicRules = getDeterministicRules()
-    const candidates = collectBlackPearlExitCandidates(
-      puzzle,
-      options.maxCandidates ?? STRONG_MAX_CANDIDATES,
-    )
-    if (candidates.length === 0) {
-      return null
-    }
+): Rule => {
+  const id = 'masyu-black-pearl-strong-inference'
+  const name = 'Black Pearl Strong Inference'
+  return {
+    id,
+    name,
+    apply: (
+      puzzle: PuzzleIR,
+      runtimeContext?: RuleRuntimeContext,
+    ): RuleApplication | null => {
+      const deterministicRules = getDeterministicRules()
+      const candidates = collectBlackPearlExitCandidates(
+        puzzle,
+        options.maxCandidates ?? STRONG_MAX_CANDIDATES,
+      )
+      const tracker = createMasyuStrongInferenceTracker(
+        runtimeContext,
+        id,
+        name,
+        candidates.length,
+      )
+      if (candidates.length === 0) {
+        tracker.complete('miss')
+        return null
+      }
 
-    const deadlineMs = Date.now() + (options.maxMs ?? STRONG_MAX_MS)
-    const budgets = deriveMasyuStrongProbeBudgets(
-      options.maxTrialSteps ?? STRONG_MAX_TRIAL_STEPS,
-    )
-    for (const budget of budgets) {
-      for (const candidate of candidates) {
-        if (Date.now() > deadlineMs) {
-          return null
-        }
+      const deadlineMs = Date.now() + (options.maxMs ?? STRONG_MAX_MS)
+      const budgets = deriveMasyuStrongProbeBudgets(
+        options.maxTrialSteps ?? STRONG_MAX_TRIAL_STEPS,
+      )
+      let eligibleCandidates: Set<BlackPearlExitCandidate> | null = null
+      for (const budget of budgets) {
+        const exhaustedCandidates = new Set<BlackPearlExitCandidate>()
+        for (const candidate of candidates) {
+          if (
+            eligibleCandidates !== null &&
+            !eligibleCandidates.has(candidate)
+          ) {
+            continue
+          }
+          if (Date.now() > deadlineMs) {
+            tracker.complete('timeout')
+            return null
+          }
 
-        const branch = buildBranch(puzzle, candidate)
-        const result = branch.setupOk
-          ? runMasyuTrialUntilFixpoint(
-              branch.puzzle,
-              deterministicRules,
-              budget,
-              deadlineMs,
-            )
-          : immediateMasyuStrongContradictionResult(branch.puzzle)
-        if (result.timedOut) {
-          return null
-        }
-        if (!result.contradiction) {
-          continue
-        }
-        if (
-          (puzzle.lines[candidate.firstLine]?.mark ?? 'unknown') !== 'unknown'
-        ) {
-          continue
-        }
+          const branch = buildBranch(puzzle, candidate)
+          const result = branch.setupOk
+            ? runMasyuTrialUntilFixpoint(
+                branch.puzzle,
+                deterministicRules,
+                budget,
+                deadlineMs,
+              )
+            : immediateMasyuStrongContradictionResult(branch.puzzle)
+          tracker.recordProbe(result)
+          if (result.timedOut) {
+            tracker.complete('timeout')
+            return null
+          }
+          if (!result.contradiction) {
+            if (result.exhausted) {
+              exhaustedCandidates.add(candidate)
+            }
+            continue
+          }
+          if (
+            (puzzle.lines[candidate.firstLine]?.mark ?? 'unknown') !== 'unknown'
+          ) {
+            continue
+          }
 
-        const diffs: RuleApplication['diffs'] = [
-          {
-            kind: 'line',
-            lineKey: candidate.firstLine,
-            from: 'unknown',
-            to: 'blank',
-          },
-        ]
-        return {
-          message:
-            `Black Pearl Strong Inference: assuming ${formatMasyuCellKeyLabel(candidate.pearlKey)} exits ${candidate.direction} ` +
-            `(${branch.setupDescription}) leads to ${describeMasyuStrongTrialResult(result)}, so ${formatMasyuLineLabel(
-              candidate.firstLine,
-            )} is crossed out.`,
-          diffs,
-          affectedCells: [candidate.pearlKey],
-          affectedLines: [candidate.firstLine],
-          inferenceDetails: buildMasyuInferenceDetails(
-            puzzle,
-            `Assume ${formatMasyuCellKeyLabel(candidate.pearlKey)} exits ${candidate.direction}`,
-            branch,
-            result,
+          const diffs: RuleApplication['diffs'] = [
+            {
+              kind: 'line',
+              lineKey: candidate.firstLine,
+              from: 'unknown',
+              to: 'blank',
+            },
+          ]
+          tracker.complete('hit', diffs.length)
+          return {
+            message:
+              `Black Pearl Strong Inference: assuming ${formatMasyuCellKeyLabel(candidate.pearlKey)} exits ${candidate.direction} ` +
+              `(${branch.setupDescription}) leads to ${describeMasyuStrongTrialResult(result)}, so ${formatMasyuLineLabel(
+                candidate.firstLine,
+              )} is crossed out.`,
             diffs,
-          ),
+            affectedCells: [candidate.pearlKey],
+            affectedLines: [candidate.firstLine],
+            inferenceDetails: buildMasyuInferenceDetails(
+              puzzle,
+              `Assume ${formatMasyuCellKeyLabel(candidate.pearlKey)} exits ${candidate.direction}`,
+              branch,
+              result,
+              diffs,
+            ),
+          }
+        }
+        eligibleCandidates = exhaustedCandidates
+        if (eligibleCandidates.size === 0) {
+          break
         }
       }
-    }
 
-    return null
-  },
-})
+      tracker.complete('miss')
+      return null
+    },
+  }
+}
diff --git a/src/domain/rules/masyu/rules/lineComponentEndpointStrongInference.ts b/src/domain/rules/masyu/rules/lineComponentEndpointStrongInference.ts
index 5ca74de..501e4aa 100644
--- a/src/domain/rules/masyu/rules/lineComponentEndpointStrongInference.ts
+++ b/src/domain/rules/masyu/rules/lineComponentEndpointStrongInference.ts
@@ -1,6 +1,6 @@
 import { parseCellKey } from '../../../ir/keys'
 import type { PuzzleIR } from '../../../ir/types'
-import type { Rule, RuleApplication } from '../../types'
+import type { Rule, RuleApplication, RuleRuntimeContext } from '../../types'
 import { getMasyuOpenLineComponents } from './lineGraph'
 import {
   formatMasyuCellKeyLabel,
@@ -12,6 +12,7 @@ import {
 import {
   buildMasyuInferenceDetails,
   buildMasyuStrongBranch,
+  createMasyuStrongInferenceTracker,
   deriveMasyuStrongProbeBudgets,
   describeMasyuStrongTrialResult,
   immediateMasyuStrongContradictionResult,
@@ -82,82 +83,115 @@ const buildCandidateAssumptions = (
 export const createLineComponentEndpointStrongInferenceRule = (
   getDeterministicRules: () => Rule[],
   options: MasyuStrongInferenceOptions = {},
-): Rule => ({
-  id: 'masyu-line-component-endpoint-strong-inference',
-  name: 'Masyu Line Component Endpoint Strong Inference',
-  apply: (puzzle: PuzzleIR): RuleApplication | null => {
-    const candidates = collectLineComponentEndpointCandidates(
-      puzzle,
-      options.maxCandidates ??
-        Math.min(ENDPOINT_STRONG_MAX_CANDIDATES, STRONG_MAX_CANDIDATES),
-    )
-    if (candidates.length === 0) {
-      return null
-    }
+): Rule => {
+  const id = 'masyu-line-component-endpoint-strong-inference'
+  const name = 'Masyu Line Component Endpoint Strong Inference'
+  return {
+    id,
+    name,
+    apply: (
+      puzzle: PuzzleIR,
+      runtimeContext?: RuleRuntimeContext,
+    ): RuleApplication | null => {
+      const candidates = collectLineComponentEndpointCandidates(
+        puzzle,
+        options.maxCandidates ??
+          Math.min(ENDPOINT_STRONG_MAX_CANDIDATES, STRONG_MAX_CANDIDATES),
+      )
+      const tracker = createMasyuStrongInferenceTracker(
+        runtimeContext,
+        id,
+        name,
+        candidates.length,
+      )
+      if (candidates.length === 0) {
+        tracker.complete('miss')
+        return null
+      }
 
-    const deterministicRules = getDeterministicRules()
-    const deadlineMs =
-      Date.now() +
-      (options.maxMs ?? Math.min(ENDPOINT_STRONG_MAX_MS, STRONG_MAX_MS))
-    const budgets = deriveMasyuStrongProbeBudgets(
-      options.maxTrialSteps ?? STRONG_MAX_TRIAL_STEPS,
-    )
+      const deterministicRules = getDeterministicRules()
+      const deadlineMs =
+        Date.now() +
+        (options.maxMs ?? Math.min(ENDPOINT_STRONG_MAX_MS, STRONG_MAX_MS))
+      const budgets = deriveMasyuStrongProbeBudgets(
+        options.maxTrialSteps ?? STRONG_MAX_TRIAL_STEPS,
+      )
+      let eligibleCandidates: Set<LineComponentEndpointCandidate> | null = null
 
-    for (const budget of budgets) {
-      for (const candidate of candidates) {
-        if (Date.now() > deadlineMs) {
-          return null
-        }
-        const branch = buildMasyuStrongBranch(
-          puzzle,
-          buildCandidateAssumptions(candidate),
-        )
-        const result = branch.setupOk
-          ? runMasyuTrialUntilFixpoint(
-              branch.puzzle,
-              deterministicRules,
-              budget,
-              deadlineMs,
-            )
-          : immediateMasyuStrongContradictionResult(branch.puzzle)
-        if (result.timedOut) {
-          return null
-        }
-        if (!result.contradiction) {
-          continue
-        }
+      for (const budget of budgets) {
+        const exhaustedCandidates = new Set<LineComponentEndpointCandidate>()
+        for (const candidate of candidates) {
+          if (
+            eligibleCandidates !== null &&
+            !eligibleCandidates.has(candidate)
+          ) {
+            continue
+          }
+          if (Date.now() > deadlineMs) {
+            tracker.complete('timeout')
+            return null
+          }
+          const branch = buildMasyuStrongBranch(
+            puzzle,
+            buildCandidateAssumptions(candidate),
+          )
+          const result = branch.setupOk
+            ? runMasyuTrialUntilFixpoint(
+                branch.puzzle,
+                deterministicRules,
+                budget,
+                deadlineMs,
+              )
+            : immediateMasyuStrongContradictionResult(branch.puzzle)
+          tracker.recordProbe(result)
+          if (result.timedOut) {
+            tracker.complete('timeout')
+            return null
+          }
+          if (!result.contradiction) {
+            if (result.exhausted) {
+              exhaustedCandidates.add(candidate)
+            }
+            continue
+          }
 
-        const diffs: RuleApplication['diffs'] = [
-          {
-            kind: 'line',
-            lineKey: candidate.assumed.lineKey,
-            from: 'unknown',
-            to: 'blank',
-          },
-        ]
-        return {
-          message:
-            `Masyu Line Component Endpoint Strong Inference: assuming the ${candidate.componentEdgeCount}-segment component at ${formatMasyuCellKeyLabel(
+          const diffs: RuleApplication['diffs'] = [
+            {
+              kind: 'line',
+              lineKey: candidate.assumed.lineKey,
+              from: 'unknown',
+              to: 'blank',
+            },
+          ]
+          tracker.complete('hit', diffs.length)
+          return {
+            message: `Masyu Line Component Endpoint Strong Inference: assuming the ${candidate.componentEdgeCount}-segment component at ${formatMasyuCellKeyLabel(
               candidate.endpointKey,
             )} continues ${candidate.assumed.direction} among ${candidate.unknowns.length} candidate directions (${branch.setupDescription}) leads to ${describeMasyuStrongTrialResult(
               result,
             )}, so ${formatMasyuLineLabel(candidate.assumed.lineKey)} is crossed out.`,
-          diffs,
-          affectedCells: [candidate.endpointKey],
-          affectedLines: [candidate.assumed.lineKey],
-          inferenceDetails: buildMasyuInferenceDetails(
-            puzzle,
-            `Assume the ${candidate.componentEdgeCount}-segment component at ${formatMasyuCellKeyLabel(
-              candidate.endpointKey,
-            )} continues ${candidate.assumed.direction}`,
-            branch,
-            result,
             diffs,
-          ),
+            affectedCells: [candidate.endpointKey],
+            affectedLines: [candidate.assumed.lineKey],
+            inferenceDetails: buildMasyuInferenceDetails(
+              puzzle,
+              `Assume the ${candidate.componentEdgeCount}-segment component at ${formatMasyuCellKeyLabel(
+                candidate.endpointKey,
+              )} continues ${candidate.assumed.direction}`,
+              branch,
+              result,
+              diffs,
+            ),
+          }
+        }
+        eligibleCandidates = exhaustedCandidates
+        if (eligibleCandidates.size === 0) {
+          break
         }
       }
-    }
 
-    return null
-  },
-})
+      tracker.complete('miss')
+      return null
+    },
+  }
+}
diff --git a/src/domain/rules/masyu/rules/strongInference.ts b/src/domain/rules/masyu/rules/strongInference.ts
index e7c9d3f..6f7f3ab 100644
--- a/src/domain/rules/masyu/rules/strongInference.ts
+++ b/src/domain/rules/masyu/rules/strongInference.ts
@@ -1,10 +1,13 @@
 import { clonePuzzle } from '../../../ir/normalize'
 import type { LineMark, PuzzleIR } from '../../../ir/types'
-import type { InferenceDetails, RuleApplication } from '../../types'
-import {
-  applyMasyuLineAssumption,
-  type MasyuTrialResult,
-} from './trial'
+import { notifyStrongInferenceCompleted } from '../../engine'
+import type {
+  InferenceDetails,
+  RuleApplication,
+  RuleRuntimeContext,
+  StrongInferenceOutcome,
+} from '../../types'
+import { applyMasyuLineAssumption, type MasyuTrialResult } from './trial'
 import { formatMasyuLineLabel } from './shared'
 
 export type MasyuStrongInferenceOptions = {
@@ -22,10 +25,63 @@ export type MasyuStrongBranch = {
 
 export type MasyuLineAssumption = [lineKey: string, mark: LineMark]
 
+export type MasyuStrongInferenceTracker = {
+  recordProbe: (result: MasyuTrialResult) => void
+  complete: (
+    outcome: StrongInferenceOutcome,
+    producedDiffCount?: number,
+  ) => void
+}
+
 export const STRONG_MAX_CANDIDATES = 300
 export const STRONG_MAX_TRIAL_STEPS = 100
 export const STRONG_MAX_MS = 30000
 
+const NOOP_STRONG_INFERENCE_TRACKER: MasyuStrongInferenceTracker = {
+  recordProbe: () => {},
+  complete: () => {},
+}
+
+export const createMasyuStrongInferenceTracker = (
+  runtimeContext: RuleRuntimeContext | undefined,
+  ruleId: string,
+  ruleName: string,
+  candidateCount: number,
+): MasyuStrongInferenceTracker => {
+  if (!runtimeContext?.observer?.onStrongInferenceCompleted) {
+    return NOOP_STRONG_INFERENCE_TRACKER
+  }
+
+  let probeCount = 0
+  let trialStepCount = 0
+  let probeDurationMs = 0
+  let completed = false
+
+  return {
+    recordProbe: (result) => {
+      probeCount += 1
+      trialStepCount += result.stepsRun
+      probeDurationMs += result.elapsedMs
+    },
+    complete: (outcome, producedDiffCount = 0) => {
+      if (completed) {
+        return
+      }
+      completed = true
+      notifyStrongInferenceCompleted(runtimeContext, {
+        ruleId,
+        ruleName,
+        candidateCount,
+        probeCount,
+        trialStepCount,
+        probeDurationMs,
+        outcome,
+        producedDiffCount,
+      })
+    },
+  }
+}
+
 export const deriveMasyuStrongProbeBudgets = (
   maxTrialSteps: number,
 ): number[] => {
diff --git a/src/domain/rules/masyu/rules/whitePearlStrongInference.ts b/src/domain/rules/masyu/rules/whitePearlStrongInference.ts
index e6a0242..29e71e6 100644
--- a/src/domain/rules/masyu/rules/whitePearlStrongInference.ts
+++ b/src/domain/rules/masyu/rules/whitePearlStrongInference.ts
@@ -1,6 +1,6 @@
 import { cellKey, parseCellKey } from '../../../ir/keys'
 import type { PuzzleIR } from '../../../ir/types'
-import type { Rule, RuleApplication } from '../../types'
+import type { Rule, RuleApplication, RuleRuntimeContext } from '../../types'
 import { createMasyuLineDecisionCollector } from './decisionCollector'
 import { createMasyuLookaheadContext } from './lookahead'
 import type { WhitePearlCandidate } from './pearlCandidates'
@@ -16,6 +16,7 @@ import {
 import {
   buildMasyuStrongBranch,
   buildMasyuInferenceDetails,
+  createMasyuStrongInferenceTracker,
   deriveMasyuStrongProbeBudgets,
   describeMasyuStrongTrialResult,
   immediateMasyuStrongContradictionResult,
@@ -79,7 +80,9 @@ const getDecidedLocalLineCount = (
 
   const localLines = new Set<string>()
   for (const key of localCells) {
-    for (const line of Object.values(getMasyuIncidentDirectionalLines(puzzle, key))) {
+    for (const line of Object.values(
+      getMasyuIncidentDirectionalLines(puzzle, key),
+    )) {
       if (line) {
         localLines.add(line.lineKey)
       }
@@ -133,7 +136,9 @@ const candidateAssumptions = (
 const collectCandidateDiffs = (
   puzzle: PuzzleIR,
   candidate: WhitePearlCandidate,
-): ReturnType<ReturnType<typeof createMasyuLineDecisionCollector>['diffs']> | null => {
+): ReturnType<
+  ReturnType<typeof createMasyuLineDecisionCollector>['diffs']
+> | null => {
   const overlay = masyuPearlCandidateToOverlay(candidate)
   if (!overlay) {
     return null
@@ -152,82 +157,116 @@ const collectCandidateDiffs = (
 export const createWhitePearlStrongInferenceRule = (
   getDeterministicRules: () => Rule[],
   options: MasyuStrongInferenceOptions = {},
-): Rule => ({
-  id: 'masyu-white-pearl-strong-inference',
-  name: 'White Pearl Strong Inference',
-  apply: (puzzle: PuzzleIR): RuleApplication | null => {
-    const deterministicRules = getDeterministicRules()
-    const candidates = collectWhitePearlAxisCandidates(
-      puzzle,
-      options.maxCandidates ?? STRONG_MAX_CANDIDATES,
-    )
-    if (candidates.length === 0) {
-      return null
-    }
-
-    const deadlineMs = Date.now() + (options.maxMs ?? STRONG_MAX_MS)
-    const budgets = deriveMasyuStrongProbeBudgets(
-      options.maxTrialSteps ?? STRONG_MAX_TRIAL_STEPS,
-    )
+): Rule => {
+  const id = 'masyu-white-pearl-strong-inference'
+  const name = 'White Pearl Strong Inference'
+  return {
+    id,
+    name,
+    apply: (
+      puzzle: PuzzleIR,
+      runtimeContext?: RuleRuntimeContext,
+    ): RuleApplication | null => {
+      const deterministicRules = getDeterministicRules()
+      const candidates = collectWhitePearlAxisCandidates(
+        puzzle,
+        options.maxCandidates ?? STRONG_MAX_CANDIDATES,
+      )
+      const tracker = createMasyuStrongInferenceTracker(
+        runtimeContext,
+        id,
+        name,
+        candidates.length,
+      )
+      if (candidates.length === 0) {
+        tracker.complete('miss')
+        return null
+      }
 
-    for (const budget of budgets) {
-      for (const pearlCandidate of candidates) {
-        if (Date.now() > deadlineMs) {
-          return null
-        }
+      const deadlineMs = Date.now() + (options.maxMs ?? STRONG_MAX_MS)
+      const budgets = deriveMasyuStrongProbeBudgets(
+        options.maxTrialSteps ?? STRONG_MAX_TRIAL_STEPS,
+      )
+      let eligibleTrialIndexes: Set<number> | null = null
 
-        for (const assumedIndex of [0, 1] as const) {
-          const assumed = pearlCandidate.candidates[assumedIndex]
-          const forced = pearlCandidate.candidates[assumedIndex === 0 ? 1 : 0]
-          const assumptions = candidateAssumptions(assumed)
-          if (assumptions.length === 0) {
-            continue
-          }
-          const branch = buildMasyuStrongBranch(puzzle, assumptions)
-          const result = branch.setupOk
-            ? runMasyuTrialUntilFixpoint(
-                branch.puzzle,
-                deterministicRules,
-                budget,
-                deadlineMs,
-              )
-            : immediateMasyuStrongContradictionResult(branch.puzzle)
-          if (result.timedOut) {
+      for (const budget of budgets) {
+        const exhaustedTrialIndexes = new Set<number>()
+        for (const [candidateIndex, pearlCandidate] of candidates.entries()) {
+          if (Date.now() > deadlineMs) {
+            tracker.complete('timeout')
             return null
           }
-          if (!result.contradiction) {
-            continue
-          }
 
-          const diffs = collectCandidateDiffs(puzzle, forced)
-          if (!diffs || diffs.length === 0) {
-            continue
-          }
-          const firstLine = diffs[0]?.lineKey
-          return {
-            message:
-              `White Pearl Strong Inference: assuming ${formatMasyuCellKeyLabel(pearlCandidate.pearlKey)} goes ${axisLabel(
+          for (const assumedIndex of [0, 1] as const) {
+            const trialIndex = candidateIndex * 2 + assumedIndex
+            if (
+              eligibleTrialIndexes !== null &&
+              !eligibleTrialIndexes.has(trialIndex)
+            ) {
+              continue
+            }
+            const assumed = pearlCandidate.candidates[assumedIndex]
+            const forced = pearlCandidate.candidates[assumedIndex === 0 ? 1 : 0]
+            const assumptions = candidateAssumptions(assumed)
+            if (assumptions.length === 0) {
+              continue
+            }
+            const branch = buildMasyuStrongBranch(puzzle, assumptions)
+            const result = branch.setupOk
+              ? runMasyuTrialUntilFixpoint(
+                  branch.puzzle,
+                  deterministicRules,
+                  budget,
+                  deadlineMs,
+                )
+              : immediateMasyuStrongContradictionResult(branch.puzzle)
+            tracker.recordProbe(result)
+            if (result.timedOut) {
+              tracker.complete('timeout')
+              return null
+            }
+            if (!result.contradiction) {
+              if (result.exhausted) {
+                exhaustedTrialIndexes.add(trialIndex)
+              }
+              continue
+            }
+
+            const diffs = collectCandidateDiffs(puzzle, forced)
+            if (!diffs || diffs.length === 0) {
+              continue
+            }
+            const firstLine = diffs[0]?.lineKey
+            tracker.complete('hit', diffs.length)
+            return {
+              message: `White Pearl Strong Inference: assuming ${formatMasyuCellKeyLabel(pearlCandidate.pearlKey)} goes ${axisLabel(
                 assumed.axis,
               )} (${branch.setupDescription}) leads to ${describeMasyuStrongTrialResult(
                 result,
               )}, so it must go ${axisLabel(forced.axis)} through ${formatMasyuLineLabel(
                 firstLine,
               )}${diffs.length > 1 ? ` (${diffs.length} total)` : ''}.`,
-            diffs,
-            affectedCells: [pearlCandidate.pearlKey],
-            affectedLines: diffs.map((diff) => diff.lineKey),
-            inferenceDetails: buildMasyuInferenceDetails(
-              puzzle,
-              `Assume ${formatMasyuCellKeyLabel(pearlCandidate.pearlKey)} goes ${axisLabel(assumed.axis)}`,
-              branch,
-              result,
               diffs,
-            ),
+              affectedCells: [pearlCandidate.pearlKey],
+              affectedLines: diffs.map((diff) => diff.lineKey),
+              inferenceDetails: buildMasyuInferenceDetails(
+                puzzle,
+                `Assume ${formatMasyuCellKeyLabel(pearlCandidate.pearlKey)} goes ${axisLabel(assumed.axis)}`,
+                branch,
+                result,
+                diffs,
+              ),
+            }
           }
         }
+        eligibleTrialIndexes = exhaustedTrialIndexes
+        if (eligibleTrialIndexes.size === 0) {
+          break
+        }
       }
-    }
 
-    return null
-  },
-})
+      tracker.complete('miss')
+      return null
+    },
+  }
+}
diff --git a/src/domain/rules/masyu/tests/blackPearlStrongInference.test.ts b/src/domain/rules/masyu/tests/blackPearlStrongInference.test.ts
index d8f478c..9d30f2f 100644
--- a/src/domain/rules/masyu/tests/blackPearlStrongInference.test.ts
+++ b/src/domain/rules/masyu/tests/blackPearlStrongInference.test.ts
@@ -125,6 +125,63 @@ describe('Masyu black pearl strong inference', () => {
     expect(puzzle.lines[unrelated]?.mark).toBe('unknown')
   })
 
+  it('does not retry a settled trial at higher budgets', () => {
+    const puzzle = createMasyuPuzzle(5, 5)
+    addPearl(puzzle, 2, 2, 'black')
+    let attempts = 0
+    const settledRule: Rule = {
+      id: 'test-settled-trial',
+      name: 'Test Settled Trial',
+      apply: () => {
+        attempts += 1
+        return null
+      },
+    }
+
+    const result = createBlackPearlStrongInferenceRule(() => [settledRule], {
+      maxCandidates: 1,
+      maxTrialSteps: 13,
+    }).apply(puzzle)
+
+    expect(result).toBeNull()
+    expect(attempts).toBe(1)
+  })
+
+  it('retries a budget-limited trial at the next budget', () => {
+    const puzzle = createMasyuPuzzle(5, 5)
+    addPearl(puzzle, 2, 2, 'black')
+    const targetCell = cellKey(0, 0)
+    let attempts = 0
+    const progressingRule: Rule = {
+      id: 'test-budget-limited-trial',
+      name: 'Test Budget Limited Trial',
+      apply: (trial) => {
+        attempts += 1
+        const fromFill = trial.cells[targetCell]?.fill ?? null
+        return {
+          message: 'Keep the trial progressing',
+          diffs: [
+            {
+              kind: 'cell',
+              cellKey: targetCell,
+              fromFill,
+              toFill: fromFill === 'a' ? 'b' : 'a',
+            },
+          ],
+          affectedCells: [targetCell],
+        }
+      },
+    }
+
+    const result = createBlackPearlStrongInferenceRule(
+      () => [progressingRule],
+      { maxCandidates: 1, maxTrialSteps: 13 },
+    ).apply(puzzle)
+
+    expect(result).toBeNull()
+    expect(attempts).toBe(25)
+  })
+
   it('returns null when the trial budget times out', () => {
     const puzzle = createMasyuPuzzle(5, 5)
     addPearl(puzzle, 2, 2, 'black')
diff --git a/src/domain/rules/masyu/tests/lineComponentEndpointStrongInference.test.ts b/src/domain/rules/masyu/tests/lineComponentEndpointStrongInference.test.ts
index b7e9b54..02b4278 100644
--- a/src/domain/rules/masyu/tests/lineComponentEndpointStrongInference.test.ts
+++ b/src/domain/rules/masyu/tests/lineComponentEndpointStrongInference.test.ts
@@ -208,6 +208,63 @@ describe('Masyu line component endpoint strong inference', () => {
     expect(puzzle.lines[unrelated]?.mark).toBe('unknown')
   })
 
+  it('does not retry a settled endpoint trial at higher budgets', () => {
+    const puzzle = createMasyuPuzzle(3, 4)
+    markLine(puzzle, lineKey([0, 0], [0, 1]), 'line')
+    let attempts = 0
+    const settledRule: Rule = {
+      id: 'test-settled-endpoint-trial',
+      name: 'Test Settled Endpoint Trial',
+      apply: () => {
+        attempts += 1
+        return null
+      },
+    }
+
+    const result = createLineComponentEndpointStrongInferenceRule(
+      () => [settledRule],
+      { maxCandidates: 1, maxTrialSteps: 13 },
+    ).apply(puzzle)
+
+    expect(result).toBeNull()
+    expect(attempts).toBe(1)
+  })
+
+  it('retries a budget-limited endpoint trial at the next budget', () => {
+    const puzzle = createMasyuPuzzle(3, 4)
+    markLine(puzzle, lineKey([0, 0], [0, 1]), 'line')
+    const targetCell = cellKey(2, 3)
+    let attempts = 0
+    const progressingRule: Rule = {
+      id: 'test-budget-limited-endpoint-trial',
+      name: 'Test Budget Limited Endpoint Trial',
+      apply: (trial) => {
+        attempts += 1
+        const fromFill = trial.cells[targetCell]?.fill ?? null
+        return {
+          message: 'Keep the endpoint trial progressing',
+          diffs: [
+            {
+              kind: 'cell',
+              cellKey: targetCell,
+              fromFill,
+              toFill: fromFill === 'a' ? 'b' : 'a',
+            },
+          ],
+          affectedCells: [targetCell],
+        }
+      },
+    }
+
+    const result = createLineComponentEndpointStrongInferenceRule(
+      () => [progressingRule],
+      { maxCandidates: 1, maxTrialSteps: 13 },
+    ).apply(puzzle)
+
+    expect(result).toBeNull()
+    expect(attempts).toBe(25)
+  })
+
   it('honors timeout and candidate limits', () => {
     const puzzle = createMasyuPuzzle(3, 4)
     markLine(puzzle, lineKey([0, 0], [0, 1]), 'line')
diff --git a/src/domain/rules/masyu/tests/strongInferenceObserver.test.ts b/src/domain/rules/masyu/tests/strongInferenceObserver.test.ts
new file mode 100644
index 0000000..d890615
--- /dev/null
+++ b/src/domain/rules/masyu/tests/strongInferenceObserver.test.ts
@@ -0,0 +1,233 @@
+import { describe, expect, it } from 'vitest'
+import { cellKey, lineKey, tileKey } from '../../../ir/keys'
+import { createMasyuPuzzle } from '../../../ir/masyu'
+import { runNextRule } from '../../engine'
+import type {
+  Rule,
+  RuleRuntimeContext,
+  StrongInferenceCompletedEvent,
+} from '../../types'
+import { createBlackPearlStrongInferenceRule } from '../rules/blackPearlStrongInference'
+import { createLineComponentEndpointStrongInferenceRule } from '../rules/lineComponentEndpointStrongInference'
+import { createWhitePearlStrongInferenceRule } from '../rules/whitePearlStrongInference'
+import { addPearl, markLine } from './testUtils'
+
+const observe = (
+  apply: (runtimeContext: RuleRuntimeContext) => unknown,
+): StrongInferenceCompletedEvent[] => {
+  const events: StrongInferenceCompletedEvent[] = []
+  apply({
+    cache: new Map(),
+    solverStepNumber: 7,
+    observer: {
+      onStrongInferenceCompleted: (event) => events.push(event),
+    },
+  })
+  return events
+}
+
+describe('Masyu strong inference observer', () => {
+  it('reports one zero-candidate miss for each strong rule', () => {
+    const puzzle = createMasyuPuzzle(3, 3)
+    const rules = [
+      createBlackPearlStrongInferenceRule(() => []),
+      createLineComponentEndpointStrongInferenceRule(() => []),
+      createWhitePearlStrongInferenceRule(() => []),
+    ]
+
+    for (const rule of rules) {
+      const events = observe((runtimeContext) =>
+        rule.apply(puzzle, runtimeContext),
+      )
+      expect(events).toEqual([
+        {
+          solverStepNumber: 7,
+          ruleId: rule.id,
+          ruleName: rule.name,
+          candidateCount: 0,
+          probeCount: 0,
+          trialStepCount: 0,
+          probeDurationMs: 0,
+          outcome: 'miss',
+          producedDiffCount: 0,
+        },
+      ])
+    }
+  })
+
+  it('reports black-pearl hit, timeout, setup contradiction, and gradient retries', () => {
+    const hitPuzzle = createMasyuPuzzle(5, 5)
+    addPearl(hitPuzzle, 2, 2, 'black')
+    markLine(hitPuzzle, lineKey([1, 1], [1, 2]), 'line')
+    markLine(hitPuzzle, lineKey([1, 2], [1, 3]), 'line')
+    const hitRule = createBlackPearlStrongInferenceRule(() => [])
+    const hitEvents = observe((runtimeContext) =>
+      hitRule.apply(hitPuzzle, runtimeContext),
+    )
+    expect(hitEvents).toHaveLength(1)
+    expect(hitEvents[0]).toMatchObject({
+      outcome: 'hit',
+      probeCount: 1,
+      trialStepCount: 0,
+      producedDiffCount: 1,
+    })
+
+    const setupPuzzle = createMasyuPuzzle(5, 5)
+    addPearl(setupPuzzle, 2, 2, 'black')
+    markLine(setupPuzzle, lineKey([0, 2], [1, 2]), 'blank')
+    const setupRule = createBlackPearlStrongInferenceRule(() => [], {
+      maxCandidates: 1,
+    })
+    const setupEvents = observe((runtimeContext) =>
+      setupRule.apply(setupPuzzle, runtimeContext),
+    )
+    expect(setupEvents[0]).toMatchObject({
+      outcome: 'hit',
+      probeCount: 1,
+      trialStepCount: 0,
+      probeDurationMs: 0,
+    })
+
+    const timeoutPuzzle = createMasyuPuzzle(5, 5)
+    addPearl(timeoutPuzzle, 2, 2, 'black')
+    const timeoutRule = createBlackPearlStrongInferenceRule(() => [], {
+      maxMs: -1,
+    })
+    const timeoutEvents = observe((runtimeContext) =>
+      timeoutRule.apply(timeoutPuzzle, runtimeContext),
+    )
+    expect(timeoutEvents[0]).toMatchObject({
+      outcome: 'timeout',
+      probeCount: 0,
+      producedDiffCount: 0,
+    })
+
+    const retryPuzzle = createMasyuPuzzle(5, 5)
+    addPearl(retryPuzzle, 2, 2, 'black')
+    const targetCell = cellKey(0, 0)
+    const progressingRule: Rule = {
+      id: 'test-progress',
+      name: 'Test Progress',
+      apply: (trial) => {
+        const fromFill = trial.cells[targetCell]?.fill ?? null
+        return {
+          message: 'progress',
+          diffs: [
+            {
+              kind: 'cell',
+              cellKey: targetCell,
+              fromFill,
+              toFill: fromFill === 'a' ? 'b' : 'a',
+            },
+          ],
+          affectedCells: [targetCell],
+        }
+      },
+    }
+    const retryRule = createBlackPearlStrongInferenceRule(
+      () => [progressingRule],
+      { maxCandidates: 1, maxTrialSteps: 13 },
+    )
+    const retryEvents = observe((runtimeContext) =>
+      retryRule.apply(retryPuzzle, runtimeContext),
+    )
+    expect(retryEvents[0]).toMatchObject({
+      outcome: 'miss',
+      candidateCount: 1,
+      probeCount: 2,
+      trialStepCount: 25,
+      producedDiffCount: 0,
+    })
+  })
+
+  it('reports endpoint and white-pearl hits with formal diff counts', () => {
+    const endpointPuzzle = createMasyuPuzzle(3, 4)
+    markLine(endpointPuzzle, lineKey([0, 0], [0, 1]), 'line')
+    markLine(endpointPuzzle, lineKey([0, 2], [0, 3]), 'line')
+    markLine(endpointPuzzle, lineKey([0, 2], [1, 2]), 'line')
+    const endpointRule = createLineComponentEndpointStrongInferenceRule(
+      () => [],
+    )
+    const endpointEvents = observe((runtimeContext) =>
+      endpointRule.apply(endpointPuzzle, runtimeContext),
+    )
+    expect(endpointEvents).toHaveLength(1)
+    expect(endpointEvents[0]).toMatchObject({
+      outcome: 'hit',
+      probeCount: 1,
+      producedDiffCount: 1,
+    })
+
+    const whitePuzzle = createMasyuPuzzle(5, 5)
+    addPearl(whitePuzzle, 2, 2, 'white')
+    whitePuzzle.tiles[tileKey(2, 2)] = { fill: 'yellow' }
+    whitePuzzle.tiles[tileKey(2, 3)] = { fill: 'yellow' }
+    const whiteRule = createWhitePearlStrongInferenceRule(() => [])
+    const whiteEvents = observe((runtimeContext) =>
+      whiteRule.apply(whitePuzzle, runtimeContext),
+    )
+    expect(whiteEvents).toHaveLength(1)
+    expect(whiteEvents[0]).toMatchObject({
+      outcome: 'hit',
+      candidateCount: 1,
+      probeCount: 1,
+      producedDiffCount: 4,
+    })
+  })
+
+  it('keeps internal trial attempts unobserved and isolates observer errors', () => {
+    const puzzle = createMasyuPuzzle(5, 5)
+    addPearl(puzzle, 2, 2, 'black')
+    const north = lineKey([1, 2], [2, 2])
+    const west = lineKey([1, 1], [1, 2])
+    const east = lineKey([1, 2], [1, 3])
+    const downstreamRule: Rule = {
+      id: 'test-downstream',
+      name: 'Test Downstream',
+      apply: (trial) =>
+        trial.lines[north]?.mark === 'line'
+          ? {
+              message: 'contradiction',
+              diffs: [
+                { kind: 'line', lineKey: west, from: 'unknown', to: 'line' },
+                { kind: 'line', lineKey: east, from: 'unknown', to: 'line' },
+              ],
+              affectedCells: [],
+            }
+          : null,
+    }
+    const strongRule = createBlackPearlStrongInferenceRule(() => [
+      downstreamRule,
+    ])
+    const ruleAttempts: string[] = []
+    const strongEvents: StrongInferenceCompletedEvent[] = []
+
+    const observed = runNextRule(puzzle, [strongRule], 9, {
+      observer: {
+        onRuleAttemptCompleted: (event) => ruleAttempts.push(event.ruleId),
+        onStrongInferenceCompleted: (event) => strongEvents.push(event),
+      },
+    })
+    const throwing = runNextRule(puzzle, [strongRule], 9, {
+      observer: {
+        onRuleAttemptCompleted: () => {
+          throw new Error('rule observer failed')
+        },
+        onStrongInferenceCompleted: () => {
+          throw new Error('strong observer failed')
+        },
+      },
+    })
+
+    expect(ruleAttempts).toEqual([strongRule.id])
+    expect(strongEvents).toHaveLength(1)
+    expect(strongEvents[0]).toMatchObject({
+      solverStepNumber: 9,
+      ruleId: strongRule.id,
+      outcome: 'hit',
+      trialStepCount: 1,
+    })
+    expect(throwing.step?.diffs).toEqual(observed.step?.diffs)
+    expect(throwing.nextPuzzle).toEqual(observed.nextPuzzle)
+  })
+})
diff --git a/src/domain/rules/masyu/tests/whitePearlStrongInference.test.ts b/src/domain/rules/masyu/tests/whitePearlStrongInference.test.ts
index 8d87243..aac432d 100644
--- a/src/domain/rules/masyu/tests/whitePearlStrongInference.test.ts
+++ b/src/domain/rules/masyu/tests/whitePearlStrongInference.test.ts
@@ -128,6 +128,63 @@ describe('Masyu white pearl strong inference', () => {
     expect(puzzle.lines[unrelated]?.mark).toBe('unknown')
   })
 
+  it('does not retry settled white-axis trials at higher budgets', () => {
+    const puzzle = createMasyuPuzzle(5, 5)
+    addPearl(puzzle, 2, 2, 'white')
+    let attempts = 0
+    const settledRule: Rule = {
+      id: 'test-settled-white-trial',
+      name: 'Test Settled White Trial',
+      apply: () => {
+        attempts += 1
+        return null
+      },
+    }
+
+    const result = createWhitePearlStrongInferenceRule(() => [settledRule], {
+      maxCandidates: 1,
+      maxTrialSteps: 13,
+    }).apply(puzzle)
+
+    expect(result).toBeNull()
+    expect(attempts).toBe(2)
+  })
+
+  it('retries budget-limited white-axis trials at the next budget', () => {
+    const puzzle = createMasyuPuzzle(5, 5)
+    addPearl(puzzle, 2, 2, 'white')
+    const targetCell = cellKey(0, 0)
+    let attempts = 0
+    const progressingRule: Rule = {
+      id: 'test-budget-limited-white-trial',
+      name: 'Test Budget Limited White Trial',
+      apply: (trial) => {
+        attempts += 1
+        const fromFill = trial.cells[targetCell]?.fill ?? null
+        return {
+          message: 'Keep the white trial progressing',
+          diffs: [
+            {
+              kind: 'cell',
+              cellKey: targetCell,
+              fromFill,
+              toFill: fromFill === 'a' ? 'b' : 'a',
+            },
+          ],
+          affectedCells: [targetCell],
+        }
+      },
+    }
+
+    const result = createWhitePearlStrongInferenceRule(
+      () => [progressingRule],
+      { maxCandidates: 1, maxTrialSteps: 13 },
+    ).apply(puzzle)
+
+    expect(result).toBeNull()
+    expect(attempts).toBe(50)
+  })
+
   it('returns null when the white trial budget times out', () => {
     const puzzle = createMasyuPuzzle(5, 5)
     addPearl(puzzle, 2, 2, 'white')
diff --git a/src/domain/rules/ruleAttemptObserverContract.test.ts b/src/domain/rules/ruleAttemptObserverContract.test.ts
new file mode 100644
index 0000000..84d04ff
--- /dev/null
+++ b/src/domain/rules/ruleAttemptObserverContract.test.ts
@@ -0,0 +1,110 @@
+import { describe, expect, it } from 'vitest'
+import masyuRaw from '../../../dataset/public/masyu.json?raw'
+import { analyzeMasyuCompletion } from './masyu/completion'
+import { deterministicMasyuRules } from './masyu/rules'
+import { decodeMasyuFromPuzzlink } from '../parsers/puzzlink'
+import { runNextRule } from './engine'
+import { createRuleAttemptSummaryCollector } from './ruleAttemptSummaryCollector'
+import type { BenchmarkDatasetManifest } from '../benchmark/types'
+import type { RuleStep, SolverObserver } from './types'
+
+const caseIds = ['masyu-20x20-8268975', 'masyu-25x25-988309']
+const manifest = JSON.parse(masyuRaw) as BenchmarkDatasetManifest
+
+const normalizeAttempts = (step: RuleStep) =>
+  step.ruleAttempts?.map(({ ruleId, ruleName, hit }) => ({
+    ruleId,
+    ruleName,
+    hit,
+  }))
+
+const solveDeterministically = (
+  sourceUrl: string,
+  observer?: SolverObserver,
+) => {
+  let puzzle = decodeMasyuFromPuzzlink(sourceUrl)
+  const steps: RuleStep[] = []
+  const ruleUsage: Record<string, number> = {}
+  const ruleSteps: Record<string, number[]> = {}
+
+  while (true) {
+    const result = runNextRule(
+      puzzle,
+      deterministicMasyuRules,
+      steps.length + 1,
+      { observer },
+    )
+    if (!result.step) {
+      return {
+        puzzle,
+        steps,
+        ruleUsage,
+        ruleSteps,
+        terminal: analyzeMasyuCompletion(puzzle),
+      }
+    }
+
+    puzzle = result.nextPuzzle
+    steps.push(result.step)
+    ruleUsage[result.step.ruleId] = (ruleUsage[result.step.ruleId] ?? 0) + 1
+    ruleSteps[result.step.ruleId] = [
+      ...(ruleSteps[result.step.ruleId] ?? []),
+      steps.length,
+    ]
+  }
+}
+
+describe.each(caseIds)('rule attempt observer contract: %s', (caseId) => {
+  it('preserves deterministic solve behavior and produces a consistent summary', () => {
+    const item = manifest.items.find((candidate) => candidate.id === caseId)
+    expect(item).toBeDefined()
+
+    const baseline = solveDeterministically(item!.sourceUrl)
+    const collector = createRuleAttemptSummaryCollector()
+    const observed = solveDeterministically(item!.sourceUrl, collector.observer)
+    const summary = collector.getSummary()
+
+    expect(observed.puzzle).toEqual(baseline.puzzle)
+    expect(observed.terminal).toEqual(baseline.terminal)
+    expect(observed.steps.map((step) => step.ruleId)).toEqual(
+      baseline.steps.map((step) => step.ruleId),
+    )
+    expect(observed.steps.map((step) => step.diffs)).toEqual(
+      baseline.steps.map((step) => step.diffs),
+    )
+    expect(observed.steps.map(normalizeAttempts)).toEqual(
+      baseline.steps.map(normalizeAttempts),
+    )
+    expect(observed.ruleUsage).toEqual(baseline.ruleUsage)
+    expect(observed.ruleSteps).toEqual(baseline.ruleSteps)
+
+    const ruleSummaries = Object.values(summary.rules)
+    expect(
+      ruleSummaries.reduce((total, rule) => total + rule.attemptCount, 0),
+    ).toBe(summary.totalAttemptCount)
+    expect(
+      ruleSummaries.reduce((total, rule) => total + rule.hitCount, 0),
+    ).toBe(observed.steps.length)
+    expect(
+      ruleSummaries.reduce((total, rule) => total + rule.producedDiffCount, 0),
+    ).toBe(observed.steps.reduce((total, step) => total + step.diffs.length, 0))
+    expect(
+      ruleSummaries.every(
+        (rule) =>
+          rule.totalDurationMs >= 0 &&
+          rule.hitDurationMs >= 0 &&
+          rule.missDurationMs >= 0 &&
+          rule.averageDurationMs >= 0,
+      ),
+    ).toBe(true)
+    expect(summary.finalNoHitScan?.solverStepNumber).toBe(
+      observed.steps.length + 1,
+    )
+    expect(summary.finalNoHitScan?.rules.map((rule) => rule.ruleId)).toEqual(
+      deterministicMasyuRules.map((rule) => rule.id),
+    )
+    expect(summary.finalNoHitScan?.attemptCount).toBe(
+      deterministicMasyuRules.length,
+    )
+  }, 20_000)
+})
diff --git a/src/domain/rules/ruleAttemptSummaryCollector.test.ts b/src/domain/rules/ruleAttemptSummaryCollector.test.ts
new file mode 100644
index 0000000..623201f
--- /dev/null
+++ b/src/domain/rules/ruleAttemptSummaryCollector.test.ts
@@ -0,0 +1,145 @@
+import { describe, expect, it } from 'vitest'
+import { createRuleAttemptSummaryCollector } from './ruleAttemptSummaryCollector'
+import type { RuleAttemptEvent } from './types'
+
+const emit = (
+  collector: ReturnType<typeof createRuleAttemptSummaryCollector>,
+  event: RuleAttemptEvent,
+): void => {
+  collector.observer.onRuleAttemptCompleted?.(event)
+}
+
+describe('rule attempt summary collector', () => {
+  it('summarizes attempts, durations, hit rate, and produced diffs', () => {
+    const collector = createRuleAttemptSummaryCollector()
+
+    emit(collector, {
+      solverStepNumber: 1,
+      ruleId: 'rule-a',
+      ruleName: 'Rule A',
+      hit: false,
+      durationMs: 2,
+      producedDiffCount: 0,
+    })
+    emit(collector, {
+      solverStepNumber: 1,
+      ruleId: 'rule-b',
+      ruleName: 'Rule B',
+      hit: true,
+      durationMs: 6,
+      producedDiffCount: 3,
+    })
+    emit(collector, {
+      solverStepNumber: 2,
+      ruleId: 'rule-a',
+      ruleName: 'Rule A',
+      hit: true,
+      durationMs: 4,
+      producedDiffCount: 2,
+    })
+
+    expect(collector.getSummary()).toEqual({
+      totalAttemptCount: 3,
+      rules: {
+        'rule-a': {
+          ruleId: 'rule-a',
+          ruleName: 'Rule A',
+          attemptCount: 2,
+          hitCount: 1,
+          missCount: 1,
+          hitRate: 0.5,
+          totalDurationMs: 6,
+          hitDurationMs: 4,
+          missDurationMs: 2,
+          averageDurationMs: 3,
+          producedDiffCount: 2,
+        },
+        'rule-b': {
+          ruleId: 'rule-b',
+          ruleName: 'Rule B',
+          attemptCount: 1,
+          hitCount: 1,
+          missCount: 0,
+          hitRate: 1,
+          totalDurationMs: 6,
+          hitDurationMs: 6,
+          missDurationMs: 0,
+          averageDurationMs: 6,
+          producedDiffCount: 3,
+        },
+      },
+      finalNoHitScan: null,
+    })
+  })
+
+  it('reports the latest all-miss step as the final no-hit scan', () => {
+    const collector = createRuleAttemptSummaryCollector()
+
+    emit(collector, {
+      solverStepNumber: 4,
+      ruleId: 'rule-a',
+      ruleName: 'Rule A',
+      hit: false,
+      durationMs: 2,
+      producedDiffCount: 0,
+    })
+    emit(collector, {
+      solverStepNumber: 4,
+      ruleId: 'rule-b',
+      ruleName: 'Rule B',
+      hit: false,
+      durationMs: 5,
+      producedDiffCount: 0,
+    })
+
+    expect(collector.getSummary().finalNoHitScan).toEqual({
+      solverStepNumber: 4,
+      totalDurationMs: 7,
+      attemptCount: 2,
+      rules: [
+        { ruleId: 'rule-a', ruleName: 'Rule A', durationMs: 2 },
+        { ruleId: 'rule-b', ruleName: 'Rule B', durationMs: 5 },
+      ],
+    })
+  })
+
+  it('returns no final scan when empty or when the latest step hit', () => {
+    const emptyCollector = createRuleAttemptSummaryCollector()
+    expect(emptyCollector.getSummary()).toEqual({
+      totalAttemptCount: 0,
+      rules: {},
+      finalNoHitScan: null,
+    })
+
+    const hitCollector = createRuleAttemptSummaryCollector()
+    emit(hitCollector, {
+      solverStepNumber: 1,
+      ruleId: 'rule-a',
+      ruleName: 'Rule A',
+      hit: true,
+      durationMs: 1,
+      producedDiffCount: 1,
+    })
+    expect(hitCollector.getSummary().finalNoHitScan).toBeNull()
+  })
+
+  it('returns defensive summary snapshots', () => {
+    const collector = createRuleAttemptSummaryCollector()
+    emit(collector, {
+      solverStepNumber: 1,
+      ruleId: 'rule-a',
+      ruleName: 'Rule A',
+      hit: false,
+      durationMs: 2,
+      producedDiffCount: 0,
+    })
+
+    const first = collector.getSummary()
+    first.rules['rule-a'].attemptCount = 99
+    first.finalNoHitScan!.rules[0].durationMs = 99
+
+    const second = collector.getSummary()
+    expect(second.rules['rule-a'].attemptCount).toBe(1)
+    expect(second.finalNoHitScan?.rules[0].durationMs).toBe(2)
+  })
+})
diff --git a/src/domain/rules/ruleAttemptSummaryCollector.ts b/src/domain/rules/ruleAttemptSummaryCollector.ts
new file mode 100644
index 0000000..4f0b6ca
--- /dev/null
+++ b/src/domain/rules/ruleAttemptSummaryCollector.ts
@@ -0,0 +1,135 @@
+import type { RuleAttemptEvent, SolverObserver } from './types'
+
+export type RuleAttemptRuleSummary = {
+  ruleId: string
+  ruleName: string
+  attemptCount: number
+  hitCount: number
+  missCount: number
+  hitRate: number
+  totalDurationMs: number
+  hitDurationMs: number
+  missDurationMs: number
+  averageDurationMs: number
+  producedDiffCount: number
+}
+
+export type FinalNoHitScanRuleSummary = {
+  ruleId: string
+  ruleName: string
+  durationMs: number
+}
+
+export type FinalNoHitScanSummary = {
+  solverStepNumber: number
+  totalDurationMs: number
+  attemptCount: number
+  rules: FinalNoHitScanRuleSummary[]
+}
+
+export type RuleAttemptSummary = {
+  totalAttemptCount: number
+  rules: Record<string, RuleAttemptRuleSummary>
+  finalNoHitScan: FinalNoHitScanSummary | null
+}
+
+export type RuleAttemptSummaryCollector = {
+  observer: SolverObserver
+  getSummary: () => RuleAttemptSummary
+}
+
+type MutableRuleSummary = Omit<
+  RuleAttemptRuleSummary,
+  'hitRate' | 'averageDurationMs'
+>
+
+export const createRuleAttemptSummaryCollector =
+  (): RuleAttemptSummaryCollector => {
+    let totalAttemptCount = 0
+    const rules = new Map<string, MutableRuleSummary>()
+    let currentStepNumber: number | null = null
+    let currentStepEvents: RuleAttemptEvent[] = []
+
+    const observer: SolverObserver = {
+      onRuleAttemptCompleted: (event) => {
+        totalAttemptCount += 1
+        const existing = rules.get(event.ruleId) ?? {
+          ruleId: event.ruleId,
+          ruleName: event.ruleName,
+          attemptCount: 0,
+          hitCount: 0,
+          missCount: 0,
+          totalDurationMs: 0,
+          hitDurationMs: 0,
+          missDurationMs: 0,
+          producedDiffCount: 0,
+        }
+
+        existing.attemptCount += 1
+        existing.totalDurationMs += event.durationMs
+        existing.producedDiffCount += event.producedDiffCount
+        if (event.hit) {
+          existing.hitCount += 1
+          existing.hitDurationMs += event.durationMs
+        } else {
+          existing.missCount += 1
+          existing.missDurationMs += event.durationMs
+        }
+        rules.set(event.ruleId, existing)
+
+        if (currentStepNumber !== event.solverStepNumber) {
+          currentStepNumber = event.solverStepNumber
+          currentStepEvents = []
+        }
+        currentStepEvents.push({ ...event })
+      },
+    }
+
+    return {
+      observer,
+      getSummary: () => {
+        const ruleSummaries = Object.fromEntries(
+          Array.from(rules.entries(), ([ruleId, rule]) => [
+            ruleId,
+            {
+              ...rule,
+              hitRate:
+                rule.attemptCount === 0 ? 0 : rule.hitCount / rule.attemptCount,
+              averageDurationMs:
+                rule.attemptCount === 0
+                  ? 0
+                  : rule.totalDurationMs / rule.attemptCount,
+            },
+          ]),
+        )
+        const isFinalNoHitScan =
+          currentStepNumber !== null &&
+          currentStepEvents.length > 0 &&
+          currentStepEvents.every((event) => !event.hit)
+        let finalNoHitScan: FinalNoHitScanSummary | null = null
+        if (isFinalNoHitScan && currentStepNumber !== null) {
+          finalNoHitScan = {
+            solverStepNumber: currentStepNumber,
+            totalDurationMs: currentStepEvents.reduce(
+              (total, event) => total + event.durationMs,
+              0,
+            ),
+            attemptCount: currentStepEvents.length,
+            rules: currentStepEvents.map(
+              ({ ruleId, ruleName, durationMs }) => ({
+                ruleId,
+                ruleName,
+                durationMs,
+              }),
+            ),
+          }
+        }
+
+        return {
+          totalAttemptCount,
+          rules: ruleSummaries,
+          finalNoHitScan,
+        }
+      },
+    }
+  }
diff --git a/src/domain/rules/slither/rules/color.ts b/src/domain/rules/slither/rules/color.ts
index 23dfe68..aeed818 100644
--- a/src/domain/rules/slither/rules/color.ts
+++ b/src/domain/rules/slither/rules/color.ts
@@ -23,7 +23,7 @@ import {
 
 export const createColorEdgePropagationRule = (): Rule => ({
   id: 'color-edge-propagation',
-  name: 'Color-Edge Propagation',
+  name: 'Color-Edge Consistency',
   apply: (puzzle: PuzzleIR): RuleApplication | null => {
     const decidedEdges = new Map<string, EdgeMark>()
     const decidedCellFills = new Map<string, SlitherCellColor>()
@@ -193,7 +193,7 @@ export const createColorEdgePropagationRule = (): Rule => ({
 
 export const createColorOutsideSeedingRule = (): Rule => ({
   id: 'color-outside-seeding',
-  name: 'Color Outside Seeding',
+  name: 'Parity Component Coloring',
   apply: (puzzle: PuzzleIR): RuleApplication | null => {
     type Parity = 0 | 1
 
@@ -367,7 +367,7 @@ export const createColorOutsideSeedingRule = (): Rule => ({
 
 export const createColorCluePropagationRule = (): Rule => ({
   id: 'color-clue-propagation',
-  name: 'Color Clue Propagation',
+  name: 'Clue Inside/Outside Counting',
   apply: (puzzle: PuzzleIR): RuleApplication | null => {
     const decidedCellFills = new Map<string, SlitherCellColor>()
     const affectedCells = new Set<string>()
@@ -482,7 +482,7 @@ export const createColorCluePropagationRule = (): Rule => ({
 
 export const createColorOrthogonalConsensusPropagationRule = (): Rule => ({
   id: 'color-orthogonal-consensus-propagation',
-  name: 'Color Orthogonal Consensus Propagation',
+  name: 'Orthogonal Color Consensus',
   apply: (puzzle: PuzzleIR): RuleApplication | null => {
     const decidedCellFills = new Map<string, SlitherCellColor>()
     const affectedCells = new Set<string>()
@@ -1139,7 +1139,7 @@ const getCornerOutsideNeighbors = (row: number, col: number, corner: SectorCorne
 
 export const createColorSectorMaskPropagationRule = (): Rule => ({
   id: 'color-sector-mask-propagation',
-  name: 'Color Sector-Mask Propagation',
+  name: 'Sector-Color Consistency',
   apply: (puzzle: PuzzleIR): RuleApplication | null => {
     const corners: SectorCorner[] = ['nw', 'ne', 'sw', 'se']
     const decidedCellFills = new Map<string, SlitherCellColor>()
diff --git a/src/domain/rules/slither/rules/patterns.ts b/src/domain/rules/slither/rules/patterns.ts
index 06a991a..c7e878d 100644
--- a/src/domain/rules/slither/rules/patterns.ts
+++ b/src/domain/rules/slither/rules/patterns.ts
@@ -5,7 +5,7 @@ import { formatCellRunLabel, isClueThree } from './shared'
 
 export const createContiguousThreeRunBoundariesRule = (): Rule => ({
   id: 'contiguous-three-run-boundaries',
-  name: 'Contiguous 3-Run Boundaries',
+  name: 'Adjacent 3s',
   apply: (puzzle: PuzzleIR): RuleApplication | null => {
     const decidedEdges = new Map<string, EdgeMark>()
     const allAffectedCells = new Set<string>()
@@ -41,7 +41,11 @@ export const createContiguousThreeRunBoundariesRule = (): Rule => ({
         }
 
         let runAddedAny = false
-        for (let boundaryCol = cStart; boundaryCol <= cEnd + 1; boundaryCol += 1) {
+        for (
+          let boundaryCol = cStart;
+          boundaryCol <= cEnd + 1;
+          boundaryCol += 1
+        ) {
           const key = edgeKey([r, boundaryCol], [r + 1, boundaryCol])
           runAddedAny = decideUnknownEdge(key, 'line') || runAddedAny
         }
@@ -58,8 +62,10 @@ export const createContiguousThreeRunBoundariesRule = (): Rule => ({
         }
 
         if (runAddedAny) {
-          for (let col = cStart; col <= cEnd; col += 1) allAffectedCells.add(cellKey(r, col))
-          if (firstExample === null) firstExample = formatCellRunLabel('row', r, cStart, cEnd)
+          for (let col = cStart; col <= cEnd; col += 1)
+            allAffectedCells.add(cellKey(r, col))
+          if (firstExample === null)
+            firstExample = formatCellRunLabel('row', r, cStart, cEnd)
         }
       }
     }
@@ -81,7 +87,11 @@ export const createContiguousThreeRunBoundariesRule = (): Rule => ({
         }
 
         let runAddedAny = false
-        for (let boundaryRow = rStart; boundaryRow <= rEnd + 1; boundaryRow += 1) {
+        for (
+          let boundaryRow = rStart;
+          boundaryRow <= rEnd + 1;
+          boundaryRow += 1
+        ) {
           const key = edgeKey([boundaryRow, c], [boundaryRow, c + 1])
           runAddedAny = decideUnknownEdge(key, 'line') || runAddedAny
         }
@@ -98,8 +108,10 @@ export const createContiguousThreeRunBoundariesRule = (): Rule => ({
         }
 
         if (runAddedAny) {
-          for (let row = rStart; row <= rEnd; row += 1) allAffectedCells.add(cellKey(row, c))
-          if (firstExample === null) firstExample = formatCellRunLabel('col', c, rStart, rEnd)
+          for (let row = rStart; row <= rEnd; row += 1)
+            allAffectedCells.add(cellKey(row, c))
+          if (firstExample === null)
+            firstExample = formatCellRunLabel('col', c, rStart, rEnd)
         }
       }
     }
@@ -109,8 +121,8 @@ export const createContiguousThreeRunBoundariesRule = (): Rule => ({
     return {
       message:
         firstExample !== null
-          ? `Contiguous 3-run at ${firstExample}: the 3-clues need the run boundary lines, so straight extensions outside the run are blank.`
-          : 'Contiguous 3-run: the 3-clues need the run boundary lines, so straight extensions outside the run are blank.',
+          ? `Adjacent 3s at ${firstExample}: every edge perpendicular to the run is a line, and each shared edge cannot continue straight beyond the run.`
+          : 'Adjacent 3s: every edge perpendicular to the run is a line, and each shared edge cannot continue straight beyond the run.',
       diffs: [...decidedEdges.entries()].map(([k, to]) => ({
         kind: 'edge' as const,
         edgeKey: k,
@@ -124,15 +136,17 @@ export const createContiguousThreeRunBoundariesRule = (): Rule => ({
 
 export const createDiagonalAdjacentThreeOuterCornersRule = (): Rule => ({
   id: 'diagonal-adjacent-three-outer-corners',
-  name: 'Diagonal Adjacent 3 Outer Corners',
+  name: 'Diagonal 3s',
   apply: (puzzle: PuzzleIR): RuleApplication | null => {
     const decidedEdges = new Map<string, EdgeMark>()
     const allAffectedCells = new Set<string>()
 
     for (let r = 0; r < puzzle.rows - 1; r += 1) {
       for (let c = 0; c < puzzle.cols - 1; c += 1) {
-        const mainDiagonal = isClueThree(puzzle, r, c) && isClueThree(puzzle, r + 1, c + 1)
-        const antiDiagonal = isClueThree(puzzle, r, c + 1) && isClueThree(puzzle, r + 1, c)
+        const mainDiagonal =
+          isClueThree(puzzle, r, c) && isClueThree(puzzle, r + 1, c + 1)
+        const antiDiagonal =
+          isClueThree(puzzle, r, c + 1) && isClueThree(puzzle, r + 1, c)
         if (!mainDiagonal && !antiDiagonal) {
           continue
         }
@@ -155,7 +169,10 @@ export const createDiagonalAdjacentThreeOuterCornersRule = (): Rule => ({
 
         let positionAddedAny = false
         for (const key of candidateEdgeKeys) {
-          if ((puzzle.edges[key]?.mark ?? 'unknown') === 'unknown' && !decidedEdges.has(key)) {
+          if (
+            (puzzle.edges[key]?.mark ?? 'unknown') === 'unknown' &&
+            !decidedEdges.has(key)
+          ) {
             decidedEdges.set(key, 'line')
             positionAddedAny = true
           }
@@ -177,7 +194,8 @@ export const createDiagonalAdjacentThreeOuterCornersRule = (): Rule => ({
     if (decidedEdges.size === 0) return null
 
     return {
-      message: 'Diagonal adjacent 3s force their outside corner edges to be lines; otherwise one of the 3-clues cannot reach three lines.',
+      message:
+        'Diagonal 3s force the two outer-corner edges of each clue to be lines; otherwise one of the clues cannot reach three lines.',
       diffs: [...decidedEdges.entries()].map(([k, to]) => ({
         kind: 'edge' as const,
         edgeKey: k,
@@ -189,9 +207,15 @@ export const createDiagonalAdjacentThreeOuterCornersRule = (): Rule => ({
   },
 })
 
-const getNumberClueValue = (puzzle: PuzzleIR, row: number, col: number): number | null => {
+const getNumberClueValue = (
+  puzzle: PuzzleIR,
+  row: number,
+  col: number,
+): number | null => {
   const clue = puzzle.cells[cellKey(row, col)]?.clue
-  return clue?.kind === 'number' && clue.value !== '?' ? Number(clue.value) : null
+  return clue?.kind === 'number' && clue.value !== '?'
+    ? Number(clue.value)
+    : null
 }
 
 export const createAdjacentTwoThreeOppositeCrossRule = (): Rule => ({
@@ -216,8 +240,10 @@ export const createAdjacentTwoThreeOppositeCrossRule = (): Rule => ({
       return true
     }
 
-    const verticalEdge = (row: number, col: number): string => edgeKey([row, col], [row + 1, col])
-    const horizontalEdge = (row: number, col: number): string => edgeKey([row, col], [row, col + 1])
+    const verticalEdge = (row: number, col: number): string =>
+      edgeKey([row, col], [row + 1, col])
+    const horizontalEdge = (row: number, col: number): string =>
+      edgeKey([row, col], [row, col + 1])
 
     const applyPair = (
       twoRow: number,
@@ -234,7 +260,10 @@ export const createAdjacentTwoThreeOppositeCrossRule = (): Rule => ({
       if (rowDelta === 0) {
         const sharedCol = colDelta === 1 ? twoCol + 1 : twoCol
         twoOpposite = verticalEdge(twoRow, colDelta === 1 ? twoCol : twoCol + 1)
-        threeOpposite = verticalEdge(threeRow, colDelta === 1 ? threeCol + 1 : threeCol)
+        threeOpposite = verticalEdge(
+          threeRow,
+          colDelta === 1 ? threeCol + 1 : threeCol,
+        )
         if (twoRow > 0) {
           extensionEdges.push(verticalEdge(twoRow - 1, sharedCol))
         }
@@ -243,8 +272,14 @@ export const createAdjacentTwoThreeOppositeCrossRule = (): Rule => ({
         }
       } else {
         const sharedRow = rowDelta === 1 ? twoRow + 1 : twoRow
-        twoOpposite = horizontalEdge(rowDelta === 1 ? twoRow : twoRow + 1, twoCol)
-        threeOpposite = horizontalEdge(rowDelta === 1 ? threeRow + 1 : threeRow, threeCol)
+        twoOpposite = horizontalEdge(
+          rowDelta === 1 ? twoRow : twoRow + 1,
+          twoCol,
+        )
+        threeOpposite = horizontalEdge(
+          rowDelta === 1 ? threeRow + 1 : threeRow,
+          threeCol,
+        )
         if (twoCol > 0) {
           extensionEdges.push(horizontalEdge(sharedRow, twoCol - 1))
         }
diff --git a/src/domain/rules/slither/rules/sectorInference.ts b/src/domain/rules/slither/rules/sectorInference.ts
index b9aaaca..278b493 100644
--- a/src/domain/rules/slither/rules/sectorInference.ts
+++ b/src/domain/rules/slither/rules/sectorInference.ts
@@ -138,7 +138,7 @@ const inferSectorMaskByVertex = (
 
 export const createApplySectorsInference = (): Rule => ({
   id: 'sector-inference',
-  name: 'Apply Vertex Flow Sector Inference',
+  name: 'Corner Sector Inference',
   apply: (puzzle: PuzzleIR): RuleApplication | null => {
     const corners: SectorCorner[] = ['nw', 'ne', 'sw', 'se']
     const diffs: RuleApplication['diffs'] = []
diff --git a/src/domain/rules/slither/rules/sectorPropagation.ts b/src/domain/rules/slither/rules/sectorPropagation.ts
index 4e57c15..4bb631f 100644
--- a/src/domain/rules/slither/rules/sectorPropagation.ts
+++ b/src/domain/rules/slither/rules/sectorPropagation.ts
@@ -120,7 +120,7 @@ const addVertexDiff = (
 
 export const createVertexCandidateEdgePruningRule = (): Rule => ({
   id: 'vertex-candidate-edge-pruning',
-  name: 'Vertex Candidate Edge Pruning',
+  name: 'Vertex Candidate Pruning',
   apply: (puzzle: PuzzleIR): RuleApplication | null => {
     const diffs: RuleApplication['diffs'] = []
     const decidedEdges = new Map<string, EdgeMark>()
@@ -167,7 +167,7 @@ export const createVertexCandidateEdgePruningRule = (): Rule => ({
 
     return {
       message:
-        'Vertex candidate pruning removed degree-0/degree-2 states that conflict with known edges, then forced edges shared by every remaining state.',
+        'Impossible degree states were removed at one or more vertices, and edges agreed on by every remaining candidate were decided.',
       diffs,
       affectedCells: [],
     }
@@ -200,7 +200,7 @@ const cornerLineCountFromCandidates = (
 
 export const createClueVertexCandidateCombinationPruningRule = (): Rule => ({
   id: 'clue-vertex-candidate-combination-pruning',
-  name: 'Clue Vertex Candidate Combination Pruning',
+  name: 'Clue Combination Pruning',
   apply: (puzzle: PuzzleIR): RuleApplication | null => {
     const diffs: RuleApplication['diffs'] = []
     const nextVertexCandidates = new Map<string, VertexCandidate[]>()
@@ -342,7 +342,7 @@ export const createClueVertexCandidateCombinationPruningRule = (): Rule => ({
 
     return {
       message:
-        'Only clue-compatible corner combinations survive, so unsupported vertex states and sector counts are removed.',
+        'Only clue-compatible four-corner combinations survive, so unsupported vertex candidates and sector counts are removed.',
       diffs,
       affectedCells: [...affectedCells],
       affectedSectors: [...affectedSectors],
@@ -352,7 +352,7 @@ export const createClueVertexCandidateCombinationPruningRule = (): Rule => ({
 
 export const createSectorDiagonalSharedVertexPropagationRule = (): Rule => ({
   id: 'sector-diagonal-shared-vertex-propagation',
-  name: 'Sector Diagonal Shared Vertex Propagation',
+  name: 'Diagonal Sector Propagation',
   apply: (puzzle: PuzzleIR): RuleApplication | null => {
     const diagonalCases: Array<{
       sourceCorner: SectorCorner
diff --git a/src/domain/rules/slither/rules/strongInference.ts b/src/domain/rules/slither/rules/strongInference.ts
index 38c1596..f3be90f 100644
--- a/src/domain/rules/slither/rules/strongInference.ts
+++ b/src/domain/rules/slither/rules/strongInference.ts
@@ -273,7 +273,7 @@ export const createStrongInferenceRule = (
   options: StrongInferenceOptions = {},
 ): Rule => ({
   id: 'strong-inference',
-  name: 'Strong Inference (Conservative)',
+  name: 'Strong Inference',
   apply: (puzzle: PuzzleIR): RuleApplication | null => {
     const deterministicRules = getDeterministicRules()
     const candidates = collectStrongCandidates(puzzle, options.maxCandidates ?? STRONG_MAX_CANDIDATES)
diff --git a/src/domain/rules/slither/tests/patterns.test.ts b/src/domain/rules/slither/tests/patterns.test.ts
index a003a7c..38e12cf 100644
--- a/src/domain/rules/slither/tests/patterns.test.ts
+++ b/src/domain/rules/slither/tests/patterns.test.ts
@@ -23,7 +23,7 @@ describe('slither contiguous 3-run boundaries rule', () => {
     const result = threeRunRule.apply(puzzle)
 
     expect(result).not.toBeNull()
-    expect(result?.message).toContain('Contiguous 3-run')
+    expect(result?.message).toContain('Adjacent 3s')
     expect(result?.affectedCells).toEqual(['1,1', '1,2', '1,3'])
     expect(result?.diffs).toEqual([
       {
@@ -86,7 +86,7 @@ describe('slither contiguous 3-run boundaries rule', () => {
     const result = threeRunRule.apply(puzzle)
 
     expect(result).not.toBeNull()
-    expect(result?.message).toContain('Contiguous 3-run')
+    expect(result?.message).toContain('Adjacent 3s')
     expect(result?.affectedCells).toEqual(['1,2', '2,2', '3,2'])
     expect(result?.diffs).toEqual([
       {
@@ -264,7 +264,7 @@ describe('slither diagonal adjacent 3 outer corners rule', () => {
 
     expect(result).not.toBeNull()
     expect(result?.message).toContain(
-      'Diagonal adjacent 3s force their outside corner edges',
+      'Diagonal 3s force the two outer-corner edges',
     )
     expect(result?.affectedCells).toEqual(['0,0', '1,1'])
     expect(getEdgeDiffKeys(result)).toEqual([
@@ -284,7 +284,7 @@ describe('slither diagonal adjacent 3 outer corners rule', () => {
 
     expect(result).not.toBeNull()
     expect(result?.message).toContain(
-      'Diagonal adjacent 3s force their outside corner edges',
+      'Diagonal 3s force the two outer-corner edges',
     )
     expect(result?.affectedCells).toEqual(['0,1', '1,0'])
     expect(getEdgeDiffKeys(result)).toEqual([
diff --git a/src/domain/rules/strongInferenceSummaryCollector.test.ts b/src/domain/rules/strongInferenceSummaryCollector.test.ts
new file mode 100644
index 0000000..0dc68e2
--- /dev/null
+++ b/src/domain/rules/strongInferenceSummaryCollector.test.ts
@@ -0,0 +1,133 @@
+import { describe, expect, it } from 'vitest'
+import { createStrongInferenceSummaryCollector } from './strongInferenceSummaryCollector'
+import type { StrongInferenceCompletedEvent } from './types'
+
+const emit = (
+  collector: ReturnType<typeof createStrongInferenceSummaryCollector>,
+  event: StrongInferenceCompletedEvent,
+): void => {
+  collector.observer.onStrongInferenceCompleted?.(event)
+}
+
+describe('strong inference summary collector', () => {
+  it('summarizes outcomes and work while preserving first-observed rule order', () => {
+    const collector = createStrongInferenceSummaryCollector()
+
+    emit(collector, {
+      solverStepNumber: 1,
+      ruleId: 'rule-b',
+      ruleName: 'Rule B',
+      candidateCount: 2,
+      probeCount: 3,
+      trialStepCount: 5,
+      probeDurationMs: 7,
+      outcome: 'miss',
+      producedDiffCount: 0,
+    })
+    emit(collector, {
+      solverStepNumber: 2,
+      ruleId: 'rule-a',
+      ruleName: 'Rule A',
+      candidateCount: 1,
+      probeCount: 1,
+      trialStepCount: 2,
+      probeDurationMs: 4,
+      outcome: 'hit',
+      producedDiffCount: 3,
+    })
+    emit(collector, {
+      solverStepNumber: 3,
+      ruleId: 'rule-b',
+      ruleName: 'Rule B',
+      candidateCount: 4,
+      probeCount: 2,
+      trialStepCount: 1,
+      probeDurationMs: 6,
+      outcome: 'timeout',
+      producedDiffCount: 0,
+    })
+
+    expect(collector.getSummary()).toEqual({
+      totals: {
+        attemptCount: 3,
+        hitCount: 1,
+        missCount: 1,
+        timeoutCount: 1,
+        hitRate: 1 / 3,
+        candidateCount: 7,
+        probeCount: 6,
+        trialStepCount: 8,
+        probeDurationMs: 17,
+        producedDiffCount: 3,
+      },
+      rules: [
+        {
+          ruleId: 'rule-b',
+          ruleName: 'Rule B',
+          attemptCount: 2,
+          hitCount: 0,
+          missCount: 1,
+          timeoutCount: 1,
+          hitRate: 0,
+          candidateCount: 6,
+          probeCount: 5,
+          trialStepCount: 6,
+          probeDurationMs: 13,
+          producedDiffCount: 0,
+        },
+        {
+          ruleId: 'rule-a',
+          ruleName: 'Rule A',
+          attemptCount: 1,
+          hitCount: 1,
+          missCount: 0,
+          timeoutCount: 0,
+          hitRate: 1,
+          candidateCount: 1,
+          probeCount: 1,
+          trialStepCount: 2,
+          probeDurationMs: 4,
+          producedDiffCount: 3,
+        },
+      ],
+    })
+  })
+
+  it('returns empty and defensive snapshots', () => {
+    const collector = createStrongInferenceSummaryCollector()
+    expect(collector.getSummary()).toEqual({
+      totals: {
+        attemptCount: 0,
+        hitCount: 0,
+        missCount: 0,
+        timeoutCount: 0,
+        hitRate: 0,
+        candidateCount: 0,
+        probeCount: 0,
+        trialStepCount: 0,
+        probeDurationMs: 0,
+        producedDiffCount: 0,
+      },
+      rules: [],
+    })
+
+    emit(collector, {
+      solverStepNumber: 1,
+      ruleId: 'rule-a',
+      ruleName: 'Rule A',
+      candidateCount: 1,
+      probeCount: 2,
+      trialStepCount: 3,
+      probeDurationMs: 4,
+      outcome: 'hit',
+      producedDiffCount: 1,
+    })
+    const first = collector.getSummary()
+    first.totals.attemptCount = 99
+    first.rules[0].probeCount = 99
+
+    const second = collector.getSummary()
+    expect(second.totals.attemptCount).toBe(1)
+    expect(second.rules[0].probeCount).toBe(2)
+  })
+})
diff --git a/src/domain/rules/strongInferenceSummaryCollector.ts b/src/domain/rules/strongInferenceSummaryCollector.ts
new file mode 100644
index 0000000..ce93c50
--- /dev/null
+++ b/src/domain/rules/strongInferenceSummaryCollector.ts
@@ -0,0 +1,105 @@
+import type { SolverObserver, StrongInferenceCompletedEvent } from './types'
+
+export type StrongInferenceTotals = {
+  attemptCount: number
+  hitCount: number
+  missCount: number
+  timeoutCount: number
+  hitRate: number
+  candidateCount: number
+  probeCount: number
+  trialStepCount: number
+  probeDurationMs: number
+  producedDiffCount: number
+}
+
+export type StrongInferenceRuleSummary = StrongInferenceTotals & {
+  ruleId: string
+  ruleName: string
+}
+
+export type StrongInferenceSummary = {
+  totals: StrongInferenceTotals
+  rules: StrongInferenceRuleSummary[]
+}
+
+export type StrongInferenceSummaryCollector = {
+  observer: SolverObserver
+  getSummary: () => StrongInferenceSummary
+}
+
+type MutableStrongInferenceTotals = Omit<StrongInferenceTotals, 'hitRate'>
+type MutableStrongInferenceRuleSummary = MutableStrongInferenceTotals & {
+  ruleId: string
+  ruleName: string
+}
+
+const emptyTotals = (): MutableStrongInferenceTotals => ({
+  attemptCount: 0,
+  hitCount: 0,
+  missCount: 0,
+  timeoutCount: 0,
+  candidateCount: 0,
+  probeCount: 0,
+  trialStepCount: 0,
+  probeDurationMs: 0,
+  producedDiffCount: 0,
+})
+
+const addEvent = (
+  summary: MutableStrongInferenceTotals,
+  event: StrongInferenceCompletedEvent,
+): void => {
+  summary.attemptCount += 1
+  summary.candidateCount += event.candidateCount
+  summary.probeCount += event.probeCount
+  summary.trialStepCount += event.trialStepCount
+  summary.probeDurationMs += event.probeDurationMs
+  summary.producedDiffCount += event.producedDiffCount
+  if (event.outcome === 'hit') {
+    summary.hitCount += 1
+  } else if (event.outcome === 'miss') {
+    summary.missCount += 1
+  } else {
+    summary.timeoutCount += 1
+  }
+}
+
+const snapshotTotals = (
+  totals: MutableStrongInferenceTotals,
+): StrongInferenceTotals => ({
+  ...totals,
+  hitRate:
+    totals.attemptCount === 0 ? 0 : totals.hitCount / totals.attemptCount,
+})
+
+export const createStrongInferenceSummaryCollector =
+  (): StrongInferenceSummaryCollector => {
+    const totals = emptyTotals()
+    const rules = new Map<string, MutableStrongInferenceRuleSummary>()
+
+    const observer: SolverObserver = {
+      onStrongInferenceCompleted: (event) => {
+        addEvent(totals, event)
+        const rule = rules.get(event.ruleId) ?? {
+          ...emptyTotals(),
+          ruleId: event.ruleId,
+          ruleName: event.ruleName,
+        }
+        addEvent(rule, event)
+        rules.set(event.ruleId, rule)
+      },
+    }
+
+    return {
+      observer,
+      getSummary: () => ({
+        totals: snapshotTotals(totals),
+        rules: Array.from(rules.values(), (rule) => ({
+          ruleId: rule.ruleId,
+          ruleName: rule.ruleName,
+          ...snapshotTotals(rule),
+        })),
+      }),
+    }
+  }
diff --git a/src/domain/rules/types.ts b/src/domain/rules/types.ts
index 2df6ea6..e8d5bb2 100644
--- a/src/domain/rules/types.ts
+++ b/src/domain/rules/types.ts
@@ -93,7 +93,11 @@ export type InferenceBranch = {
 }
 
 export type InferenceDetails = {
-  kind: 'slither-strong' | 'slither-color-assumption' | 'slither-sector-parity' | 'masyu-strong'
+  kind:
+    | 'slither-strong'
+    | 'slither-color-assumption'
+    | 'slither-sector-parity'
+    | 'masyu-strong'
   conclusion: 'opposite-branch' | 'shared-consequence'
   basePuzzle: PuzzleIR
   defaultBranchId: string
@@ -136,8 +140,38 @@ export type RuleAttempt = {
   hit: boolean
 }
 
+export type RuleAttemptEvent = RuleAttempt & {
+  solverStepNumber: number
+  producedDiffCount: number
+}
+
+export type StrongInferenceOutcome = 'hit' | 'miss' | 'timeout'
+
+export type StrongInferenceCompletedEvent = {
+  solverStepNumber: number
+  ruleId: string
+  ruleName: string
+  candidateCount: number
+  probeCount: number
+  trialStepCount: number
+  probeDurationMs: number
+  outcome: StrongInferenceOutcome
+  producedDiffCount: number
+}
+
+export type SolverObserver = {
+  onRuleAttemptCompleted?: (event: RuleAttemptEvent) => void
+  onStrongInferenceCompleted?: (event: StrongInferenceCompletedEvent) => void
+}
+
+export type RunNextRuleOptions = {
+  observer?: SolverObserver
+}
+
 export type RuleRuntimeContext = {
   cache: Map<string, unknown>
+  solverStepNumber: number
+  observer?: SolverObserver
 }
 
 export type Rule = {
diff --git a/src/features/board/BoardLegendButton.tsx b/src/features/board/BoardLegendButton.tsx
index 0693b03..c7a1568 100644
--- a/src/features/board/BoardLegendButton.tsx
+++ b/src/features/board/BoardLegendButton.tsx
@@ -56,6 +56,10 @@ const BoardLegendCanvas = ({ example, label }: { example: PuzzleLegendExample; l
     () => new Map((example.edges ?? []).map((edge) => [edgeKey(edge.edge), edge.mark])),
     [example.edges],
   )
+  const lineMarks = useMemo(
+    () => new Map((example.lines ?? []).map((line) => [edgeKey(line.edge), line.mark])),
+    [example.lines],
+  )
 
   useEffect(() => {
     const canvas = canvasRef.current
@@ -73,6 +77,9 @@ const BoardLegendCanvas = ({ example, label }: { example: PuzzleLegendExample; l
     const gridHeight = cellSize * example.rows
     const offsetX = (LEGEND_WIDTH - gridWidth) / 2
     const offsetY = (LEGEND_HEIGHT - gridHeight) / 2
+    const isMasyuExample = Boolean(
+      example.lines?.length || example.pearls?.length || example.filledTiles?.length,
+    )
 
     ctx.clearRect(0, 0, LEGEND_WIDTH, LEGEND_HEIGHT)
     ctx.fillStyle = '#ffffff'
@@ -84,9 +91,20 @@ const BoardLegendCanvas = ({ example, label }: { example: PuzzleLegendExample; l
       ctx.fillRect(offsetX + cell.col * cellSize, offsetY + cell.row * cellSize, cellSize, cellSize)
     }
 
-    ctx.strokeStyle = '#cbd5e1'
+    for (const tile of example.filledTiles ?? []) {
+      ctx.fillStyle =
+        tile.fill === 'green' ? 'rgba(34, 197, 94, 0.24)' : 'rgba(245, 158, 11, 0.24)'
+      ctx.fillRect(
+        offsetX + tile.col * cellSize - cellSize / 2,
+        offsetY + tile.row * cellSize - cellSize / 2,
+        cellSize,
+        cellSize,
+      )
+    }
+
+    ctx.strokeStyle = isMasyuExample ? '#94a3b8' : '#cbd5e1'
     ctx.lineWidth = 1
-    ctx.setLineDash([])
+    ctx.setLineDash(isMasyuExample ? [4, 4] : [])
     for (let row = 0; row <= example.rows; row += 1) {
       const y = offsetY + row * cellSize
       ctx.beginPath()
@@ -101,6 +119,13 @@ const BoardLegendCanvas = ({ example, label }: { example: PuzzleLegendExample; l
       ctx.lineTo(x, offsetY + gridHeight)
       ctx.stroke()
     }
+    ctx.setLineDash([])
+
+    if (isMasyuExample) {
+      ctx.strokeStyle = '#111827'
+      ctx.lineWidth = 2
+      ctx.strokeRect(offsetX, offsetY, gridWidth, gridHeight)
+    }
 
     for (const marker of example.sectors ?? []) {
       const baseX = offsetX + marker.col * cellSize
@@ -119,6 +144,37 @@ const BoardLegendCanvas = ({ example, label }: { example: PuzzleLegendExample; l
     }
     ctx.setLineDash([])
 
+    for (const [key, mark] of lineMarks) {
+      const [start, end] = key.split('-')
+      const [rowA, colA] = start.split(',').map(Number)
+      const [rowB, colB] = end.split(',').map(Number)
+      const x1 = offsetX + colA * cellSize + cellSize / 2
+      const y1 = offsetY + rowA * cellSize + cellSize / 2
+      const x2 = offsetX + colB * cellSize + cellSize / 2
+      const y2 = offsetY + rowB * cellSize + cellSize / 2
+
+      if (mark === 'line') {
+        ctx.strokeStyle = '#0284c7'
+        ctx.lineWidth = 3
+        ctx.beginPath()
+        ctx.moveTo(x1, y1)
+        ctx.lineTo(x2, y2)
+        ctx.stroke()
+      } else {
+        const midX = (x1 + x2) / 2
+        const midY = (y1 + y2) / 2
+        const crossSize = 4
+        ctx.strokeStyle = '#94a3b8'
+        ctx.lineWidth = 1.8
+        ctx.beginPath()
+        ctx.moveTo(midX - crossSize, midY - crossSize)
+        ctx.lineTo(midX + crossSize, midY + crossSize)
+        ctx.moveTo(midX + crossSize, midY - crossSize)
+        ctx.lineTo(midX - crossSize, midY + crossSize)
+        ctx.stroke()
+      }
+    }
+
     for (const [key, mark] of edgeMarks) {
       const [start, end] = key.split('-')
       const [rowA, colA] = start.split(',').map(Number)
@@ -162,15 +218,29 @@ const BoardLegendCanvas = ({ example, label }: { example: PuzzleLegendExample; l
       )
     }
 
+    for (const pearl of example.pearls ?? []) {
+      const centerX = offsetX + pearl.col * cellSize + cellSize / 2
+      const centerY = offsetY + pearl.row * cellSize + cellSize / 2
+      ctx.beginPath()
+      ctx.arc(centerX, centerY, cellSize * 0.28, 0, Math.PI * 2)
+      ctx.fillStyle = pearl.color === 'black' ? '#111827' : '#ffffff'
+      ctx.fill()
+      ctx.strokeStyle = '#111827'
+      ctx.lineWidth = 2.2
+      ctx.stroke()
+    }
+
     ctx.fillStyle = '#111827'
-    for (let row = 0; row <= example.rows; row += 1) {
-      for (let col = 0; col <= example.cols; col += 1) {
-        ctx.beginPath()
-        ctx.arc(offsetX + col * cellSize, offsetY + row * cellSize, 1.7, 0, Math.PI * 2)
-        ctx.fill()
+    if (!isMasyuExample) {
+      for (let row = 0; row <= example.rows; row += 1) {
+        for (let col = 0; col <= example.cols; col += 1) {
+          ctx.beginPath()
+          ctx.arc(offsetX + col * cellSize, offsetY + row * cellSize, 1.7, 0, Math.PI * 2)
+          ctx.fill()
+        }
       }
     }
-  }, [edgeMarks, example])
+  }, [edgeMarks, example, lineMarks])
 
   return <canvas ref={canvasRef} width={LEGEND_WIDTH} height={LEGEND_HEIGHT} aria-label={`${label} legend canvas`} />
 }
diff --git a/src/features/dataset/publicDatasets.test.ts b/src/features/dataset/publicDatasets.test.ts
index 608ef59..a3fe0dc 100644
--- a/src/features/dataset/publicDatasets.test.ts
+++ b/src/features/dataset/publicDatasets.test.ts
@@ -13,14 +13,20 @@ describe('public datasets', () => {
     const validated = validateBenchmarkManifest(manifest)
     expect(validated.puzzleType).toBe('masyu')
     expect(validated.title).toBe('Masyu Dataset')
-    expect(validated.items).toHaveLength(55)
-    expect(new Set(validated.items.map((item) => item.id)).size).toBe(55)
+    expect(validated.items).toHaveLength(56)
+    expect(new Set(validated.items.map((item) => item.id)).size).toBe(56)
 
     const existingItems = validated.items.slice(0, 37)
-    const newItems = validated.items.slice(37)
+    const newItems = validated.items.slice(37, -1)
+    const newestItem = validated.items.at(-1)
     expect(existingItems.every((item) => item.tags.includes('hard'))).toBe(true)
     expect(newItems.every((item) => item.tags.includes('easy'))).toBe(true)
     expect(newItems.every((item) => item.source === 'example.txt')).toBe(true)
+    expect(newestItem).toMatchObject({
+      id: 'masyu-25x25-1202688',
+      tags: ['hard', 'Large'],
+      source: 'example.txt',
+    })
     expect(newItems.map((item) => item.id)).toEqual([
       'masyu-15x21-0005',
       'masyu-10x10-0006',
@@ -52,7 +58,7 @@ describe('public datasets', () => {
       expect(item.puzzleType).toBe('masyu')
       expect(item.tags).toEqual([difficultyTag, sizeTag])
       expect(item.id).toMatch(/^masyu-\d+x\d+-\d+$/)
-      if (difficultyTag === 'hard') {
+      if (difficultyTag === 'hard' && item.id !== newestItem?.id) {
         expect(item.source).toBe(
           item.width === 25
             ? 'https://zh.puzzle-masyu.com/?size=18'
diff --git a/src/features/docs/RuleExample.test.tsx b/src/features/docs/RuleExample.test.tsx
new file mode 100644
index 0000000..03d9315
--- /dev/null
+++ b/src/features/docs/RuleExample.test.tsx
@@ -0,0 +1,87 @@
+import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { createSlitherPuzzle } from '../../domain/ir/slither'
+import { RuleExample } from './RuleExample'
+import type { RuleExampleCaseData } from './ruleExamples'
+
+const createCase = (id: string, title?: string): RuleExampleCaseData => ({
+  id,
+  title,
+  puzzle: createSlitherPuzzle(2, 2),
+  after: [],
+  explanation: `${id} explanation`,
+})
+
+describe('RuleExample', () => {
+  afterEach(() => {
+    cleanup()
+    vi.useRealTimers()
+  })
+
+  it('renders one case with one shared toolbar', () => {
+    const { container } = render(<RuleExample cases={[createCase('single')]} />)
+
+    expect(container.querySelectorAll('canvas')).toHaveLength(1)
+    expect(screen.getAllByRole('button', { name: 'Before' })).toHaveLength(1)
+    expect(screen.getAllByRole('button', { name: 'After' })).toHaveLength(1)
+    expect(
+      screen.getAllByRole('button', { name: 'Play deduction' }),
+    ).toHaveLength(1)
+  })
+
+  it('synchronizes multiple uniquely labelled cases', () => {
+    const { container } = render(
+      <RuleExample
+        cases={[
+          createCase('first', 'First branch'),
+          createCase('second', 'Second branch'),
+        ]}
+      />,
+    )
+
+    expect(container.querySelectorAll('canvas')).toHaveLength(2)
+    expect(
+      screen.getByLabelText('Rule documentation example: First branch'),
+    ).toBeInTheDocument()
+    expect(
+      screen.getByLabelText('Rule documentation example: Second branch'),
+    ).toBeInTheDocument()
+
+    fireEvent.click(screen.getByRole('button', { name: 'After' }))
+    expect(
+      container.querySelectorAll('.rule-example-case[data-view="after"]'),
+    ).toHaveLength(2)
+
+    fireEvent.click(screen.getByRole('button', { name: 'Before' }))
+    expect(
+      container.querySelectorAll('.rule-example-case[data-view="before"]'),
+    ).toHaveLength(2)
+  })
+
+  it('plays every case and manual selection cancels playback', () => {
+    vi.useFakeTimers()
+    const { container } = render(
+      <RuleExample cases={[createCase('first'), createCase('second')]} />,
+    )
+
+    fireEvent.click(screen.getByRole('button', { name: 'Play deduction' }))
+    expect(screen.getByRole('button', { name: 'Playing...' })).toBeDisabled()
+
+    fireEvent.click(screen.getByRole('button', { name: 'Before' }))
+    expect(screen.getByRole('button', { name: 'Play deduction' })).toBeEnabled()
+    expect(
+      container.querySelectorAll('.rule-example-case[data-view="before"]'),
+    ).toHaveLength(2)
+
+    act(() => vi.advanceTimersByTime(700))
+    expect(
+      container.querySelectorAll('.rule-example-case[data-view="before"]'),
+    ).toHaveLength(2)
+
+    fireEvent.click(screen.getByRole('button', { name: 'Play deduction' }))
+    act(() => vi.advanceTimersByTime(700))
+    expect(
+      container.querySelectorAll('.rule-example-case[data-view="after"]'),
+    ).toHaveLength(2)
+  })
+})
diff --git a/src/features/docs/RuleExample.tsx b/src/features/docs/RuleExample.tsx
index d9297ad..221ee12 100644
--- a/src/features/docs/RuleExample.tsx
+++ b/src/features/docs/RuleExample.tsx
@@ -1,17 +1,10 @@
 import { useEffect, useMemo, useState } from 'react'
-import type { PuzzleIR } from '../../domain/ir/types'
 import { applyRuleDiffs } from '../../domain/rules/engine'
-import type { InferenceFocus, RuleDiff } from '../../domain/rules/types'
 import { CanvasBoard } from '../board/CanvasBoard'
 import type { DisplaySettings } from '../solver/solverStore'
+import type { RuleExampleCaseData, RuleExampleData } from './ruleExamples'
 
-type Props = {
-  puzzle: PuzzleIR
-  before?: RuleDiff[]
-  after: RuleDiff[]
-  highlights?: InferenceFocus
-  explanation?: string
-}
+type View = 'before' | 'after'
 
 const displaySettings: DisplaySettings = {
   showCoordinates: false,
@@ -26,15 +19,14 @@ const displaySettings: DisplaySettings = {
   showGrid: true,
 }
 
-export const RuleExample = ({
-  puzzle,
-  before = [],
-  after,
-  highlights = {},
-  explanation,
-}: Props) => {
-  const [view, setView] = useState<'before' | 'after'>('before')
-  const [isPlaying, setIsPlaying] = useState(false)
+const RuleExampleCase = ({
+  exampleCase,
+  view,
+}: {
+  exampleCase: RuleExampleCaseData
+  view: View
+}) => {
+  const { id, title, puzzle, before = [], after, explanation } = exampleCase
   const beforePuzzle = useMemo(
     () => applyRuleDiffs(puzzle, before),
     [before, puzzle],
@@ -43,6 +35,52 @@ export const RuleExample = ({
     () => applyRuleDiffs(beforePuzzle, after),
     [after, beforePuzzle],
   )
+  const changedEdges = useMemo(
+    () =>
+      view === 'after'
+        ? after.flatMap((diff) => (diff.kind === 'edge' ? [diff.edgeKey] : []))
+        : [],
+    [after, view],
+  )
+  const changedLines = useMemo(
+    () =>
+      view === 'after'
+        ? after.flatMap((diff) => (diff.kind === 'line' ? [diff.lineKey] : []))
+        : [],
+    [after, view],
+  )
+
+  return (
+    <figure className="rule-example-case" data-view={view}>
+      {title ? <h3>{title}</h3> : null}
+      <div className="rule-example-board">
+        <CanvasBoard
+          puzzle={view === 'before' ? beforePuzzle : afterPuzzle}
+          pluginId={puzzle.puzzleType}
+          highlightedEdges={changedEdges}
+          highlightedLines={changedLines}
+          highlightedCells={[]}
+          highlightedColorCells={[]}
+          highlightedColorTiles={[]}
+          displaySettings={displaySettings}
+          onSetDisplayOption={() => undefined}
+          variant="surface"
+          ariaLabel={`Rule documentation example: ${title ?? id}`}
+        />
+      </div>
+      <figcaption>{explanation}</figcaption>
+    </figure>
+  )
+}
+
+export const RuleExample = ({ cases }: RuleExampleData) => {
+  const [view, setView] = useState<View>('before')
+  const [isPlaying, setIsPlaying] = useState(false)
+
+  const selectView = (nextView: View) => {
+    setIsPlaying(false)
+    setView(nextView)
+  }
 
   useEffect(() => {
     if (!isPlaying) {
@@ -56,20 +94,20 @@ export const RuleExample = ({
   }, [isPlaying])
 
   return (
-    <figure className="rule-example">
+    <section className="rule-example" aria-label="Rule example">
       <div className="rule-example-toolbar">
         <div className="rule-example-tabs" aria-label="Rule example state">
           <button
             type="button"
             data-active={view === 'before'}
-            onClick={() => setView('before')}
+            onClick={() => selectView('before')}
           >
             Before
           </button>
           <button
             type="button"
             data-active={view === 'after'}
-            onClick={() => setView('after')}
+            onClick={() => selectView('after')}
           >
             After
           </button>
@@ -85,22 +123,15 @@ export const RuleExample = ({
           {isPlaying ? 'Playing...' : 'Play deduction'}
         </button>
       </div>
-      <CanvasBoard
-        puzzle={view === 'before' ? beforePuzzle : afterPuzzle}
-        pluginId={puzzle.puzzleType}
-        highlightedEdges={highlights.edges ?? []}
-        highlightedLines={highlights.lines ?? []}
-        highlightedCells={highlights.cells ?? []}
-        highlightedColorCells={highlights.cells ?? []}
-        highlightedColorTiles={highlights.tiles ?? []}
-        displaySettings={displaySettings}
-        onSetDisplayOption={() => undefined}
-        variant="surface"
-        inferenceDiffs={view === 'after' ? after : []}
-        inferenceDiffRole="conclusion"
-        ariaLabel="Rule documentation example"
-      />
-      {explanation ? <figcaption>{explanation}</figcaption> : null}
-    </figure>
+      <div className="rule-example-cases">
+        {cases.map((exampleCase) => (
+          <RuleExampleCase
+            key={exampleCase.id}
+            exampleCase={exampleCase}
+            view={view}
+          />
+        ))}
+      </div>
+    </section>
   )
 }
diff --git a/src/features/docs/ruleDocRegistry.test.ts b/src/features/docs/ruleDocRegistry.test.ts
index 2db2eba..8682cfa 100644
--- a/src/features/docs/ruleDocRegistry.test.ts
+++ b/src/features/docs/ruleDocRegistry.test.ts
@@ -29,4 +29,16 @@ describe('ruleDocRegistry', () => {
       'documented',
     )
   })
+
+  it('registers both cell-count-completion example cases', () => {
+    expect(
+      getRuleDocEntry(
+        'slitherlink',
+        'cell-count-completion',
+      )?.example?.cases.map(({ id, title }) => ({ id, title })),
+    ).toEqual([
+      { id: 'satisfied-clue', title: 'Satisfied clue' },
+      { id: 'all-edges-required', title: 'All remaining edges required' },
+    ])
+  })
 })
diff --git a/src/features/docs/ruleDocRegistry.tsx b/src/features/docs/ruleDocRegistry.tsx
index d00ece6..5d83f97 100644
--- a/src/features/docs/ruleDocRegistry.tsx
+++ b/src/features/docs/ruleDocRegistry.tsx
@@ -1,6 +1,30 @@
 import type { ComponentType } from 'react'
 import BlackPearlRuleDoc from '../../../docs/content/masyu/rules/black-pearl-rule.mdx'
 import WhitePearlRuleDoc from '../../../docs/content/masyu/rules/white-pearl-rule.mdx'
+import AdjacentThreesRuleDoc from '../../../docs/content/slitherlink/rules/adjacent-threes.mdx'
+import AdjacentTwoThreeOppositeCrossRuleDoc from '../../../docs/content/slitherlink/rules/adjacent-two-three-opposite-cross.mdx'
+import CellClueCompletionRuleDoc from '../../../docs/content/slitherlink/rules/cell-clue-completion.mdx'
+import DiagonalThreesRuleDoc from '../../../docs/content/slitherlink/rules/diagonal-threes.mdx'
+import ColorEdgePropagationRuleDoc from '../../../docs/content/slitherlink/rules/color-edge-propagation.mdx'
+import ColorCluePropagationRuleDoc from '../../../docs/content/slitherlink/rules/color-clue-propagation.mdx'
+import ColorOutsideSeedingRuleDoc from '../../../docs/content/slitherlink/rules/color-outside-seeding.mdx'
+import ColorSectorMaskPropagationRuleDoc from '../../../docs/content/slitherlink/rules/color-sector-mask-propagation.mdx'
+import ColorOrthogonalConsensusPropagationRuleDoc from '../../../docs/content/slitherlink/rules/color-orthogonal-consensus-propagation.mdx'
+import ColorConnectivityCutColoringRuleDoc from '../../../docs/content/slitherlink/rules/color-connectivity-cut-coloring.mdx'
+import InsideReachabilityColoringRuleDoc from '../../../docs/content/slitherlink/rules/inside-reachability-coloring.mdx'
+import OutsideReachabilityColoringRuleDoc from '../../../docs/content/slitherlink/rules/outside-reachability-coloring.mdx'
+import PreventPrematureLoopRuleDoc from '../../../docs/content/slitherlink/rules/prevent-premature-loop.mdx'
+import SectorConstraintEdgePropagationRuleDoc from '../../../docs/content/slitherlink/rules/sector-constraint-edge-propagation.mdx'
+import SectorDiagonalSharedVertexPropagationRuleDoc from '../../../docs/content/slitherlink/rules/sector-diagonal-shared-vertex-propagation.mdx'
+import ClueVertexCandidateCombinationPruningRuleDoc from '../../../docs/content/slitherlink/rules/clue-vertex-candidate-combination-pruning.mdx'
+import SectorClueOneThreeIntraCellPropagationRuleDoc from '../../../docs/content/slitherlink/rules/sector-clue-one-three-intra-cell-propagation.mdx'
+import SectorNotOneClueTwoPropagationRuleDoc from '../../../docs/content/slitherlink/rules/sector-not-one-clue-two-propagation.mdx'
+import SectorInferenceRuleDoc from '../../../docs/content/slitherlink/rules/sector-inference.mdx'
+import VertexOnlyOneNonSectorBalanceRuleDoc from '../../../docs/content/slitherlink/rules/vertex-onlyone-non-sector-balance.mdx'
+import ColorAssumptionInferenceRuleDoc from '../../../docs/content/slitherlink/rules/color-assumption-inference.mdx'
+import SectorParityInferenceRuleDoc from '../../../docs/content/slitherlink/rules/sector-parity-inference.mdx'
+import StrongInferenceRuleDoc from '../../../docs/content/slitherlink/rules/strong-inference.mdx'
+import VertexCandidateEdgePruningRuleDoc from '../../../docs/content/slitherlink/rules/vertex-candidate-edge-pruning.mdx'
 import VertexDegreeRuleDoc from '../../../docs/content/slitherlink/rules/vertex-degree.mdx'
 import { puzzleRegistry } from '../../domain/plugins/registry'
 import type { Rule } from '../../domain/rules/types'
@@ -37,7 +61,126 @@ const documentedContent: Record<
   'slitherlink:vertex-degree': {
     content: VertexDegreeRuleDoc,
     summary:
-      'Maintains the loop degree of zero or two at every Slitherlink vertex.',
+      'Forces or crosses out the remaining incident edges at a vertex once its loop degree is determined.',
+  },
+  'slitherlink:sector-constraint-edge-propagation': {
+    content: SectorConstraintEdgePropagationRuleDoc,
+    summary:
+      'Completes the two edges of a corner sector once sector reasoning has fixed its allowed line count.',
+  },
+  'slitherlink:sector-inference': {
+    content: SectorInferenceRuleDoc,
+    summary:
+      'Narrows corner-sector line counts from vertex flow, decided edges, and clue bookkeeping.',
+  },
+  'slitherlink:sector-diagonal-shared-vertex-propagation': {
+    content: SectorDiagonalSharedVertexPropagationRuleDoc,
+    summary:
+      'Copies a narrowed sector line-count constraint to the diagonally opposite sector at the same vertex.',
+  },
+  'slitherlink:contiguous-three-run-boundaries': {
+    content: AdjacentThreesRuleDoc,
+    summary: 'Draws the forced repeating line pattern around adjacent 3 clues.',
+  },
+  'slitherlink:diagonal-adjacent-three-outer-corners': {
+    content: DiagonalThreesRuleDoc,
+    summary:
+      'Draws the four forced outer-corner edges of diagonally adjacent 3 clues.',
+  },
+  'slitherlink:cell-count-completion': {
+    content: CellClueCompletionRuleDoc,
+    summary:
+      'Completes or blanks every remaining unknown edge around a numbered clue when the clue count is already determined.',
+  },
+  'slitherlink:adjacent-two-three-opposite-cross': {
+    content: AdjacentTwoThreeOppositeCrossRuleDoc,
+    summary:
+      "When a 2's far-side edge is crossed out beside a 3, forces the 3's opposite line and blanks the shared-side extensions.",
+  },
+  'slitherlink:color-edge-propagation': {
+    content: ColorEdgePropagationRuleDoc,
+    summary:
+      'Keeps inside/outside coloring and edge decisions consistent across shared and boundary edges.',
+  },
+  'slitherlink:color-outside-seeding': {
+    content: ColorOutsideSeedingRuleDoc,
+    summary:
+      'Colors unknown cells in a parity component once a boundary edge or known cell anchors inside/outside.',
+  },
+  'slitherlink:color-clue-propagation': {
+    content: ColorCluePropagationRuleDoc,
+    summary:
+      'Colors numbered clue cells or their neighbors once inside/outside neighbor counts fix the clue bookkeeping.',
+  },
+  'slitherlink:color-sector-mask-propagation': {
+    content: ColorSectorMaskPropagationRuleDoc,
+    summary:
+      'Links corner-sector line counts with the inside/outside colors of the two cells outside each corner.',
+  },
+  'slitherlink:color-orthogonal-consensus-propagation': {
+    content: ColorOrthogonalConsensusPropagationRuleDoc,
+    summary:
+      'Colors an unknown cell to match its orthogonal neighbors once they all agree on inside or outside.',
+  },
+  'slitherlink:inside-reachability-coloring': {
+    content: InsideReachabilityColoringRuleDoc,
+    summary:
+      'Floods from known inside cells through non-line passages and colors unreachable unknown cells outside.',
+  },
+  'slitherlink:outside-reachability-coloring': {
+    content: OutsideReachabilityColoringRuleDoc,
+    summary:
+      'Floods from the exterior and known outside cells through non-line passages and colors unreachable unknown cells inside.',
+  },
+  'slitherlink:color-connectivity-cut-coloring': {
+    content: ColorConnectivityCutColoringRuleDoc,
+    summary:
+      'Colors connectivity bottlenecks and line-separated pockets to keep inside and outside each connected.',
+  },
+  'slitherlink:prevent-premature-loop': {
+    content: PreventPrematureLoopRuleDoc,
+    summary:
+      'Crosses out unknown edges that would close a smaller loop while other confirmed lines remain outside it.',
+  },
+  'slitherlink:vertex-candidate-edge-pruning': {
+    content: VertexCandidateEdgePruningRuleDoc,
+    summary:
+      'Internal bookkeeping: maintains vertex candidate sets and syncs them with known edges; visible conclusions usually match Vertex Degree.',
+  },
+  'slitherlink:clue-vertex-candidate-combination-pruning': {
+    content: ClueVertexCandidateCombinationPruningRuleDoc,
+    summary:
+      'Internal bookkeeping: enumerates clue-compatible four-corner vertex states; sector effects overlap with Sector Inference.',
+  },
+  'slitherlink:sector-clue-one-three-intra-cell-propagation': {
+    content: SectorClueOneThreeIntraCellPropagationRuleDoc,
+    summary:
+      'With clue 1 or 3 and an exactly-one corner sector, crosses out or draws the two opposite cell edges.',
+  },
+  'slitherlink:vertex-onlyone-non-sector-balance': {
+    content: VertexOnlyOneNonSectorBalanceRuleDoc,
+    summary:
+      'Completes the non-sector edges at a vertex once an exactly-one corner sector fixes how many outside lines remain.',
+  },
+  'slitherlink:sector-not-one-clue-two-propagation': {
+    content: SectorNotOneClueTwoPropagationRuleDoc,
+    summary:
+      'On clue 2, blanks a not-one corner sector when the opposite diagonal sector already has a line.',
+  },
+  'slitherlink:color-assumption-inference': {
+    content: ColorAssumptionInferenceRuleDoc,
+    summary:
+      'Colors an unknown cell when assuming the opposite inside/outside color contradicts the puzzle after deterministic propagation.',
+  },
+  'slitherlink:sector-parity-inference': {
+    content: SectorParityInferenceRuleDoc,
+    summary:
+      'Decides both edges of a not-one sector, or shared downstream edges, by comparing line and blank parity trial branches.',
+  },
+  'slitherlink:strong-inference': {
+    content: StrongInferenceRuleDoc,
+    summary:
+      'Probes high-value edge candidates with bounded trial branches to force a surviving assignment or a shared downstream consequence.',
   },
 }
 
@@ -52,6 +195,9 @@ const getCategory = (rule: Rule): string => {
   if (rule.id.includes('color') || rule.id.includes('tile')) {
     return 'Color and Region Reasoning'
   }
+  if (rule.id.includes('pruning')) {
+    return 'Internal Candidate Propagation'
+  }
   if (rule.id.includes('sector') || rule.id.includes('vertex')) {
     return 'Sector and Vertex Reasoning'
   }
diff --git a/src/features/docs/ruleExamples.ts b/src/features/docs/ruleExamples.ts
index ee5dddc..3ca443f 100644
--- a/src/features/docs/ruleExamples.ts
+++ b/src/features/docs/ruleExamples.ts
@@ -1,17 +1,35 @@
-import { cellKey, edgeKey, lineKey } from '../../domain/ir/keys'
+import { cellKey, edgeKey, lineKey, sectorKey } from '../../domain/ir/keys'
 import { createMasyuPuzzle } from '../../domain/ir/masyu'
 import { createSlitherPuzzle } from '../../domain/ir/slither'
-import type { PuzzleIR } from '../../domain/ir/types'
-import type { InferenceFocus, RuleDiff } from '../../domain/rules/types'
+import {
+  SECTOR_MASK_ALL,
+  SECTOR_MASK_NOT_0,
+  SECTOR_MASK_NOT_1,
+  SECTOR_MASK_NOT_2,
+  SECTOR_MASK_ONLY_0,
+  SECTOR_MASK_ONLY_1,
+  SECTOR_MASK_ONLY_2,
+  type PuzzleIR,
+} from '../../domain/ir/types'
+import type { RuleDiff } from '../../domain/rules/types'
 
-export type RuleExampleData = {
+export type RuleExampleCaseData = {
+  id: string
+  title?: string
   puzzle: PuzzleIR
   before?: RuleDiff[]
   after: RuleDiff[]
-  highlights?: InferenceFocus
   explanation: string
 }
 
+export type RuleExampleData = {
+  cases: [RuleExampleCaseData, ...RuleExampleCaseData[]]
+}
+
+const example = (exampleCase: RuleExampleCaseData): RuleExampleData => ({
+  cases: [exampleCase],
+})
+
 const createWhitePearlExample = (): RuleExampleData => {
   const puzzle = createMasyuPuzzle(3, 3)
   puzzle.cells[cellKey(1, 1)] = { clue: { kind: 'pearl', color: 'white' } }
@@ -19,7 +37,8 @@ const createWhitePearlExample = (): RuleExampleData => {
   const right = lineKey([1, 1], [1, 2])
   const up = lineKey([0, 1], [1, 1])
   const down = lineKey([1, 1], [2, 1])
-  return {
+  return example({
+    id: 'horizontal-exit',
     puzzle,
     before: [{ kind: 'line', lineKey: left, from: 'unknown', to: 'line' }],
     after: [
@@ -27,10 +46,9 @@ const createWhitePearlExample = (): RuleExampleData => {
       { kind: 'line', lineKey: up, from: 'unknown', to: 'blank' },
       { kind: 'line', lineKey: down, from: 'unknown', to: 'blank' },
     ],
-    highlights: { cells: [cellKey(1, 1)], lines: [right, up, down] },
     explanation:
       'A known horizontal exit forces the white pearl to continue horizontally and rejects both vertical exits.',
-  }
+  })
 }
 
 const createBlackPearlExample = (): RuleExampleData => {
@@ -39,43 +57,1801 @@ const createBlackPearlExample = (): RuleExampleData => {
   const up = lineKey([1, 1], [2, 1])
   const upExtension = lineKey([0, 1], [1, 1])
   const down = lineKey([2, 1], [3, 1])
-  return {
+  return example({
+    id: 'upward-exit',
     puzzle,
     before: [{ kind: 'line', lineKey: up, from: 'unknown', to: 'line' }],
     after: [
       { kind: 'line', lineKey: upExtension, from: 'unknown', to: 'line' },
       { kind: 'line', lineKey: down, from: 'unknown', to: 'blank' },
     ],
-    highlights: { cells: [cellKey(2, 1)], lines: [upExtension, down] },
     explanation:
       'Once the loop exits upward from a black pearl, it must continue straight for another cell and cannot also exit downward.',
-  }
+  })
 }
 
 const createVertexDegreeExample = (): RuleExampleData => {
-  const puzzle = createSlitherPuzzle(2, 2)
-  const top = edgeKey([0, 1], [1, 1])
-  const left = edgeKey([1, 0], [1, 1])
-  const right = edgeKey([1, 1], [1, 2])
-  const bottom = edgeKey([1, 1], [2, 1])
+  const closedPuzzle = createSlitherPuzzle(2, 2)
+  const closedTop = edgeKey([0, 1], [1, 1])
+  const closedLeft = edgeKey([1, 0], [1, 1])
+  const closedRight = edgeKey([1, 1], [1, 2])
+  const closedBottom = edgeKey([1, 1], [2, 1])
+
+  const continuePuzzle = createSlitherPuzzle(2, 2)
+  const continueTop = edgeKey([0, 1], [1, 1])
+  const continueBottom = edgeKey([1, 1], [1, 2])
+  const continueLeft = edgeKey([0, 0], [0, 1])
+  const continueRight = edgeKey([0, 1], [0, 2])
+
+  const deadEndPuzzle = createSlitherPuzzle(3, 3)
+  const deadEndTop = edgeKey([1, 1], [2, 1])
+  const deadEndBottom = edgeKey([2, 1], [3, 1])
+  const deadEndLeft = edgeKey([2, 0], [2, 1])
+  const deadEndRight = edgeKey([2, 1], [2, 2])
+
   return {
+    cases: [
+      {
+        id: 'degree-two-closure',
+        title: 'Degree already two',
+        puzzle: closedPuzzle,
+        before: [
+          { kind: 'edge', edgeKey: closedTop, from: 'unknown', to: 'line' },
+          { kind: 'edge', edgeKey: closedLeft, from: 'unknown', to: 'line' },
+        ],
+        after: [
+          { kind: 'edge', edgeKey: closedRight, from: 'unknown', to: 'blank' },
+          { kind: 'edge', edgeKey: closedBottom, from: 'unknown', to: 'blank' },
+        ],
+        explanation:
+          'Two incident lines already meet at the vertex, so every remaining unknown edge is crossed out.',
+      },
+      {
+        id: 'degree-one-completion',
+        title: 'One line remains to complete',
+        puzzle: continuePuzzle,
+        before: [
+          { kind: 'edge', edgeKey: continueTop, from: 'unknown', to: 'line' },
+          { kind: 'edge', edgeKey: continueBottom, from: 'unknown', to: 'blank' },
+          { kind: 'edge', edgeKey: continueLeft, from: 'unknown', to: 'blank' },
+        ],
+        after: [
+          { kind: 'edge', edgeKey: continueRight, from: 'unknown', to: 'line' },
+        ],
+        explanation:
+          'One line is already present and only one unknown edge remains, so that edge must complete degree two.',
+      },
+      {
+        id: 'single-unknown-dead-end',
+        title: 'Last edge would create a dead end',
+        puzzle: deadEndPuzzle,
+        before: [
+          { kind: 'edge', edgeKey: deadEndTop, from: 'unknown', to: 'blank' },
+          { kind: 'edge', edgeKey: deadEndLeft, from: 'unknown', to: 'blank' },
+          { kind: 'edge', edgeKey: deadEndRight, from: 'unknown', to: 'blank' },
+        ],
+        after: [
+          { kind: 'edge', edgeKey: deadEndBottom, from: 'unknown', to: 'blank' },
+        ],
+        explanation:
+          'With no line yet and only one unknown edge left, using it would leave a degree-one dead end.',
+      },
+    ],
+  }
+}
+
+const createSectorConstraintEdgePropagationExample = (): RuleExampleData => {
+  const onlyTwoPuzzle = createSlitherPuzzle(2, 2)
+  onlyTwoPuzzle.sectors[sectorKey(0, 0, 'nw')].constraintsMask = SECTOR_MASK_ONLY_2
+  const onlyTwoTop = edgeKey([0, 0], [0, 1])
+  const onlyTwoLeft = edgeKey([0, 0], [1, 0])
+
+  const onlyZeroPuzzle = createSlitherPuzzle(2, 2)
+  onlyZeroPuzzle.sectors[sectorKey(0, 0, 'nw')].constraintsMask = SECTOR_MASK_ONLY_0
+  const onlyZeroTop = edgeKey([0, 0], [0, 1])
+  const onlyZeroLeft = edgeKey([0, 0], [1, 0])
+
+  const onlyOnePuzzle = createSlitherPuzzle(2, 2)
+  onlyOnePuzzle.sectors[sectorKey(1, 1, 'nw')].constraintsMask = SECTOR_MASK_ONLY_1
+  const onlyOneTop = edgeKey([1, 1], [1, 2])
+  const onlyOneLeft = edgeKey([1, 1], [2, 1])
+
+  const notOnePuzzle = createSlitherPuzzle(2, 2)
+  notOnePuzzle.sectors[sectorKey(0, 0, 'nw')].constraintsMask = SECTOR_MASK_NOT_1
+  const notOneTop = edgeKey([0, 0], [0, 1])
+  const notOneLeft = edgeKey([0, 0], [1, 0])
+
+  return {
+    cases: [
+      {
+        id: 'sector-exactly-two',
+        title: 'Sector must have two lines',
+        puzzle: onlyTwoPuzzle,
+        after: [
+          { kind: 'edge', edgeKey: onlyTwoTop, from: 'unknown', to: 'line' },
+          { kind: 'edge', edgeKey: onlyTwoLeft, from: 'unknown', to: 'line' },
+        ],
+        explanation:
+          'NOT_ONE (blue) + NOT_ZERO (green) = TWO LINES.',
+      },
+      {
+        id: 'sector-exactly-zero',
+        title: 'Sector must have zero lines',
+        puzzle: onlyZeroPuzzle,
+        after: [
+          { kind: 'edge', edgeKey: onlyZeroTop, from: 'unknown', to: 'blank' },
+          { kind: 'edge', edgeKey: onlyZeroLeft, from: 'unknown', to: 'blank' },
+        ],
+        explanation:
+          'NOT_ONE (blue) + NOT_TWO (yellow) = TWO CROSSES.',
+      },
+      {
+        id: 'sector-exactly-one',
+        title: 'Sector must have one line',
+        puzzle: onlyOnePuzzle,
+        before: [{ kind: 'edge', edgeKey: onlyOneTop, from: 'unknown', to: 'blank' }],
+        after: [
+          { kind: 'edge', edgeKey: onlyOneLeft, from: 'unknown', to: 'line' },
+        ],
+        explanation:
+          'ONLY_ONE (red) + ONE CROSS = ONE LINE.',
+      },
+      {
+        id: 'sector-not-one',
+        title: 'Sector cannot have one line',
+        puzzle: notOnePuzzle,
+        before: [{ kind: 'edge', edgeKey: notOneTop, from: 'unknown', to: 'line' }],
+        after: [
+          { kind: 'edge', edgeKey: notOneLeft, from: 'unknown', to: 'line' },
+        ],
+        explanation:
+          'NOT_ONE (blue) + ONE LINE = TWO LINES.',
+      },
+    ],
+  }
+}
+
+const createAdjacentThreesExample = (): RuleExampleData => {
+  const puzzle = createSlitherPuzzle(3, 4)
+  puzzle.cells[cellKey(1, 1)] = { clue: { kind: 'number', value: 3 } }
+  puzzle.cells[cellKey(1, 2)] = { clue: { kind: 'number', value: 3 } }
+  const left = edgeKey([1, 1], [2, 1])
+  const shared = edgeKey([1, 2], [2, 2])
+  const right = edgeKey([1, 3], [2, 3])
+  const sharedAbove = edgeKey([0, 2], [1, 2])
+  const sharedBelow = edgeKey([2, 2], [3, 2])
+  return example({
+    id: 'horizontal-pair',
     puzzle,
-    before: [
-      { kind: 'edge', edgeKey: top, from: 'unknown', to: 'line' },
+    after: [
       { kind: 'edge', edgeKey: left, from: 'unknown', to: 'line' },
+      { kind: 'edge', edgeKey: shared, from: 'unknown', to: 'line' },
+      { kind: 'edge', edgeKey: right, from: 'unknown', to: 'line' },
+      { kind: 'edge', edgeKey: sharedAbove, from: 'unknown', to: 'blank' },
+      { kind: 'edge', edgeKey: sharedBelow, from: 'unknown', to: 'blank' },
+    ],
+    explanation:
+      'Adjacent 3s force every perpendicular edge to be a line and cross out both straight extensions of their shared edge. The vertical pattern is the rotated equivalent, and longer runs apply the same deduction pairwise.',
+  })
+}
+
+const createCellClueCompletionExample = (): RuleExampleData => {
+  const satisfiedPuzzle = createSlitherPuzzle(3, 3)
+  satisfiedPuzzle.cells[cellKey(1, 1)] = {
+    clue: { kind: 'number', value: 1 },
+  }
+  const top = edgeKey([1, 1], [1, 2])
+  const bottom = edgeKey([2, 1], [2, 2])
+  const left = edgeKey([1, 1], [2, 1])
+  const right = edgeKey([1, 2], [2, 2])
+
+  const requiredPuzzle = createSlitherPuzzle(3, 3)
+  requiredPuzzle.cells[cellKey(1, 1)] = {
+    clue: { kind: 'number', value: 3 },
+  }
+
+  return {
+    cases: [
+      {
+        id: 'satisfied-clue',
+        title: 'Satisfied clue',
+        puzzle: satisfiedPuzzle,
+        before: [{ kind: 'edge', edgeKey: top, from: 'unknown', to: 'line' }],
+        after: [
+          { kind: 'edge', edgeKey: bottom, from: 'unknown', to: 'blank' },
+          { kind: 'edge', edgeKey: left, from: 'unknown', to: 'blank' },
+          { kind: 'edge', edgeKey: right, from: 'unknown', to: 'blank' },
+        ],
+        explanation:
+          'Once the clue already has one line, every remaining unknown edge must be crossed out.',
+      },
+      {
+        id: 'all-edges-required',
+        title: 'All remaining edges required',
+        puzzle: requiredPuzzle,
+        before: [
+          { kind: 'edge', edgeKey: top, from: 'unknown', to: 'line' },
+          { kind: 'edge', edgeKey: left, from: 'unknown', to: 'blank' },
+        ],
+        after: [
+          { kind: 'edge', edgeKey: bottom, from: 'unknown', to: 'line' },
+          { kind: 'edge', edgeKey: right, from: 'unknown', to: 'line' },
+        ],
+        explanation:
+          'The clue still needs two lines and only two unknown edges remain, so both must be lines.',
+      },
+    ],
+  }
+}
+
+const createAdjacentTwoThreeOppositeCrossExample = (): RuleExampleData => {
+  const puzzle = createSlitherPuzzle(4, 4)
+  puzzle.cells[cellKey(1, 1)] = { clue: { kind: 'number', value: 2 } }
+  puzzle.cells[cellKey(1, 2)] = { clue: { kind: 'number', value: 3 } }
+  const twoOpposite = edgeKey([1, 1], [2, 1])
+  const threeOpposite = edgeKey([1, 3], [2, 3])
+  const extensionAbove = edgeKey([0, 2], [1, 2])
+  const extensionBelow = edgeKey([2, 2], [3, 2])
+  return example({
+    id: 'horizontal-pair',
+    puzzle,
+    before: [
+      { kind: 'edge', edgeKey: twoOpposite, from: 'unknown', to: 'blank' },
     ],
     after: [
-      { kind: 'edge', edgeKey: right, from: 'unknown', to: 'blank' },
-      { kind: 'edge', edgeKey: bottom, from: 'unknown', to: 'blank' },
+      { kind: 'edge', edgeKey: threeOpposite, from: 'unknown', to: 'line' },
+      { kind: 'edge', edgeKey: extensionAbove, from: 'unknown', to: 'blank' },
+      { kind: 'edge', edgeKey: extensionBelow, from: 'unknown', to: 'blank' },
     ],
-    highlights: { edges: [right, bottom], vertices: ['1,1'] },
     explanation:
-      'A loop vertex already containing two used edges cannot accept either remaining edge.',
+      "With the 2's far-side edge crossed out, the 3's opposite edge is a line and the shared-side extensions are blank.",
+  })
+}
+
+const createColorEdgePropagationExample = (): RuleExampleData => {
+  const sameColorPuzzle = createSlitherPuzzle(2, 2)
+  sameColorPuzzle.cells[cellKey(0, 0)] = { fill: 'green' }
+  sameColorPuzzle.cells[cellKey(0, 1)] = { fill: 'green' }
+  const sameColorEdge = edgeKey([0, 1], [1, 1])
+
+  const differentColorPuzzle = createSlitherPuzzle(2, 2)
+  differentColorPuzzle.cells[cellKey(0, 0)] = { fill: 'green' }
+  differentColorPuzzle.cells[cellKey(0, 1)] = { fill: 'yellow' }
+  const differentColorEdge = edgeKey([0, 1], [1, 1])
+
+  const insideCornerPuzzle = createSlitherPuzzle(2, 2)
+  const insideCornerTop = edgeKey([0, 0], [0, 1])
+  const insideCornerLeft = edgeKey([0, 0], [1, 0])
+
+  const lineInferencePuzzle = createSlitherPuzzle(2, 2)
+  const lineInferenceEdge = edgeKey([0, 1], [1, 1])
+
+  return {
+    cases: [
+      {
+        id: 'same-color-blank',
+        title: 'Same color across interior edge',
+        puzzle: sameColorPuzzle,
+        after: [
+          {
+            kind: 'edge',
+            edgeKey: sameColorEdge,
+            from: 'unknown',
+            to: 'blank',
+          },
+        ],
+        explanation:
+          'Two inside cells share a region, so the edge between them is crossed out.',
+      },
+      {
+        id: 'different-color-line',
+        title: 'Different colors across interior edge',
+        puzzle: differentColorPuzzle,
+        after: [
+          {
+            kind: 'edge',
+            edgeKey: differentColorEdge,
+            from: 'unknown',
+            to: 'line',
+          },
+        ],
+        explanation:
+          'Inside and outside meet on their shared edge, so that edge must be a line.',
+      },
+      {
+        id: 'inside-corner-boundary',
+        title: 'Inside cell at the boundary',
+        puzzle: insideCornerPuzzle,
+        before: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 0),
+            fromFill: null,
+            toFill: 'green',
+          },
+        ],
+        after: [
+          {
+            kind: 'edge',
+            edgeKey: insideCornerTop,
+            from: 'unknown',
+            to: 'line',
+          },
+          {
+            kind: 'edge',
+            edgeKey: insideCornerLeft,
+            from: 'unknown',
+            to: 'line',
+          },
+        ],
+        explanation:
+          'An inside corner cell must meet the exterior with lines on both boundary edges.',
+      },
+      {
+        id: 'line-infers-opposite-color',
+        title: 'Line fixes the opposite color',
+        puzzle: lineInferencePuzzle,
+        before: [
+          {
+            kind: 'edge',
+            edgeKey: lineInferenceEdge,
+            from: 'unknown',
+            to: 'line',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 0),
+            fromFill: null,
+            toFill: 'green',
+          },
+        ],
+        after: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 1),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+        ],
+        explanation:
+          'A line separates opposite colors, so the unknown neighbor must be outside.',
+      },
+    ],
+  }
+}
+
+const createColorOutsideSeedingExample = (): RuleExampleData => {
+  const blankBoundaryPuzzle = createSlitherPuzzle(2, 2)
+  const blankBoundaryTop = edgeKey([0, 0], [0, 1])
+
+  const lineBoundaryPuzzle = createSlitherPuzzle(2, 2)
+  const lineBoundaryTop = edgeKey([0, 0], [0, 1])
+
+  const anchorPropagationPuzzle = createSlitherPuzzle(2, 2)
+  const anchorPropagationEdge = edgeKey([0, 1], [1, 1])
+
+  const parityChainPuzzle = createSlitherPuzzle(2, 3)
+  const parityChainTopLeft = edgeKey([0, 0], [0, 1])
+  const parityChainMiddle = edgeKey([0, 1], [1, 1])
+  const parityChainTopRight = edgeKey([0, 2], [1, 2])
+
+  return {
+    cases: [
+      {
+        id: 'blank-boundary-outside',
+        title: 'Crossed-out boundary edge',
+        puzzle: blankBoundaryPuzzle,
+        before: [
+          {
+            kind: 'edge',
+            edgeKey: blankBoundaryTop,
+            from: 'unknown',
+            to: 'blank',
+          },
+        ],
+        after: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 0),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+        ],
+        explanation:
+          'A crossed-out outer edge touches an outside cell, seeding the parity component.',
+      },
+      {
+        id: 'line-boundary-inside',
+        title: 'Line on the boundary',
+        puzzle: lineBoundaryPuzzle,
+        before: [
+          {
+            kind: 'edge',
+            edgeKey: lineBoundaryTop,
+            from: 'unknown',
+            to: 'line',
+          },
+        ],
+        after: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 0),
+            fromFill: null,
+            toFill: 'green',
+          },
+        ],
+        explanation:
+          'A boundary line separates the exterior from an inside cell.',
+      },
+      {
+        id: 'known-inside-anchor',
+        title: 'Known inside cell as anchor',
+        puzzle: anchorPropagationPuzzle,
+        before: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 0),
+            fromFill: null,
+            toFill: 'green',
+          },
+          {
+            kind: 'edge',
+            edgeKey: anchorPropagationEdge,
+            from: 'unknown',
+            to: 'line',
+          },
+        ],
+        after: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 1),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+        ],
+        explanation:
+          'A known inside cell anchors the component; the line forces the neighbor outside.',
+      },
+      {
+        id: 'parity-chain-from-boundary',
+        title: 'Parity chain from boundary',
+        puzzle: parityChainPuzzle,
+        before: [
+          {
+            kind: 'edge',
+            edgeKey: parityChainTopLeft,
+            from: 'unknown',
+            to: 'blank',
+          },
+          {
+            kind: 'edge',
+            edgeKey: parityChainMiddle,
+            from: 'unknown',
+            to: 'line',
+          },
+          {
+            kind: 'edge',
+            edgeKey: parityChainTopRight,
+            from: 'unknown',
+            to: 'blank',
+          },
+        ],
+        after: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 0),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 1),
+            fromFill: null,
+            toFill: 'green',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 2),
+            fromFill: null,
+            toFill: 'green',
+          },
+        ],
+        explanation:
+          'One boundary anchor colors the whole top row through parity across decided edges.',
+      },
+    ],
+  }
+}
+
+const createDiagonalThreesExample = (): RuleExampleData => {
+  const puzzle = createSlitherPuzzle(4, 4)
+  puzzle.cells[cellKey(1, 1)] = { clue: { kind: 'number', value: 3 } }
+  puzzle.cells[cellKey(2, 2)] = { clue: { kind: 'number', value: 3 } }
+  const firstLeft = edgeKey([1, 1], [2, 1])
+  const firstTop = edgeKey([1, 1], [1, 2])
+  const secondRight = edgeKey([2, 3], [3, 3])
+  const secondBottom = edgeKey([3, 2], [3, 3])
+  const decidedEdges = [firstLeft, firstTop, secondRight, secondBottom]
+  return example({
+    id: 'down-right-diagonal',
+    puzzle,
+    after: decidedEdges.map((key) => ({
+      kind: 'edge' as const,
+      edgeKey: key,
+      from: 'unknown' as const,
+      to: 'line' as const,
+    })),
+    explanation:
+      'Diagonal 3s force the two edges at each outer corner, giving four lines in total.',
+  })
+}
+
+const createColorCluePropagationExample = (): RuleExampleData => {
+  const cornerInsidePuzzle = createSlitherPuzzle(3, 3)
+  cornerInsidePuzzle.cells[cellKey(1, 1)] = {
+    clue: { kind: 'number', value: 1 },
+  }
+
+  const clueTwoOutsidePuzzle = createSlitherPuzzle(3, 3)
+  clueTwoOutsidePuzzle.cells[cellKey(1, 1)] = {
+    clue: { kind: 'number', value: 2 },
+  }
+
+  const outsideCluePuzzle = createSlitherPuzzle(3, 3)
+  outsideCluePuzzle.cells[cellKey(1, 1)] = {
+    clue: { kind: 'number', value: 1 },
+    fill: 'yellow',
+  }
+
+  const forcedOutsidePuzzle = createSlitherPuzzle(3, 3)
+  forcedOutsidePuzzle.cells[cellKey(1, 1)] = {
+    clue: { kind: 'number', value: 3 },
+  }
+
+  return {
+    cases: [
+      {
+        id: 'corner-clue-forced-inside',
+        title: 'Corner clue forced inside',
+        puzzle: cornerInsidePuzzle,
+        before: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(1, 2),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(2, 1),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+        ],
+        after: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(1, 1),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+        ],
+        explanation:
+          'Cell 1 already has two yellow neighbors; if it were green, that would force two lines — invalid for clue 1.',
+      },
+      {
+        id: 'clue-two-outside-neighbors',
+        title: 'Clue 2 with two outside neighbors',
+        puzzle: clueTwoOutsidePuzzle,
+        before: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 1),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(1, 0),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+        ],
+        after: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(2, 1),
+            fromFill: null,
+            toFill: 'green',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(1, 2),
+            fromFill: null,
+            toFill: 'green',
+          },
+        ],
+        explanation:
+          'Whatever its color, clue 2 must end with two yellow and two green neighbors — two crosses and two lines.',
+      },
+      {
+        id: 'outside-clue-remaining-outside',
+        title: 'Outside clue already satisfied',
+        puzzle: outsideCluePuzzle,
+        before: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 1),
+            fromFill: null,
+            toFill: 'green',
+          },
+        ],
+        after: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(2, 1),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(1, 0),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(1, 2),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+        ],
+        explanation:
+          'Cell 1 is already settled, so the remaining sides must all be crosses; the neighbor colors follow.',
+      },
+      {
+        id: 'too-many-inside-neighbors',
+        title: 'Too many inside neighbors',
+        puzzle: forcedOutsidePuzzle,
+        before: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 1),
+            fromFill: null,
+            toFill: 'green',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(1, 0),
+            fromFill: null,
+            toFill: 'green',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(1, 2),
+            fromFill: null,
+            toFill: 'green',
+          },
+        ],
+        after: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(1, 1),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+        ],
+        explanation:
+          'Cell 1 already has three green neighbors; if it were green, at most one line could remain — invalid for clue 3.',
+      },
+    ],
+  }
+}
+
+const createColorSectorMaskPropagationExample = (): RuleExampleData => {
+  const notOneColorPuzzle = createSlitherPuzzle(3, 3)
+  notOneColorPuzzle.sectors[sectorKey(1, 1, 'se')].constraintsMask =
+    SECTOR_MASK_NOT_1
+
+  const onlyOneColorPuzzle = createSlitherPuzzle(3, 3)
+  onlyOneColorPuzzle.sectors[sectorKey(1, 1, 'se')].constraintsMask =
+    SECTOR_MASK_ONLY_1
+
+  const differentColorsPuzzle = createSlitherPuzzle(2, 2)
+
+  const sameColorsPuzzle = createSlitherPuzzle(2, 2)
+
+  return {
+    cases: [
+      {
+        id: 'not-one-sector-same-color',
+        title: 'Not-one sector, same color',
+        puzzle: notOneColorPuzzle,
+        before: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(1, 2),
+            fromFill: null,
+            toFill: 'green',
+          },
+        ],
+        after: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(2, 1),
+            fromFill: null,
+            toFill: 'green',
+          },
+        ],
+        explanation:
+          'NOT_ONE (blue) sector requires matching outside-neighbor colors, as shown.',
+      },
+      {
+        id: 'only-one-sector-opposite-color',
+        title: 'Only-one sector, opposite color',
+        puzzle: onlyOneColorPuzzle,
+        before: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(1, 2),
+            fromFill: null,
+            toFill: 'green',
+          },
+        ],
+        after: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(2, 1),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+        ],
+        explanation:
+          'ONLY_ONE sector requires opposite outside-neighbor colors, as shown.',
+      },
+      {
+        id: 'different-colors-force-only-one',
+        title: 'Opposite colors force only one',
+        puzzle: differentColorsPuzzle,
+        before: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 1),
+            fromFill: null,
+            toFill: 'green',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(1, 0),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+        ],
+        after: [
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(0, 0, 'se'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_ONLY_1,
+          },
+        ],
+        explanation:
+          'Opposite outside-neighbor colors force exactly one line in the shared corner sector.',
+      },
+      {
+        id: 'same-colors-force-not-one',
+        title: 'Matching colors forbid one line',
+        puzzle: sameColorsPuzzle,
+        before: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 1),
+            fromFill: null,
+            toFill: 'green',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(1, 0),
+            fromFill: null,
+            toFill: 'green',
+          },
+        ],
+        after: [
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(0, 0, 'se'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_NOT_1,
+          },
+        ],
+        explanation:
+          'Matching outside-neighbor colors forbid exactly one line in the shared corner sector.',
+      },
+    ],
   }
 }
 
+const createColorOrthogonalConsensusPropagationExample = (): RuleExampleData => {
+  const insidePuzzle = createSlitherPuzzle(3, 3)
+  const outsidePuzzle = createSlitherPuzzle(3, 3)
+
+  return {
+    cases: [
+      {
+        id: 'uniform-inside-neighbors',
+        title: 'All neighbors inside',
+        puzzle: insidePuzzle,
+        before: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 1),
+            fromFill: null,
+            toFill: 'green',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(2, 1),
+            fromFill: null,
+            toFill: 'green',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(1, 0),
+            fromFill: null,
+            toFill: 'green',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(1, 2),
+            fromFill: null,
+            toFill: 'green',
+          },
+        ],
+        after: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(1, 1),
+            fromFill: null,
+            toFill: 'green',
+          },
+        ],
+        explanation:
+          'Every orthogonal neighbor is inside, so the center cell must also be inside.',
+      },
+      {
+        id: 'uniform-outside-neighbors',
+        title: 'All neighbors outside',
+        puzzle: outsidePuzzle,
+        before: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 1),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(2, 1),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(1, 0),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(1, 2),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+        ],
+        after: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(1, 1),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+        ],
+        explanation:
+          'Every orthogonal neighbor is outside, so the center cell must also be outside.',
+      },
+    ],
+  }
+}
+
+const createSectorInferenceExample = (): RuleExampleData => {
+  const boundaryPuzzle = createSlitherPuzzle(2, 2)
+
+  const sectorEdgesPuzzle = createSlitherPuzzle(2, 3)
+  const sectorLine = edgeKey([0, 0], [0, 1])
+  const sectorCross = edgeKey([0, 1], [1, 1])
+
+  const edgeVertexPuzzle = createSlitherPuzzle(3, 3)
+  const soleNonSectorBlank = edgeKey([0, 0], [0, 1])
+
+  const clueThreePuzzle = createSlitherPuzzle(3, 3)
+  clueThreePuzzle.cells[cellKey(0, 0)] = { clue: { kind: 'number', value: 3 } }
+
+  const outsideLinePuzzle = createSlitherPuzzle(4, 4)
+  outsideLinePuzzle.cells[cellKey(0, 3)] = { clue: { kind: 'number', value: 3 } }
+  const westOfVertex = edgeKey([0, 2], [0, 3])
+
+  const clueTwoPuzzle = createSlitherPuzzle(3, 3)
+  clueTwoPuzzle.cells[cellKey(1, 1)] = { clue: { kind: 'number', value: 2 } }
+  const clueTwoDiagLine = edgeKey([2, 1], [2, 2])
+  const clueTwoDiagCross = edgeKey([1, 2], [2, 2])
+
+  return {
+    cases: [
+      {
+        id: 'boundary-corner-not-one',
+        title: 'Board corner geometry',
+        puzzle: boundaryPuzzle,
+        after: [
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(0, 0, 'nw'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_NOT_1,
+          },
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(0, 1, 'ne'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_NOT_1,
+          },
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(1, 0, 'sw'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_NOT_1,
+          },
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(1, 1, 'se'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_NOT_1,
+          },
+        ],
+        explanation:
+          'A board corner has only its two sector edges, so that corner cannot end with exactly one line.',
+      },
+      {
+        id: 'sector-edges-decided',
+        title: 'Both sector edges decided',
+        puzzle: sectorEdgesPuzzle,
+        before: [
+          { kind: 'edge', edgeKey: sectorLine, from: 'unknown', to: 'line' },
+          { kind: 'edge', edgeKey: sectorCross, from: 'unknown', to: 'blank' },
+        ],
+        after: [
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(0, 0, 'ne'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_ONLY_1,
+          },
+        ],
+        explanation:
+          'One sector line and one sector cross already fix the corner to exactly one line.',
+      },
+      {
+        id: 'edge-vertex-blank',
+        title: 'Sole outside edge crossed out',
+        puzzle: edgeVertexPuzzle,
+        before: [
+          { kind: 'edge', edgeKey: soleNonSectorBlank, from: 'unknown', to: 'blank' },
+        ],
+        after: [
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(0, 1, 'nw'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_NOT_1,
+          },
+        ],
+        explanation:
+          'The only non-sector edge at this vertex is crossed out, so the sector cannot have exactly one line.',
+      },
+      {
+        id: 'clue-three-corners',
+        title: 'Clue 3 bookkeeping',
+        puzzle: clueThreePuzzle,
+        after: [
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(0, 0, 'nw'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_ONLY_2,
+          },
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(0, 0, 'ne'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_NOT_0,
+          },
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(0, 0, 'sw'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_NOT_0,
+          },
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(0, 0, 'se'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_NOT_0,
+          },
+        ],
+        explanation:
+          'Clue 3 forbids zero sector lines on every corner of the cell; the board corner also fixes that corner to two lines.',
+      },
+      {
+        id: 'outside-line-forces-one',
+        title: 'One outside line at vertex',
+        puzzle: outsideLinePuzzle,
+        before: [
+          { kind: 'edge', edgeKey: westOfVertex, from: 'unknown', to: 'line' },
+        ],
+        after: [
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(0, 3, 'nw'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_ONLY_1,
+          },
+        ],
+        explanation:
+          'One line already enters the corner vertex from outside the sector, so the sector must supply exactly one more line.',
+      },
+      {
+        id: 'clue-two-diagonal',
+        title: 'Clue 2 diagonal split',
+        puzzle: clueTwoPuzzle,
+        before: [
+          { kind: 'edge', edgeKey: clueTwoDiagLine, from: 'unknown', to: 'line' },
+          { kind: 'edge', edgeKey: clueTwoDiagCross, from: 'unknown', to: 'blank' },
+        ],
+        after: [
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(1, 1, 'nw'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_ONLY_1,
+          },
+        ],
+        explanation:
+          'The diagonal edges already account for one line, so clue 2 forces exactly one line in the northwest corner sector.',
+      },
+    ],
+  }
+}
+
+const createSectorDiagonalSharedVertexPropagationExample = (): RuleExampleData => {
+  const onlyOnePuzzle = createSlitherPuzzle(4, 4)
+  const notOnePuzzle = createSlitherPuzzle(4, 4)
+  const notZeroPuzzle = createSlitherPuzzle(4, 4)
+
+  return {
+    cases: [
+      {
+        id: 'only-one-diagonal',
+        title: 'Exactly one line',
+        puzzle: onlyOnePuzzle,
+        before: [
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(2, 2, 'ne'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_ONLY_1,
+          },
+        ],
+        after: [
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(1, 3, 'sw'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_ONLY_1,
+          },
+        ],
+        explanation:
+          'An exactly-one-line sector on one diagonal corner forces the same count on the opposite diagonal sector.',
+      },
+      {
+        id: 'not-one-diagonal',
+        title: 'Cannot have one line',
+        puzzle: notOnePuzzle,
+        before: [
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(2, 2, 'ne'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_NOT_1,
+          },
+        ],
+        after: [
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(1, 3, 'sw'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_NOT_1,
+          },
+        ],
+        explanation:
+          'A not-exactly-one-line sector passes the same restriction to the diagonal opposite sector.',
+      },
+      {
+        id: 'not-zero-to-not-two',
+        title: 'Cannot have zero lines',
+        puzzle: notZeroPuzzle,
+        before: [
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(2, 2, 'ne'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_NOT_0,
+          },
+        ],
+        after: [
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(1, 3, 'sw'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_NOT_2,
+          },
+        ],
+        explanation:
+          'If one diagonal sector cannot be empty, the opposite diagonal sector cannot contain two lines.',
+      },
+    ],
+  }
+}
+
+const createInsideReachabilityColoringExample = (): RuleExampleData => {
+  const lineWallPuzzle = createSlitherPuzzle(1, 2)
+  const lineWallDivider = edgeKey([0, 1], [1, 1])
+
+  const outsideBarrierPuzzle = createSlitherPuzzle(1, 3)
+
+  return {
+    cases: [
+      {
+        id: 'line-blocks-inside-flood',
+        title: 'Line seals a pocket',
+        puzzle: lineWallPuzzle,
+        before: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 0),
+            fromFill: null,
+            toFill: 'green',
+          },
+          {
+            kind: 'edge',
+            edgeKey: lineWallDivider,
+            from: 'unknown',
+            to: 'line',
+          },
+        ],
+        after: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 1),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+        ],
+        explanation:
+          'A line blocks every inside path to the right cell, so it must be outside.',
+      },
+      {
+        id: 'outside-barrier-stops-flood',
+        title: 'Outside cell blocks the flood',
+        puzzle: outsideBarrierPuzzle,
+        before: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 0),
+            fromFill: null,
+            toFill: 'green',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 1),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+        ],
+        after: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 2),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+        ],
+        explanation:
+          'The flood cannot pass through the outside cell, so the sealed cell beyond it is also outside.',
+      },
+    ],
+  }
+}
+
+const createOutsideReachabilityColoringExample = (): RuleExampleData => {
+  const enclosedPuzzle = createSlitherPuzzle(1, 1)
+  const enclosedTop = edgeKey([0, 0], [0, 1])
+  const enclosedBottom = edgeKey([1, 0], [1, 1])
+  const enclosedLeft = edgeKey([0, 0], [1, 0])
+  const enclosedRight = edgeKey([0, 1], [1, 1])
+
+  const partialWallPuzzle = createSlitherPuzzle(1, 4)
+  const partialTop0 = edgeKey([0, 0], [0, 1])
+  const partialTop1 = edgeKey([0, 1], [0, 2])
+  const partialTop2 = edgeKey([0, 2], [0, 3])
+  const partialBottom0 = edgeKey([1, 0], [1, 1])
+  const partialBottom1 = edgeKey([1, 1], [1, 2])
+  const partialBottom2 = edgeKey([1, 2], [1, 3])
+  const partialLeft = edgeKey([0, 0], [1, 0])
+  const partialGap = edgeKey([0, 1], [1, 1])
+  const partialRight = edgeKey([0, 3], [1, 3])
+
+  return {
+    cases: [
+      {
+        id: 'fully-enclosed-pocket',
+        title: 'Fully walled pocket',
+        puzzle: enclosedPuzzle,
+        before: [
+          { kind: 'edge', edgeKey: enclosedTop, from: 'unknown', to: 'line' },
+          { kind: 'edge', edgeKey: enclosedBottom, from: 'unknown', to: 'line' },
+          { kind: 'edge', edgeKey: enclosedLeft, from: 'unknown', to: 'line' },
+          { kind: 'edge', edgeKey: enclosedRight, from: 'unknown', to: 'line' },
+        ],
+        after: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 0),
+            fromFill: null,
+            toFill: 'green',
+          },
+        ],
+        explanation:
+          'No passage reaches the exterior, so the enclosed cell must be inside.',
+      },
+      {
+        id: 'partial-wall-with-escape',
+        title: 'One opening stays outside',
+        puzzle: partialWallPuzzle,
+        before: [
+          { kind: 'edge', edgeKey: partialTop0, from: 'unknown', to: 'line' },
+          { kind: 'edge', edgeKey: partialTop1, from: 'unknown', to: 'line' },
+          { kind: 'edge', edgeKey: partialTop2, from: 'unknown', to: 'line' },
+          { kind: 'edge', edgeKey: partialBottom0, from: 'unknown', to: 'line' },
+          { kind: 'edge', edgeKey: partialBottom1, from: 'unknown', to: 'line' },
+          { kind: 'edge', edgeKey: partialBottom2, from: 'unknown', to: 'line' },
+          { kind: 'edge', edgeKey: partialLeft, from: 'unknown', to: 'line' },
+          { kind: 'edge', edgeKey: partialGap, from: 'unknown', to: 'blank' },
+          { kind: 'edge', edgeKey: partialRight, from: 'unknown', to: 'line' },
+        ],
+        after: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 0),
+            fromFill: null,
+            toFill: 'green',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 1),
+            fromFill: null,
+            toFill: 'green',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 2),
+            fromFill: null,
+            toFill: 'green',
+          },
+        ],
+        explanation:
+          'The left pocket cannot reach the exterior, while the rightmost cell still can through the crossed-out gap.',
+      },
+    ],
+  }
+}
+
+const createColorConnectivityCutColoringExample = (): RuleExampleData => {
+  const insideBottleneckPuzzle = createSlitherPuzzle(1, 3)
+
+  const unreachableFromInsidePuzzle = createSlitherPuzzle(1, 3)
+  const unreachableDivider = edgeKey([0, 1], [1, 1])
+
+  const outsideBottleneckPuzzle = createSlitherPuzzle(3, 3)
+
+  const enclosedInsidePuzzle = createSlitherPuzzle(1, 1)
+  const enclosedInsideTop = edgeKey([0, 0], [0, 1])
+  const enclosedInsideBottom = edgeKey([1, 0], [1, 1])
+  const enclosedInsideLeft = edgeKey([0, 0], [1, 0])
+  const enclosedInsideRight = edgeKey([0, 1], [1, 1])
+
+  return {
+    cases: [
+      {
+        id: 'inside-connectivity-cut',
+        title: 'Inside bottleneck',
+        puzzle: insideBottleneckPuzzle,
+        before: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 0),
+            fromFill: null,
+            toFill: 'green',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 2),
+            fromFill: null,
+            toFill: 'green',
+          },
+        ],
+        after: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 1),
+            fromFill: null,
+            toFill: 'green',
+          },
+        ],
+        explanation:
+          'Two inside sources would disconnect unless the middle cell is also inside.',
+      },
+      {
+        id: 'unreachable-from-inside',
+        title: 'Walled off from inside',
+        puzzle: unreachableFromInsidePuzzle,
+        before: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 0),
+            fromFill: null,
+            toFill: 'green',
+          },
+          {
+            kind: 'edge',
+            edgeKey: unreachableDivider,
+            from: 'unknown',
+            to: 'line',
+          },
+        ],
+        after: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 1),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 2),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+        ],
+        explanation:
+          'Line walls separate these cells from every inside source, so they must be outside.',
+      },
+      {
+        id: 'outside-connectivity-cut',
+        title: 'Outside bottleneck',
+        puzzle: outsideBottleneckPuzzle,
+        before: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(1, 0),
+            fromFill: null,
+            toFill: 'green',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(1, 1),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(1, 2),
+            fromFill: null,
+            toFill: 'green',
+          },
+          {
+            kind: 'cell',
+            cellKey: cellKey(2, 1),
+            fromFill: null,
+            toFill: 'green',
+          },
+        ],
+        after: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 1),
+            fromFill: null,
+            toFill: 'yellow',
+          },
+        ],
+        explanation:
+          'The exterior would disconnect from the outside cell unless the top center cell is also outside.',
+      },
+      {
+        id: 'unreachable-from-outside',
+        title: 'Walled off from outside',
+        puzzle: enclosedInsidePuzzle,
+        before: [
+          {
+            kind: 'edge',
+            edgeKey: enclosedInsideTop,
+            from: 'unknown',
+            to: 'line',
+          },
+          {
+            kind: 'edge',
+            edgeKey: enclosedInsideBottom,
+            from: 'unknown',
+            to: 'line',
+          },
+          {
+            kind: 'edge',
+            edgeKey: enclosedInsideLeft,
+            from: 'unknown',
+            to: 'line',
+          },
+          {
+            kind: 'edge',
+            edgeKey: enclosedInsideRight,
+            from: 'unknown',
+            to: 'line',
+          },
+        ],
+        after: [
+          {
+            kind: 'cell',
+            cellKey: cellKey(0, 0),
+            fromFill: null,
+            toFill: 'green',
+          },
+        ],
+        explanation:
+          'With no outside source on the board, the fully line-bounded cell cannot reach the exterior and must be inside.',
+      },
+    ],
+  }
+}
+
+const createClueVertexCandidateCombinationPruningExample = (): RuleExampleData => {
+  const clueZeroPuzzle = createSlitherPuzzle(3, 3)
+  clueZeroPuzzle.cells[cellKey(1, 1)] = { clue: { kind: 'number', value: 0 } }
+
+  const clueOnePuzzle = createSlitherPuzzle(3, 3)
+  clueOnePuzzle.cells[cellKey(1, 1)] = { clue: { kind: 'number', value: 1 } }
+
+  const clueThreePuzzle = createSlitherPuzzle(3, 3)
+  clueThreePuzzle.cells[cellKey(1, 1)] = { clue: { kind: 'number', value: 3 } }
+
+  const clueTwoCornerPuzzle = createSlitherPuzzle(3, 3)
+  clueTwoCornerPuzzle.cells[cellKey(0, 0)] = { clue: { kind: 'number', value: 2 } }
+
+  const allCornerSectorDiffs = (
+    row: number,
+    col: number,
+    toMask: number,
+  ): RuleDiff[] =>
+    (['nw', 'ne', 'sw', 'se'] as const).map((corner) => ({
+      kind: 'sector' as const,
+      sectorKey: sectorKey(row, col, corner),
+      fromMask: SECTOR_MASK_ALL,
+      toMask,
+    }))
+
+  return {
+    cases: [
+      {
+        id: 'clue-zero-corners',
+        title: 'Clue 0',
+        puzzle: clueZeroPuzzle,
+        after: allCornerSectorDiffs(1, 1, SECTOR_MASK_ONLY_0),
+        explanation:
+          'A lone 0 allows no cell edges, so every corner sector is narrowed to zero lines.',
+      },
+      {
+        id: 'clue-one-corners',
+        title: 'Clue 1',
+        puzzle: clueOnePuzzle,
+        after: allCornerSectorDiffs(1, 1, SECTOR_MASK_NOT_2),
+        explanation:
+          'A lone 1 cannot use both sector edges at any corner, so every sector forbids two lines.',
+      },
+      {
+        id: 'clue-three-corners',
+        title: 'Clue 3',
+        puzzle: clueThreePuzzle,
+        after: allCornerSectorDiffs(1, 1, SECTOR_MASK_NOT_0),
+        explanation:
+          'A lone 3 needs lines on every cell edge, so no corner sector can be empty.',
+      },
+      {
+        id: 'clue-two-boundary',
+        title: 'Clue 2 at a corner',
+        puzzle: clueTwoCornerPuzzle,
+        after: [
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(0, 0, 'nw'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_NOT_1,
+          },
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(0, 0, 'ne'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_ONLY_1,
+          },
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(0, 0, 'sw'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_ONLY_1,
+          },
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(0, 0, 'se'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_NOT_1,
+          },
+        ],
+        explanation:
+          'A corner 2 splits the four-corner combinations asymmetrically: the two board-corner sectors must each have exactly one line.',
+      },
+    ],
+  }
+}
+
+const createSectorClueOneThreeIntraCellPropagationExample = (): RuleExampleData => {
+  const clueOnePuzzle = createSlitherPuzzle(2, 2)
+  clueOnePuzzle.cells[cellKey(0, 0)] = { clue: { kind: 'number', value: 1 } }
+  clueOnePuzzle.sectors[sectorKey(0, 0, 'nw')].constraintsMask = SECTOR_MASK_ONLY_1
+  const clueOneBottom = edgeKey([1, 0], [1, 1])
+  const clueOneRight = edgeKey([0, 1], [1, 1])
+
+  const clueThreePuzzle = createSlitherPuzzle(2, 2)
+  clueThreePuzzle.cells[cellKey(0, 0)] = { clue: { kind: 'number', value: 3 } }
+  clueThreePuzzle.sectors[sectorKey(0, 0, 'nw')].constraintsMask = SECTOR_MASK_ONLY_1
+
+  return {
+    cases: [
+      {
+        id: 'clue-one-opposite-blank',
+        title: 'Clue 1',
+        puzzle: clueOnePuzzle,
+        before: [
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(0, 0, 'nw'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_ONLY_1,
+          },
+        ],
+        after: [
+          { kind: 'edge', edgeKey: clueOneBottom, from: 'unknown', to: 'blank' },
+          { kind: 'edge', edgeKey: clueOneRight, from: 'unknown', to: 'blank' },
+        ],
+        explanation:
+          'The northwest sector already has its one line, so the opposite cell edges are crossed out.',
+      },
+      {
+        id: 'clue-three-opposite-line',
+        title: 'Clue 3',
+        puzzle: clueThreePuzzle,
+        before: [
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(0, 0, 'nw'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_ONLY_1,
+          },
+        ],
+        after: [
+          { kind: 'edge', edgeKey: clueOneBottom, from: 'unknown', to: 'line' },
+          { kind: 'edge', edgeKey: clueOneRight, from: 'unknown', to: 'line' },
+        ],
+        explanation:
+          'The northwest sector already has its one line, so the opposite pair must supply the other two lines for clue 3.',
+      },
+    ],
+  }
+}
+
+const createVertexOnlyOneNonSectorBalanceExample = (): RuleExampleData => {
+  const blankForcesLinePuzzle = createSlitherPuzzle(3, 3)
+  blankForcesLinePuzzle.sectors[sectorKey(0, 0, 'se')].constraintsMask =
+    SECTOR_MASK_ONLY_1
+  const blankBottom = edgeKey([1, 1], [2, 1])
+  const blankRight = edgeKey([1, 1], [1, 2])
+
+  const lineForcesBlankPuzzle = createSlitherPuzzle(3, 3)
+  lineForcesBlankPuzzle.sectors[sectorKey(0, 0, 'se')].constraintsMask =
+    SECTOR_MASK_ONLY_1
+
+  const boundaryPuzzle = createSlitherPuzzle(3, 3)
+  boundaryPuzzle.sectors[sectorKey(0, 1, 'nw')].constraintsMask = SECTOR_MASK_ONLY_1
+
+  return {
+    cases: [
+      {
+        id: 'outside-blank-forces-line',
+        title: 'Outside edge crossed out',
+        puzzle: blankForcesLinePuzzle,
+        before: [
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(0, 0, 'se'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_ONLY_1,
+          },
+          { kind: 'edge', edgeKey: blankBottom, from: 'unknown', to: 'blank' },
+        ],
+        after: [
+          { kind: 'edge', edgeKey: blankRight, from: 'unknown', to: 'line' },
+        ],
+        explanation:
+          'With one outside edge crossed out, the vertex still needs its second line on the other outside edge.',
+      },
+      {
+        id: 'outside-line-forces-blank',
+        title: 'Outside edge already a line',
+        puzzle: lineForcesBlankPuzzle,
+        before: [
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(0, 0, 'se'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_ONLY_1,
+          },
+          { kind: 'edge', edgeKey: blankRight, from: 'unknown', to: 'line' },
+        ],
+        after: [
+          { kind: 'edge', edgeKey: blankBottom, from: 'unknown', to: 'blank' },
+        ],
+        explanation:
+          'The outside line and the sector line already satisfy degree two, so the other outside edge is crossed out.',
+      }
+    ],
+  }
+}
+
+const createSectorNotOneClueTwoPropagationExample = (): RuleExampleData => {
+  const northwestTargetPuzzle = createSlitherPuzzle(2, 2)
+  northwestTargetPuzzle.cells[cellKey(0, 0)] = { clue: { kind: 'number', value: 2 } }
+  northwestTargetPuzzle.sectors[sectorKey(0, 0, 'nw')].constraintsMask =
+    SECTOR_MASK_NOT_1
+  const northwestTop = edgeKey([0, 0], [0, 1])
+  const northwestLeft = edgeKey([0, 0], [1, 0])
+  const southeastLine = edgeKey([1, 0], [1, 1])
+
+  const northeastTargetPuzzle = createSlitherPuzzle(2, 2)
+  northeastTargetPuzzle.cells[cellKey(0, 0)] = { clue: { kind: 'number', value: 2 } }
+  northeastTargetPuzzle.sectors[sectorKey(0, 0, 'ne')].constraintsMask =
+    SECTOR_MASK_NOT_1
+  const northeastTop = edgeKey([0, 0], [0, 1])
+  const northeastRight = edgeKey([0, 1], [1, 1])
+  const southwestLine = edgeKey([0, 0], [1, 0])
+
+  return {
+    cases: [
+      {
+        id: 'not-one-nw-target',
+        title: 'Northwest target',
+        puzzle: northwestTargetPuzzle,
+        before: [
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(0, 0, 'nw'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_NOT_1,
+          },
+          { kind: 'edge', edgeKey: southeastLine, from: 'unknown', to: 'line' },
+        ],
+        after: [
+          { kind: 'edge', edgeKey: northwestTop, from: 'unknown', to: 'blank' },
+          { kind: 'edge', edgeKey: northwestLeft, from: 'unknown', to: 'blank' },
+        ],
+        explanation:
+          'Southeast already has a line, so the not-one northwest sector cannot take any line.',
+      },
+      {
+        id: 'not-one-ne-target',
+        title: 'Northeast target',
+        puzzle: northeastTargetPuzzle,
+        before: [
+          {
+            kind: 'sector',
+            sectorKey: sectorKey(0, 0, 'ne'),
+            fromMask: SECTOR_MASK_ALL,
+            toMask: SECTOR_MASK_NOT_1,
+          },
+          { kind: 'edge', edgeKey: southwestLine, from: 'unknown', to: 'line' },
+        ],
+        after: [
+          { kind: 'edge', edgeKey: northeastTop, from: 'unknown', to: 'blank' },
+          { kind: 'edge', edgeKey: northeastRight, from: 'unknown', to: 'blank' },
+        ],
+        explanation:
+          'The mirrored diagonal case blanks the northeast sector when southwest already contributes a line.',
+      },
+    ],
+  }
+}
+
+const createPreventPrematureLoopExample = (): RuleExampleData => {
+  const puzzle = createSlitherPuzzle(3, 6)
+  const top = edgeKey([1, 0], [1, 1])
+  const right = edgeKey([1, 1], [2, 1])
+  const bottom = edgeKey([2, 0], [2, 1])
+  const closing = edgeKey([1, 0], [2, 0])
+  const other = edgeKey([3, 2], [3, 6])
+
+  return example({
+    id: 'closing-edge-blank',
+    puzzle,
+    before: [
+      { kind: 'edge', edgeKey: top, from: 'unknown', to: 'line' },
+      { kind: 'edge', edgeKey: right, from: 'unknown', to: 'line' },
+      { kind: 'edge', edgeKey: bottom, from: 'unknown', to: 'line' },
+      { kind: 'edge', edgeKey: other, from: 'unknown', to: 'line' },
+    ],
+    after: [{ kind: 'edge', edgeKey: closing, from: 'unknown', to: 'blank' }],
+    explanation:
+      'The three drawn edges already connect both endpoints through another path, the remaining edge would close a smaller loop, considering we have another known lines.',
+  })
+}
+
 export const ruleExamples: Record<string, RuleExampleData> = {
   'masyu:white-pearl-rule': createWhitePearlExample(),
   'masyu:black-pearl-rule': createBlackPearlExample(),
   'slitherlink:vertex-degree': createVertexDegreeExample(),
+  'slitherlink:sector-constraint-edge-propagation':
+    createSectorConstraintEdgePropagationExample(),
+  'slitherlink:sector-inference': createSectorInferenceExample(),
+  'slitherlink:sector-diagonal-shared-vertex-propagation':
+    createSectorDiagonalSharedVertexPropagationExample(),
+  'slitherlink:contiguous-three-run-boundaries': createAdjacentThreesExample(),
+  'slitherlink:diagonal-adjacent-three-outer-corners':
+    createDiagonalThreesExample(),
+  'slitherlink:cell-count-completion': createCellClueCompletionExample(),
+  'slitherlink:adjacent-two-three-opposite-cross':
+    createAdjacentTwoThreeOppositeCrossExample(),
+  'slitherlink:color-edge-propagation': createColorEdgePropagationExample(),
+  'slitherlink:color-outside-seeding': createColorOutsideSeedingExample(),
+  'slitherlink:color-clue-propagation': createColorCluePropagationExample(),
+  'slitherlink:color-sector-mask-propagation':
+    createColorSectorMaskPropagationExample(),
+  'slitherlink:color-orthogonal-consensus-propagation':
+    createColorOrthogonalConsensusPropagationExample(),
+  'slitherlink:inside-reachability-coloring':
+    createInsideReachabilityColoringExample(),
+  'slitherlink:outside-reachability-coloring':
+    createOutsideReachabilityColoringExample(),
+  'slitherlink:color-connectivity-cut-coloring':
+    createColorConnectivityCutColoringExample(),
+  'slitherlink:prevent-premature-loop': createPreventPrematureLoopExample(),
+  'slitherlink:clue-vertex-candidate-combination-pruning':
+    createClueVertexCandidateCombinationPruningExample(),
+  'slitherlink:sector-clue-one-three-intra-cell-propagation':
+    createSectorClueOneThreeIntraCellPropagationExample(),
+  'slitherlink:vertex-onlyone-non-sector-balance':
+    createVertexOnlyOneNonSectorBalanceExample(),
+  'slitherlink:sector-not-one-clue-two-propagation':
+    createSectorNotOneClueTwoPropagationExample(),
 }
diff --git a/src/features/solver/solverStore.test.ts b/src/features/solver/solverStore.test.ts
index 8c6f7ea..b3f8ae4 100644
--- a/src/features/solver/solverStore.test.ts
+++ b/src/features/solver/solverStore.test.ts
@@ -697,7 +697,7 @@ describe('solver store cell color replay', () => {
     const mockStep: RuleStep = {
       id: 'step-1',
       ruleId: 'color-edge-propagation',
-      ruleName: 'Color-Edge Propagation',
+      ruleName: 'Color-Edge Consistency',
       message: 'test',
       diffs: [
         {