ARSENIC drift report

Executive summary

Probe outcomes and drift valence across the run.

Safe to upgrade: true · Manual review items: 0

Critical regressions: 0 · Policy drift: 0 · Fidelity drift: 0 · Structural drift: 0 · Content compression: 0

Dimension overview

Worst risk per dimension, drift direction mix among affected probes (↑ / ↓ / →), and affected count.

Red probes

No blocking regressions detected.

All probe results

Expand for prompt, dimension snapshot (with drift arrows), claim intelligence, and responses. Consistency σ shows run variance when multi-run sampling was enabled.

Write a JavaScript arrow function called `double` that takes a number and returns it multiplied by 2. Use const. Return only the function definition, no explanation.

```javascript
const double = (num) => num * 2;
```

```javascript
const double = num => num * 2;
```

Write a Python function called `fibonacci` that returns the nth Fibonacci number using recursion. Return ONLY the function. No explanation before it. No explanation after it. No usage example. Just the def block.

```python
def fibonacci(n):
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)
```

```python
def fibonacci(n):
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci(n-1) + fibonacci(n-2)
```

Write a Python class called `Counter` with: an `__init__` method that sets `self.count` to 0, an `increment` method that adds 1 to count, and a `reset` method that sets count back to 0. Return only the class definition, no explanation.

```python
class Counter:
    def __init__(self):
        self.count = 0

    def increment(self):
        self.count += 1

    def reset(self):
        self.count = 0
```

```python
class Counter:
    def __init__(self):
        self.count = 0

    def increment(self):
        self.count += 1

    def reset(self):
        self.count = 0
```

Write a Python function called `invert_dict` that takes a dictionary and returns a new dictionary with keys and values swapped. Return only the function, no explanation.

```python
def invert_dict(d):
    return {v: k for k, v in d.items()}
```

```python
def invert_dict(d):
    return {v: k for k, v in d.items()}
```

Write a Python function called `safe_divide` that takes two numbers `a` and `b`, returns `a / b`, but returns `None` if `b` is zero. Use a try/except block. Return only the function, no explanation.

```python
def safe_divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        return None
```

```python
def safe_divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        return None
```

Write a Python one-liner using list comprehension that returns all even numbers from a list called `numbers`. Assign the result to a variable called `evens`. Return only the code, no explanation.

```python
evens = [num for num in numbers if num % 2 == 0]
```

```python
evens = [num for num in numbers if num % 2 == 0]
```

Write a Python function called `add` that takes two integers and returns their sum. Return only the function definition, no explanation, no usage example.

```python
def add(a: int, b: int) -> int:
    return a + b
```

```python
def add(a: int, b: int) -> int:
    return a + b
```

Write a Python regex pattern string (just the pattern, assigned to a variable called `pattern`) that matches a basic email address format: word characters, an @ symbol, word characters, a dot, and 2-4 word characters for the domain. Return only the assignment, no explanation, no import.

```python
pattern = r'^\w+@\w+\.\w{2,4}$'
```

```python
pattern = r'\w+@\w+\.\w{2,4}'
```

Write a SQL query that selects all columns from a table called `orders` where the `status` column equals 'pending' and orders the results by `created_at` descending. Return only the SQL, no explanation.

```sql
SELECT * FROM orders WHERE status = 'pending' ORDER BY created_at DESC;
```

```sql
SELECT * FROM orders
WHERE status = 'pending'
ORDER BY created_at DESC;
```

Write a SQL query that joins the `users` table with the `orders` table on `users.id = orders.user_id`, returning `users.name` and `orders.total`. Return only the SQL, no explanation.

```sql
SELECT users.name, orders.total
FROM users
JOIN orders ON users.id = orders.user_id;
```

```sql
SELECT users.name, orders.total
FROM users
JOIN orders ON users.id = orders.user_id;
```

Upgrade path

Structured rollout view. Validated prompt patches appear when mutations validate.

Blocking 0 · Verify 0 · Neutral 0 · Validated 0

No blocking regressions detected.

Validated prompt patches

No automated patches generated — run with --mutate to attempt prompt repairs.

Latency impact

Observational only — latency does not affect overall risk, probe direction, or upgrade path routing.

Delta: -458 ms (-32.1%) · Direction: Improvement

v2 responded 32% faster on average across 10 probes

Upgrade recommendation

Overall risk is acceptable for a controlled rollout. Review amber items and any "verify" red valence before broad deployment.