Evaluator: add debug-level tracing for skipped rules

[unclesp1d3r]

Summary

Add debug-level trace output when evaluate_rules skips a rule due to an expected evaluation error (BufferOverrun, InvalidOffset, TypeReadError).

Context

In src/evaluator/engine/mod.rs, the evaluate_rules function gracefully skips individual rules that fail with expected evaluation errors (line ~200). This is correct behavior -- one rule's buffer overrun should not abort evaluation of all remaining rules.

However, when a rule is skipped, there is no diagnostic output. Users cannot distinguish between "rule didn't match the file" and "rule failed internally." This makes debugging magic file rules difficult.

Acceptance Criteria

• Emit a debug-level trace when a rule is skipped due to evaluation error
• Include the rule message and error details in the trace
• No output at default log level (debug only)
• Same treatment for child rule evaluation errors (line ~250)

Impact

LOW -- Developer/debugging experience improvement. No functional impact.

Files to Modify

• src/evaluator/engine/mod.rs -- Add tracing::debug! or log::debug! calls at skip points

References

• TODO comment at src/evaluator/engine/mod.rs:201

[traycerai]

Warning

Ticket Assist will be discontinued on May 1, 2026. After that date, the feature will no longer be available. We suggest installing the Traycer IDE Extension for continued AI-powered, spec-driven development. Thank you for choosing Traycer!

Plan

Observations

The codebase currently has no logging framework — neither tracing nor log is in Cargo.toml. The only diagnostic output is raw eprintln! calls guarded by #[allow(clippy::print_stderr)], with a comment in file:src/parser/loader.rs (line 180) explicitly noting "consider a logging framework in the future." The two skip points in file:src/evaluator/engine/mod.rs are at lines 199–201 (top-level rule skip) and lines 251–253 (child rule skip). The clippy config has use_debug = "warn", so {:?} formatting must be avoided in favour of {} (Display).

Approach

Add the log crate (the standard Rust logging facade) as a dependency — it is lighter-weight than tracing, has no proc-macro overhead, and is the idiomatic choice for a library crate. Then emit log::debug! calls at both skip points. Library consumers can plug in any log-compatible backend (e.g., env_logger) to see the output; at default log level nothing is emitted.

Implementation Steps

1. Add log to Cargo.toml

In file:Cargo.toml, under [dependencies], add:

log = "0.4"

No feature flags are needed. Do not add a backend (e.g., env_logger) — that is the consumer's responsibility for a library crate.

2. Add use log::debug; import to file:src/evaluator/engine/mod.rs

At the top of the file after the existing use statements (after line 16), add:

use log::debug;

This makes the debug! macro available throughout the module.

3. Add log::debug! at the top-level rule skip point

In file:src/evaluator/engine/mod.rs, modify the error handling match arm at lines 192–202. Currently it reads:

Err(
    LibmagicError::EvaluationError(
        crate::error::EvaluationError::BufferOverrun { .. }
        | crate::error::EvaluationError::InvalidOffset { .. }
        | crate::error::EvaluationError::TypeReadError(_),
    )
    | LibmagicError::IoError(_),
) => {
    // Expected evaluation errors for individual rules -- skip gracefully
    continue;
}

Change it to bind the error and emit a debug log:

Err(e @ (
    LibmagicError::EvaluationError(
        crate::error::EvaluationError::BufferOverrun { .. }
        | crate::error::EvaluationError::InvalidOffset { .. }
        | crate::error::EvaluationError::TypeReadError(_),
    )
    | LibmagicError::IoError(_),
)) => {
    // Expected evaluation errors for individual rules -- skip gracefully
    debug!("Skipping rule '{}' due to evaluation error: {}", rule.message, e);
    continue;
}

4. Add log::debug! at the child rule skip point

In file:src/evaluator/engine/mod.rs, modify the error handling match arm at lines 244–253. Currently it reads:

Err(
    LibmagicError::EvaluationError(
        crate::error::EvaluationError::BufferOverrun { .. }
        | crate::error::EvaluationError::InvalidOffset { .. }
        | crate::error::EvaluationError::TypeReadError(_),
    )
    | LibmagicError::IoError(_),
) => {
    // Expected child evaluation errors -- skip gracefully
}

Change it to bind the error and emit a debug log:

