test(l1): add per-phase timing breakdown to multisync Slack notifications (#6136)

**Motivation**

The multisync monitoring script (`docker_monitor.py`) sends Slack
notifications at the end of each sync run, but they only report the
total sync time per network. When investigating performance regressions
or comparing runs, we had to manually SSH into the server and parse raw
container logs to figure out which phase was slow. This is
time-consuming and error-prone.

The sync logs already contain per-phase completion markers like:
```
✓ BLOCK HEADERS complete: 25,693,009 headers in 0:29:00
✓ STORAGE HEALING complete: 87,414 storage accounts healed in 1:42:00
```

This PR surfaces that data directly in the Slack notification, so
performance bottlenecks are visible at a glance.

**Description**

Adds three things to `tooling/sync/docker_monitor.py`:

1. **`PHASE_COMPLETION_PATTERNS` dict** — Regex patterns for all 8 snap
sync phases:
- Block Headers, Account Ranges, Account Insertion, Storage Ranges,
Storage Insertion, State Healing, Storage Healing, Bytecodes

2. **`parse_phase_timings(run_id, container)` function** — Reads saved
container log files from `multisync_logs/run_{run_id}/{container}.log`
and extracts `(phase_name, item_count, duration)` for each completed
phase. Returns an empty list if logs are missing or if a phase didn't
complete (e.g., on a failed run), so the behavior is graceful.

3. **Phase breakdown in Slack and run logs** — After the per-instance
status line, a code block is appended showing the full phase timing
table. The same breakdown is also written to `run_history.log` and the
per-run `summary.txt`.

### Expected Slack output (successful run)

The Slack message will now include a section like this for each network
instance:

```
📊 Phase Breakdown — mainnet
Block Headers       0:29:00  (25,693,009)
Account Ranges      0:45:12  (12,345,678)
Account Insertion   0:12:34  (12,345,678)
Storage Ranges      0:38:45  (1,234,567)
Storage Insertion   0:08:23  (1,234,567)
State Healing       0:15:00  (87,414)
Storage Healing     1:42:00  (87,414)
Bytecodes           0:05:30  (45,678)
```

Phase names are left-aligned with padding for readability. The count in
parentheses corresponds to the number of items processed (headers,
accounts, storage slots, etc.).

### Expected Slack output (failed run with partial phases)

If a run fails mid-sync (e.g., timeout during storage healing), only the
phases that completed are shown:

```
📊 Phase Breakdown — mainnet
Block Headers       0:29:00  (25,693,009)
Account Ranges      0:45:12  (12,345,678)
Account Insertion   0:12:34  (12,345,678)
Storage Ranges      0:38:45  (1,234,567)
Storage Insertion   0:08:23  (1,234,567)
```

Phases that never completed (State Healing, Storage Healing, Bytecodes
in this case) are simply omitted — no placeholder or "N/A" rows.

### Expected text log output (`summary.txt` / `run_history.log`)

```
  ✅ mainnet: success (sync: 4h 32m 15s)
    Phase Breakdown:
      Block Headers       0:29:00  (25,693,009)
      Account Ranges      0:45:12  (12,345,678)
      Account Insertion   0:12:34  (12,345,678)
      Storage Ranges      0:38:45  (1,234,567)
      Storage Insertion   0:08:23  (1,234,567)
      State Healing       0:15:00  (87,414)
      Storage Healing     1:42:00  (87,414)
      Bytecodes           0:05:30  (45,678)
```

### How it works

The flow is:
1. `save_all_logs()` saves container logs to disk (already existed, no
changes)
2. `log_run_result()` now calls `parse_phase_timings()` and appends
breakdown to text log
3. `slack_notify()` now calls `parse_phase_timings()` and appends code
blocks to Slack payload

Since `save_all_logs()` is called before both `log_run_result()` and
`slack_notify()` (lines 721→725 in main loop), the saved log files are
always available for parsing.

### Edge cases

| Scenario | Behavior |
|----------|----------|
| Run fails before any phase completes | No breakdown section shown |
| Log file missing or unreadable | Empty list returned, no breakdown |
| Only some phases completed | Only completed phases listed |
| Multiple networks (hoodi, sepolia, mainnet) | Separate breakdown per
instance |

**Checklist**

- [ ] Updated `STORE_SCHEMA_VERSION` (crates/storage/lib.rs) if the PR
includes breaking changes to the `Store` requiring a re-sync.

N/A — This PR only modifies the Python monitoring script, no Rust code
or storage changes.

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: pablodeymo

tooling/sync/docker_monitor.py

@@ -48,6 +48,18 @@
     "block_processing": "📦", "success": "🎉", "failed": "❌"
 }
 
