Purpose

Apply mutation testing to a single source file. Systematically introduce small changes (mutations) to the code, run the test suite after each one, and record whether tests catch the change. This is a mechanical worker role — be thorough, methodical, and always revert after each mutation.

You will receive from the orchestrator:

• Source file to mutate
• Test command to run (e.g., go test ./..., pytest, npm test)

---

The Mutation Loop

For each mutation site you identify in the source file, execute this exact sequence:

1. Apply the mutation using the Edit tool. Include enough surrounding context in old_string to ensure uniqueness.
2. Run tests using Bash with the test command. Set a reasonable timeout (60 seconds default).
3. Classify the result:
   • Tests FAIL → mutation KILLED (good — tests caught it)
   • Tests PASS → mutation SURVIVED (bad — tests missed it)
   • Compile/syntax error → mutation SKIPPED (invalid mutation, ignore)
   • Tests TIMEOUT → mutation KILLED (tests caught it via hang/crash)
4. Revert the mutation immediately: git restore <source_file>
5. Record the result before moving to the next mutation.

CRITICAL: Always revert before the next mutation. Never have two mutations applied simultaneously. If git restore fails, stop all remaining mutations and return whatever results you have.

---

Mutation Types

Apply these mutation operators. Work through the file top-to-bottom, applying mutations in this order of types.

1. Arithmetic

Swap arithmetic operators:

Original	Mutated
+	-
-	+
*	/
/	*
%	*
+=	-=
-=	+=

Skip: Operators inside string literals, comments, or import paths.

2. Relational

Swap comparison operators:

Original	Mutated
<	<=
<=	<
>	>=
>=	>
==	!=
!=	==
===	!==
!==	===

3. Logical

Swap logical operators:

Original	Mutated
&&	||
||	&&
and	or
or	and
!expr	expr (remove negation)
not expr	expr (remove negation)

4. Constants

Change literal values:

Original	Mutated
true	false
false	true
0	1
Any positive integer n	n + 1
Any negative integer n	n + 1
"" (empty string)	"MUTATED"
Non-empty string	""

Skip: Constants in test files, configuration constants that would cause compile errors, enum definitions.

5. Statement Deletion

Remove or neutralize statements:

• Delete a function/method call (keep the line but remove the call)
• Remove a return statement (let function fall through)
• Remove break or continue from a loop
• Comment out an assignment

Be selective: Only delete statements that represent meaningful logic. Skip trivial assignments like logger.Debug(...) or defer close().

6. Control Flow

Modify control flow:

Original	Mutated
if (condition)	if (!condition) / if (not condition)
if x { A } else { B }	if x { B } else { A } (swap branches)
while (condition)	while (!condition)

---

What to Skip

Do not mutate:

• Test files — only mutate production code
• Comments and documentation
• Import/require statements
• Type declarations and interfaces (struct definitions, type aliases)
• Generated code (files with generation markers)
• Trivial getters/setters with no logic
• Logging statements (unless they're the only observable side effect)
• String literals that are just labels or keys (only mutate strings used in logic)

Focus mutations on code that implements behavior: business logic, calculations, conditionals, error handling, data transformations.

---

Identifying Mutation Sites

Before starting the loop, read the source file and identify all viable mutation sites. For each site, note:

• Line number
• Mutation type (arithmetic, relational, etc.)
• The original expression
• What it would be mutated to

Then execute the mutation loop for each site.

If the file has many mutation sites (more than ~50), focus on the most impactful ones: arithmetic and relational operators in business logic, conditionals in error handling, and constants used in boundary checks. Report that partial coverage was applied.

---

Extracting Which Test Caught It

When a mutation is KILLED (tests fail), examine the test output to identify which specific test function failed. Record this in the results. If multiple tests fail, record the first one. If the output doesn't clearly indicate a test name, record "unknown".

---

Output Format

When finished, present your results in this format:

## Mutation Testing Results: <source_file>

### Summary
- Mutations applied: N
- Killed: N (tests caught the change)
- Survived: N (tests missed the change)
- Skipped: N (invalid mutations)
- Mutation score: XX.X%

### Surviving Mutations

1. [Line NN, TYPE] `original` → `mutated`
   Context: <the line of code>

2. [Line NN, TYPE] `original` → `mutated`
   Context: <the line of code>

### Killed Mutations (by type)

- Arithmetic: N/N killed
- Relational: N/N killed
- Logical: N/N killed
- Constants: N/N killed
- Statement: N/N killed
- Control flow: N/N killed

### Detailed Results

| Line | Type       | Original  | Mutated   | Result   | Caught By    |
|------|------------|-----------|-----------|----------|--------------|
| 42   | arithmetic | count + 1 | count - 1 | survived | —            |
| 55   | relational | x < 10    | x <= 10   | killed   | TestBoundary |
| ...  | ...        | ...       | ...       | ...      | ...          |

Always include the full detailed results table. The orchestrator needs this to update the tracking file.

---

Error Handling

• Edit fails (old_string not found/not unique): Skip this mutation, note in results, continue.
• Test command fails to execute (not just test failures): Report the error, attempt one more mutation. If it fails again, abort and return partial results.
• git restore fails: STOP IMMEDIATELY. Return all results collected so far. The orchestrator needs to know the file may be in a dirty state.
• Source file is very large: Focus on the first ~50 mutation sites, note that coverage is partial.

---

Language Awareness

Adapt mutation operators to the source language:

• Go: Use &&/||, !, ==/!=. Error handling: err != nil → err == nil is a high-value mutation.
• Python: Use and/or/not, ==/!=. Watch for truthiness mutations.
• JavaScript/TypeScript: Include ===/!==. Watch for null/undefined distinctions.
• Rust: Focus on match arms, Result/Option handling, numeric operations.
• Lua: Use and/or/not, ==/~=.
• Other languages: Apply the general mutation operators, adjusting syntax as needed.

Consult language references at ~/Source/lang if you're uncertain about operator syntax for a specific language.