Err(e @ (
    LibmagicError::EvaluationError(
        crate::error::EvaluationError::BufferOverrun { .. }
        | crate::error::EvaluationError::InvalidOffset { .. }
        | crate::error::EvaluationError::TypeReadError(_),
    )
    | LibmagicError::IoError(_),
)) => {
    // Expected child evaluation errors -- skip gracefully
    debug!("Skipping child rules of '{}' due to evaluation error: {}", rule.message, e);
}

Summary

File	Change
file:Cargo.toml	Add log = "0.4" to [dependencies]
file:src/evaluator/engine/mod.rs	Add use log::debug; import
file:src/evaluator/engine/mod.rs	Bind error and emit debug! at top-level skip point (~line 200)
file:src/evaluator/engine/mod.rs	Bind error and emit debug! at child rule skip point (~line 252)

The log crate emits nothing at runtime unless a subscriber is registered by the binary/test harness, satisfying the "no output at default log level" acceptance criterion. Both log messages use {} (Display) for the error to comply with the use_debug = "warn" clippy lint.

Import In IDE

🤖 Prompt for AI Agents

# Observations

The codebase currently has **no logging framework** — neither `tracing` nor `log` is in `Cargo.toml`. The only diagnostic output is raw `eprintln!` calls guarded by `#[allow(clippy::print_stderr)]`, with a comment in `file:src/parser/loader.rs` (line 180) explicitly noting _"consider a logging framework in the future."_ The two skip points in `file:src/evaluator/engine/mod.rs` are at lines 199–201 (top-level rule skip) and lines 251–253 (child rule skip). The `clippy` config has `use_debug = "warn"`, so `{:?}` formatting must be avoided in favour of `{}` (Display).

# Approach

Add the `log` crate (the standard Rust logging facade) as a dependency — it is lighter-weight than `tracing`, has no proc-macro overhead, and is the idiomatic choice for a library crate. Then emit `log::debug!` calls at both skip points. Library consumers can plug in any `log`-compatible backend (e.g., `env_logger`) to see the output; at default log level nothing is emitted.

# Implementation Steps

## 1. Add `log` to `Cargo.toml`

In `file:Cargo.toml`, under `[dependencies]`, add:

```
log = "0.4"
```

No feature flags are needed. Do **not** add a backend (e.g., `env_logger`) — that is the consumer's responsibility for a library crate.

## 2. Add `use log::debug;` import to `file:src/evaluator/engine/mod.rs`

At the top of the file after the existing `use` statements (after line 16), add:

```rust
use log::debug;
```

This makes the `debug!` macro available throughout the module.

## 3. Add `log::debug!` at the top-level rule skip point

In `file:src/evaluator/engine/mod.rs`, modify the error handling match arm at lines 192–202. Currently it reads:

```rust
Err(
    LibmagicError::EvaluationError(
        crate::error::EvaluationError::BufferOverrun { .. }
        | crate::error::EvaluationError::InvalidOffset { .. }
        | crate::error::EvaluationError::TypeReadError(_),
    )
    | LibmagicError::IoError(_),
) => {
    // Expected evaluation errors for individual rules -- skip gracefully
    continue;
}
```

Change it to bind the error and emit a debug log:

```rust
Err(e @ (
    LibmagicError::EvaluationError(
        crate::error::EvaluationError::BufferOverrun { .. }
        | crate::error::EvaluationError::InvalidOffset { .. }
        | crate::error::EvaluationError::TypeReadError(_),
    )
    | LibmagicError::IoError(_),
)) => {
    // Expected evaluation errors for individual rules -- skip gracefully
    debug!("Skipping rule '{}' due to evaluation error: {}", rule.message, e);
    continue;
}
```

## 4. Add `log::debug!` at the child rule skip point

In `file:src/evaluator/engine/mod.rs`, modify the error handling match arm at lines 244–253. Currently it reads:

```rust
Err(
    LibmagicError::EvaluationError(
        crate::error::EvaluationError::BufferOverrun { .. }
        | crate::error::EvaluationError::InvalidOffset { .. }
        | crate::error::EvaluationError::TypeReadError(_),
    )
    | LibmagicError::IoError(_),
) => {
    // Expected child evaluation errors -- skip gracefully
}
```

Change it to bind the error and emit a debug log:

```rust
Err(e @ (
    LibmagicError::EvaluationError(
        crate::error::EvaluationError::BufferOverrun { .. }
        | crate::error::EvaluationError::InvalidOffset { .. }
        | crate::error::EvaluationError::TypeReadError(_),
    )
    | LibmagicError::IoError(_),
)) => {
    // Expected child evaluation errors -- skip gracefully
    debug!("Skipping child rules of '{}' due to evaluation error: {}", rule.message, e);
}
```

# Summary

| File | Change |
|---|---|
| `file:Cargo.toml` | Add `log = "0.4"` to `[dependencies]` |
| `file:src/evaluator/engine/mod.rs` | Add `use log::debug;` import |
| `file:src/evaluator/engine/mod.rs` | Bind error and emit `debug!` at top-level skip point (~line 200) |
| `file:src/evaluator/engine/mod.rs` | Bind error and emit `debug!` at child rule skip point (~line 252) |

The `log` crate emits nothing at runtime unless a subscriber is registered by the binary/test harness, satisfying the "no output at default log level" acceptance criterion. Both log messages use `{}` (Display) for the error to comply with the `use_debug = "warn"` clippy lint.

---

Execution Information

Branch: main
Commit: 8be6924

---

💡 Tips

Supported Commands (Inside Comments)

• Use @traycerai generate to iterate on the previous version of the implementation plan.

Supported Commands (Inside Description)

• Add @traycerai ignore anywhere in the ticket description to prevent this ticket from being processed.
• Add @traycerai branch:<branch-name> anywhere in the ticket description to specify the target branch for the implementation plan.

Community

• Join our Discord Community to get help, request features, and share feedback.
• Follow us on X/Twitter for updates and announcements.

[traycerai]

I have updated the Implementation Plan to reflect the recent changes in the ticket.

Previous Plan

Observations

The codebase currently has no logging framework — neither tracing nor log is in Cargo.toml. The only diagnostic output is raw eprintln! calls guarded by #[allow(clippy::print_stderr)], with a comment in file:src/parser/loader.rs (line 179) explicitly noting "consider a logging framework in the future." The two skip points in file:src/evaluator/engine/mod.rs are at lines 199–201 (top-level rule skip) and lines 251–253 (child rule skip). The clippy config has use_debug = "warn", so {:?} formatting must be avoided in favour of {} (Display).

Approach

Add the log crate (the standard Rust logging facade) as a dependency — it is lighter-weight than tracing, has no proc-macro overhead, and is the idiomatic choice for a library crate. Then emit log::debug! calls at both skip points. Library consumers can plug in any log-compatible backend (e.g., env_logger) to see the output; at default log level nothing is emitted.

---

Implementation Steps

1. Add log to Cargo.toml

In file:Cargo.toml, under [dependencies], add:

log = "0.4"

No feature flags are needed. Do not add a backend (e.g., env_logger) — that is the consumer's responsibility for a library crate.

---

2. Add log::debug! at the top-level rule skip point

In file:src/evaluator/engine/mod.rs, in the evaluate_rules function, replace the comment-only continue block (lines 199–202) with a log::debug! call before the continue. The message should include:

• The rule's message field (identifies which rule was skipped)
• The error e (Display format, not Debug, to satisfy use_debug = "warn")

The match arm currently looks like:

Err(
    LibmagicError::EvaluationError(
        crate::error::EvaluationError::BufferOverrun { .. }
        | crate::error::EvaluationError::InvalidOffset { .. }
        | crate::error::EvaluationError::TypeReadError(_),
    )
    | LibmagicError::IoError(_),
) => {
    // Expected evaluation errors for individual rules -- skip gracefully
    continue;
}

Bind the error to a variable (e.g., e) in the pattern so it can be logged, then emit log::debug! with the rule message and error before continue.

---

3. Add log::debug! at the child rule skip point

In the same function, the child-rule skip arm (lines 244–253) currently has only a comment. Apply the same treatment: bind the error, emit log::debug! including the parent rule's message and the error, then let the arm fall through (no continue needed here — it's already a non-returning arm).

---

4. Add use log::debug; import

At the top of file:src/evaluator/engine/mod.rs, add use log::debug; alongside the existing use statements, or use the fully-qualified log::debug! macro path — either is acceptable; the fully-qualified form avoids an unused-import warning if the macro is conditionally compiled away.

---

Resulting call-site shape (conceptual, not code)

Location	What to log
Top-level rule skip (~line 200)	"Skipping rule '{}' due to evaluation error: {}", rule.message, e
Child rule skip (~line 252)	"Skipping child rules of '{}' due to evaluation error: {}", rule.message, e

Both use {} (Display) for the error to comply with the use_debug = "warn" clippy lint.

---

Sequence of changes

sequenceDiagram
    participant Cargo as Cargo.toml
    participant Engine as evaluator/engine/mod.rs

    Cargo->>Cargo: Add log = "0.4" to [dependencies]
    Engine->>Engine: Add use log::debug (or use fully-qualified path)
    Engine->>Engine: Bind error in top-level skip arm, emit log::debug!
    Engine->>Engine: Bind error in child skip arm, emit log::debug!

Loading

No other files need modification. The log crate emits nothing at runtime unless a subscriber is registered by the binary/test harness, satisfying the "no output at default log level" acceptance criterion.

Import In IDE

🤖 Prompt for AI Agents

## Observations

The codebase currently has **no logging framework** — neither `tracing` nor `log` is in `Cargo.toml`. The only diagnostic output is raw `eprintln!` calls guarded by `#[allow(clippy::print_stderr)]`, with a comment in `file:src/parser/loader.rs` (line 179) explicitly noting _"consider a logging framework in the future."_ The two skip points in `file:src/evaluator/engine/mod.rs` are at lines 199–201 (top-level rule skip) and lines 251–253 (child rule skip). The `clippy` config has `use_debug = "warn"`, so `{:?}` formatting must be avoided in favour of `{}` (Display).

## Approach

Add the `log` crate (the standard Rust logging facade) as a dependency — it is lighter-weight than `tracing`, has no proc-macro overhead, and is the idiomatic choice for a library crate. Then emit `log::debug!` calls at both skip points. Library consumers can plug in any `log`-compatible backend (e.g., `env_logger`) to see the output; at default log level nothing is emitted.

---

## Implementation Steps

### 1. Add `log` to `Cargo.toml`

In `file:Cargo.toml`, under `[dependencies]`, add:

```
log = "0.4"
```

No feature flags are needed. Do **not** add a backend (e.g., `env_logger`) — that is the consumer's responsibility for a library crate.

---

### 2. Add `log::debug!` at the top-level rule skip point

In `file:src/evaluator/engine/mod.rs`, in the `evaluate_rules` function, replace the comment-only `continue` block (lines 199–202) with a `log::debug!` call before the `continue`. The message should include:

- The rule's `message` field (identifies which rule was skipped)
- The error `e` (Display format, not Debug, to satisfy `use_debug = "warn"`)

The match arm currently looks like:

```rust
Err(
    LibmagicError::EvaluationError(
        crate::error::EvaluationError::BufferOverrun { .. }
        | crate::error::EvaluationError::InvalidOffset { .. }
        | crate::error::EvaluationError::TypeReadError(_),
    )
    | LibmagicError::IoError(_),
) => {
    // Expected evaluation errors for individual rules -- skip gracefully
    continue;
}
```

Bind the error to a variable (e.g., `e`) in the pattern so it can be logged, then emit `log::debug!` with the rule message and error before `continue`.

---

### 3. Add `log::debug!` at the child rule skip point

In the same function, the child-rule skip arm (lines 244–253) currently has only a comment. Apply the same treatment: bind the error, emit `log::debug!` including the parent rule's `message` and the error, then let the arm fall through (no `continue` needed here — it's already a non-returning arm).

---

### 4. Add `use log::debug;` import

At the top of `file:src/evaluator/engine/mod.rs`, add `use log::debug;` alongside the existing `use` statements, or use the fully-qualified `log::debug!` macro path — either is acceptable; the fully-qualified form avoids an unused-import warning if the macro is conditionally compiled away.

---

### Resulting call-site shape (conceptual, not code)

| Location | What to log |
|---|---|
| Top-level rule skip (~line 200) | `"Skipping rule '{}' due to evaluation error: {}", rule.message, e` |
| Child rule skip (~line 252) | `"Skipping child rules of '{}' due to evaluation error: {}", rule.message, e` |

Both use `{}` (Display) for the error to comply with the `use_debug = "warn"` clippy lint.

---

### Sequence of changes

```mermaid
sequenceDiagram
    participant Cargo as Cargo.toml
    participant Engine as evaluator/engine/mod.rs

    Cargo->>Cargo: Add log = "0.4" to [dependencies]
    Engine->>Engine: Add use log::debug (or use fully-qualified path)
    Engine->>Engine: Bind error in top-level skip arm, emit log::debug!
    Engine->>Engine: Bind error in child skip arm, emit log::debug!
```

No other files need modification. The `log` crate emits nothing at runtime unless a subscriber is registered by the binary/test harness, satisfying the "no output at default log level" acceptance criterion.

---

Execution Information

Branch: main
Commit: 8be6924

New Plan

Observations

The codebase currently has no logging framework — neither tracing nor log is in Cargo.toml. The only diagnostic output is raw eprintln! calls guarded by #[allow(clippy::print_stderr)], with a comment in file:src/parser/loader.rs (line 180) explicitly noting "consider a logging framework in the future." The two skip points in file:src/evaluator/engine/mod.rs are at lines 199–201 (top-level rule skip) and lines 251–253 (child rule skip). The clippy config has use_debug = "warn", so {:?} formatting must be avoided in favour of {} (Display).

Approach

Add the log crate (the standard Rust logging facade) as a dependency — it is lighter-weight than tracing, has no proc-macro overhead, and is the idiomatic choice for a library crate. Then emit log::debug! calls at both skip points. Library consumers can plug in any log-compatible backend (e.g., env_logger) to see the output; at default log level nothing is emitted.

Implementation Steps

1. Add log to Cargo.toml

In file:Cargo.toml, under [dependencies], add:

log = "0.4"

No feature flags are needed. Do not add a backend (e.g., env_logger) — that is the consumer's responsibility for a library crate.

2. Add use log::debug; import to file:src/evaluator/engine/mod.rs

At the top of the file after the existing use statements (after line 16), add:

use log::debug;

This makes the debug! macro available throughout the module.

3. Add log::debug! at the top-level rule skip point

In file:src/evaluator/engine/mod.rs, modify the error handling match arm at lines 192–202. Currently it reads:

Err(
    LibmagicError::EvaluationError(
        crate::error::EvaluationError::BufferOverrun { .. }
        | crate::error::EvaluationError::InvalidOffset { .. }
        | crate::error::EvaluationError::TypeReadError(_),
    )
    | LibmagicError::IoError(_),
) => {
    // Expected evaluation errors for individual rules -- skip gracefully
    continue;
}

Change it to bind the error and emit a debug log:

Err(e @ (
    LibmagicError::EvaluationError(
        crate::error::EvaluationError::BufferOverrun { .. }
        | crate::error::EvaluationError::InvalidOffset { .. }
        | crate::error::EvaluationError::TypeReadError(_),
    )
    | LibmagicError::IoError(_),
)) => {
    // Expected evaluation errors for individual rules -- skip gracefully
    debug!("Skipping rule '{}' due to evaluation error: {}", rule.message, e);
    continue;
}

4. Add log::debug! at the child rule skip point

In file:src/evaluator/engine/mod.rs, modify the error handling match arm at lines 244–253. Currently it reads:

Err(
    LibmagicError::EvaluationError(
        crate::error::EvaluationError::BufferOverrun { .. }
        | crate::error::EvaluationError::InvalidOffset { .. }
        | crate::error::EvaluationError::TypeReadError(_),
    )
    | LibmagicError::IoError(_),
) => {
    // Expected child evaluation errors -- skip gracefully
}

Change it to bind the error and emit a debug log:

Err(e @ (
    LibmagicError::EvaluationError(
        crate::error::EvaluationError::BufferOverrun { .. }
        | crate::error::EvaluationError::InvalidOffset { .. }
        | crate::error::EvaluationError::TypeReadError(_),
    )
    | LibmagicError::IoError(_),
)) => {
    // Expected child evaluation errors -- skip gracefully
    debug!("Skipping child rules of '{}' due to evaluation error: {}", rule.message, e);
}

Summary

File	Change
file:Cargo.toml	Add log = "0.4" to [dependencies]
file:src/evaluator/engine/mod.rs	Add use log::debug; import
file:src/evaluator/engine/mod.rs	Bind error and emit debug! at top-level skip point (~line 200)
file:src/evaluator/engine/mod.rs	Bind error and emit debug! at child rule skip point (~line 252)

The log crate emits nothing at runtime unless a subscriber is registered by the binary/test harness, satisfying the "no output at default log level" acceptance criterion. Both log messages use {} (Display) for the error to comply with the use_debug = "warn" clippy lint.

Import In IDE

🤖 Prompt for AI Agents

# Observations

The codebase currently has **no logging framework** — neither `tracing` nor `log` is in `Cargo.toml`. The only diagnostic output is raw `eprintln!` calls guarded by `#[allow(clippy::print_stderr)]`, with a comment in `file:src/parser/loader.rs` (line 180) explicitly noting _"consider a logging framework in the future."_ The two skip points in `file:src/evaluator/engine/mod.rs` are at lines 199–201 (top-level rule skip) and lines 251–253 (child rule skip). The `clippy` config has `use_debug = "warn"`, so `{:?}` formatting must be avoided in favour of `{}` (Display).

# Approach

Add the `log` crate (the standard Rust logging facade) as a dependency — it is lighter-weight than `tracing`, has no proc-macro overhead, and is the idiomatic choice for a library crate. Then emit `log::debug!` calls at both skip points. Library consumers can plug in any `log`-compatible backend (e.g., `env_logger`) to see the output; at default log level nothing is emitted.

# Implementation Steps

## 1. Add `log` to `Cargo.toml`

In `file:Cargo.toml`, under `[dependencies]`, add:

```
log = "0.4"
```

No feature flags are needed. Do **not** add a backend (e.g., `env_logger`) — that is the consumer's responsibility for a library crate.

## 2. Add `use log::debug;` import to `file:src/evaluator/engine/mod.rs`

At the top of the file after the existing `use` statements (after line 16), add:

```rust
use log::debug;
```

This makes the `debug!` macro available throughout the module.

## 3. Add `log::debug!` at the top-level rule skip point

In `file:src/evaluator/engine/mod.rs`, modify the error handling match arm at lines 192–202. Currently it reads:

```rust
Err(
    LibmagicError::EvaluationError(
        crate::error::EvaluationError::BufferOverrun { .. }
        | crate::error::EvaluationError::InvalidOffset { .. }
        | crate::error::EvaluationError::TypeReadError(_),
    )
    | LibmagicError::IoError(_),
) => {
    // Expected evaluation errors for individual rules -- skip gracefully
    continue;
}
```

Change it to bind the error and emit a debug log:

```rust
Err(e @ (
    LibmagicError::EvaluationError(
        crate::error::EvaluationError::BufferOverrun { .. }
        | crate::error::EvaluationError::InvalidOffset { .. }
        | crate::error::EvaluationError::TypeReadError(_),
    )
    | LibmagicError::IoError(_),
)) => {
    // Expected evaluation errors for individual rules -- skip gracefully
    debug!("Skipping rule '{}' due to evaluation error: {}", rule.message, e);
    continue;
}
```

## 4. Add `log::debug!` at the child rule skip point

In `file:src/evaluator/engine/mod.rs`, modify the error handling match arm at lines 244–253. Currently it reads:

```rust
Err(
    LibmagicError::EvaluationError(
        crate::error::EvaluationError::BufferOverrun { .. }
        | crate::error::EvaluationError::InvalidOffset { .. }
        | crate::error::EvaluationError::TypeReadError(_),
    )
    | LibmagicError::IoError(_),
) => {
    // Expected child evaluation errors -- skip gracefully
}
```

Change it to bind the error and emit a debug log:

```rust
Err(e @ (
    LibmagicError::EvaluationError(
        crate::error::EvaluationError::BufferOverrun { .. }
        | crate::error::EvaluationError::InvalidOffset { .. }
        | crate::error::EvaluationError::TypeReadError(_),
    )
    | LibmagicError::IoError(_),
)) => {
    // Expected child evaluation errors -- skip gracefully
    debug!("Skipping child rules of '{}' due to evaluation error: {}", rule.message, e);
}
```

# Summary

| File | Change |
|---|---|
| `file:Cargo.toml` | Add `log = "0.4"` to `[dependencies]` |
| `file:src/evaluator/engine/mod.rs` | Add `use log::debug;` import |
| `file:src/evaluator/engine/mod.rs` | Bind error and emit `debug!` at top-level skip point (~line 200) |
| `file:src/evaluator/engine/mod.rs` | Bind error and emit `debug!` at child rule skip point (~line 252) |

The `log` crate emits nothing at runtime unless a subscriber is registered by the binary/test harness, satisfying the "no output at default log level" acceptance criterion. Both log messages use `{}` (Display) for the error to comply with the `use_debug = "warn"` clippy lint.

---

Execution Information

Branch: main
Commit: 8be6924