+# Phase completion patterns for parsing sync logs
+PHASE_COMPLETION_PATTERNS = {
+    "Block Headers": r"✓ BLOCK HEADERS complete: ([\d,]+) headers in (\d+:\d{2}:\d{2})",
+    "Account Ranges": r"✓ ACCOUNT RANGES complete: ([\d,]+) accounts in (\d+:\d{2}:\d{2})",
+    "Account Insertion": r"✓ ACCOUNT INSERTION complete: ([\d,]+) accounts inserted in (\d+:\d{2}:\d{2})",
+    "Storage Ranges": r"✓ STORAGE RANGES complete: ([\d,]+) storage slots in (\d+:\d{2}:\d{2})",
+    "Storage Insertion": r"✓ STORAGE INSERTION complete: ([\d,]+) storage slots inserted in (\d+:\d{2}:\d{2})",
+    "State Healing": r"✓ STATE HEALING complete: ([\d,]+) state paths healed in (\d+:\d{2}:\d{2})",
+    "Storage Healing": r"✓ STORAGE HEALING complete: ([\d,]+) storage accounts healed in (\d+:\d{2}:\d{2})",
+    "Bytecodes": r"✓ BYTECODES complete: ([\d,]+) bytecodes in (\d+:\d{2}:\d{2})",
+}
+
 
 @dataclass
 class Instance:
@@ -262,6 +274,30 @@ def rpc_call(url: str, method: str) -> Optional[Any]:
         return None
 
 
+def parse_phase_timings(run_id: str, container: str) -> list[tuple[str, str, str]]:
+    """Parse phase completion times from saved container logs.
+
+    Returns list of (phase_name, count, duration) tuples.
+    """
+    log_file = LOGS_DIR / f"run_{run_id}" / f"{container}.log"
+    if not log_file.exists():
+        return []
+
+    try:
+        logs = log_file.read_text()
+    except Exception:
+        return []
+
+    phases = []
+    for phase_name, pattern in PHASE_COMPLETION_PATTERNS.items():
+        match = re.search(pattern, logs)
+        if match:
+            count = match.group(1)
+            duration = match.group(2)
+            phases.append((phase_name, count, duration))
+    return phases
+
+
 def slack_notify(run_id: str, run_count: int, instances: list, hostname: str, branch: str, commit: str, build_profile: str = ""):
     """Send a single summary Slack message for the run."""
     all_success = all(i.status == "success" for i in instances)
@@ -319,6 +355,21 @@ def slack_notify(run_id: str, run_count: int, instances: list, hostname: str, br
         if i.error:
             line += f"\n       Error: {i.error}"
         blocks.append({"type": "section", "text": {"type": "mrkdwn", "text": line}})
+
+    # Add phase breakdown for each instance
+    for i in instances:
+        phases = parse_phase_timings(run_id, i.container)
+        if phases:
+            phase_lines = [f"📊 *Phase Breakdown — {i.name}*", "```"]
+            max_name_len = max(len(name) for name, _, _ in phases)
+            for name, count, duration in phases:
+                phase_lines.append(f"{name:<{max_name_len}}  {duration}  ({count})")
+            phase_lines.append("```")
+            blocks.append({
+                "type": "section",
+                "text": {"type": "mrkdwn", "text": "\n".join(phase_lines)}
+            })
+
     try:
         requests.post(url, json={"blocks": blocks}, timeout=10)
     except Exception:
@@ -417,6 +468,15 @@ def log_run_result(run_id: str, run_count: int, instances: list[Instance], hostn
         if inst.error:
             line += f"\n       Error: {inst.error}"
         lines.append(line)
+
+        # Add phase breakdown
+        phases = parse_phase_timings(run_id, inst.container)
+        if phases:
+            lines.append(f"    Phase Breakdown:")
+            max_name_len = max(len(name) for name, _, _ in phases)
+            for name, count, duration in phases:
+                lines.append(f"      {name:<{max_name_len}}  {duration}  ({count})")
+
     lines.append("")
     # Append to log file
     with open(RUN_LOG_FILE, "a") as f: