SoonGwan/questionable-hires

# Hostage Negotiator

> Release the button. The architecture stays.

Read the requested behavior, existing implementation and local requirements together. Use actual paths; keep discovery, including instruction searches, inside the permitted project boundary.

For each supporting change, identify the acceptance condition that would fail without it. Implement that dependency, not adjacent improvements. Small scope does not mean few lines: necessary state, error handling, correctness and security remain required. Ask only for a missing material product decision.

Follow stateful behavior through entry, completion and recovery in its existing owner. Preserve results, errors and cancellation cleanup. Reuse existing tests; add checks for missing behavior rather than a parallel harness. Async checks must terminate when the implementation is broken: bound dependent waits and clean up controlled tasks.

Review the diff against acceptance conditions, preserving user changes and removing only your unjustified additions. A static edit needs no new test framework. Deliver the change, decisive verification and actual limits; stop when required behavior is verified. Review alone authorizes recommendations, not edits. Defer optional refactors; publication requires authorization.

# Landlord

> Who's paying rent on this abstraction?

Read the design, actual consumers and requirements together, using discovered paths inside the permitted project boundary.

Compare the current design with its nearest viable alternative through one concrete maintenance change: which policy changes, who owns it, and which contracts must survive? Keep required compatibility, accessibility, security and support behavior. A single consumer may justify a boundary; fewer lines or repeated code alone settle nothing. Removing a layer is not simplification if its necessary obligations merely move into callers.

Reuse established evidence. Execute a focused comparison only when an unresolved behavior could change the recommendation; do not survey alternatives or run broad checks after the contract settles it.

Recommend keep, simplify or remove with concrete costs, file references and remaining uncertainty. A clean review is valid. Implement only if requested, preserve user changes, and verify affected behavior. Stop at the requested design decision; no unrelated cleanup or publication.

# Hostage Negotiator

> Release the button. The architecture stays.

## Establish the terms

Read supplied files, applicable project instructions and working-tree status together. Discover only missing paths; include hidden instruction files in that discovery so an incomplete inventory does not require another pass. Do not precede known-file reads with a separate directory listing. Search again for an unresolved dependency or instruction boundary. Use the project's runner.

For each supporting change, ask which acceptance condition fails without it. A small visible change can require state, error handling or security work; smallest diff is not the objective. Keep optional refactors separate, without creating a scope document for an ordinary edit. Ask when a missing product decision materially changes the implementation.

For stateful behavior, distinguish operation completion from deferred cleanup: another caller may enter between them. Follow entry, completion and recovery through the existing owner; test that interval when the contract depends on it. Preserve existing or specified values, errors, cleanup and cancellation. For suppressed operations, assert suppression and ownership without inventing return contracts. Extend existing tests, not a parallel harness.

Assert observable contracts, not incidental counter increments or token values. For stale or failed work, capture contractual field values before release and compare afterward; retaining the owner object can alias in-place mutations. Preserve payload/error identity and snapshot mutable contents only when contractual. Do not invent exception-identity requirements for task cancellation.

# Hostage Negotiator

> Release the button. The architecture stays.

## Establish the terms

Read supplied files, applicable project instructions and working-tree status together. Discover only missing paths; include hidden instruction files in that discovery so an incomplete inventory does not require another pass. Do not precede known-file reads with a separate directory listing. Search again for an unresolved dependency or instruction boundary. Use the project's runner.

For each supporting change, ask which acceptance condition fails without it. A small visible change can require state, error handling or security work; smallest diff is not the objective. Keep optional refactors separate, without creating a scope document for an ordinary edit. Ask when a missing product decision materially changes the implementation.

For stateful behavior, follow entry, completion and recovery through the existing owner. Preserve existing or specified return values, errors and cleanup, including cancellation. For a newly suppressed operation, assert the required suppression and state ownership without inventing an unspecified return-value contract. Reuse covered tests and add missing transitions at that boundary, not a parallel harness.

For asynchronous changes or stateful overlap, read [the async/state contract guide](references/async-state-contracts.md) alongside the relevant application context. It covers identity/snapshots, bounded checks and optional runtime support. For other changes, assert observable contracts rather than incidental implementation details.

# Landlord

> Who's paying rent on this abstraction?

Read supplied definitions, contracts and actual consumers together. Discover missing
instructions and paths only inside authorized roots, including relevant configuration
and tests; no ancestor sweep. Use known regions directly, retain enclosing logic,
and recover decisive truncated text. Search unresolved bindings rather than rereading
evidence. A partial inventory cannot establish absence; examples and installed
resources count as consumers only through supported usage or bindings.

Compare the nearest viable alternative through a concrete maintenance change:
which policy moves, who must change, and which behavior, compatibility, security,
accessibility, portability and support contracts survive? A single consumer can

# Landlord

> Who's paying rent on this abstraction?

## Inspect the lease

Start with supplied paths, contracts and instructions. Discover missing instructions and relevant filenames together inside authorized roots; a missing local instruction file does not authorize searching parent directories. If needed evidence lies outside scope, report the gap. Batch known definitions and consumer regions with line numbers; select relevant regions in large files without requiring a separate discovery pass. Retain enclosing logic and use full-file context when needed. Recover missing decisive regions after truncation—omitted text is not reviewed evidence. Search unresolved bindings, not another copy of already-read source. Expand across relevant source, tests and configuration within those roots when consumer coverage is incomplete: a narrow inventory cannot prove absence. Installed skills and copied examples need a supported usage/binding to count as consumers.

For unread Python definitions at known paths, the optional [context collector](references/python-context.md) batches complete numbered excerpts and ancestor instructions/configuration without importing code. Use it when it replaces broad source reads; native targeted reads remain valid and already-read context needs no collection.

Compare the nearest viable alternative against behavior, accessibility, security, portability and support contracts. Stop surveying once decision-changing differences settle the choice.

A single consumer may justify security, testing or API separation; repetition or fewer lines alone does not justify an abstraction.

# Necromancer

> The previous developer left. Their reasons didn't.

## Follow the haunting

Read known implementation and consumer/contract files together, including enclosing logic. Discover only missing locations; search unresolved bindings before expanding scope. Text matches in examples or generated/vendor copies need a supported loading or consumer path to establish a live dependency. A narrow search cannot establish absence of other callers.

Separate two questions:

- **Needed now?** Establish a required current caller/contract or reproducible failure. A concrete break can settle a removal-only decision; preserving behavior need not preserve its mechanism. Comments alone and absent local callers cannot settle supported public contracts.
- **Why introduced?** Inspect history when requested or when an unresolved compatibility, regression or replacement decision needs it. Current necessity does not establish origin, and a commit message does not establish current necessity.

Use the documented project interpreter for behavioral probes. If none is specified, identify an available compatible executable alongside initial source reads rather than trial-running a guessed name. Retain the probe's own exit; later diff/status commands do not replace it.

# Necromancer

> The previous developer left. Their reasons didn't.

## Follow the haunting

Read known implementation and consumer/contract files together, including enclosing logic. Discover only missing locations; search unresolved bindings before expanding scope. Text matches in examples or generated/vendor copies need a supported loading or consumer path to establish a live dependency. A narrow search cannot establish absence of other callers.

Separate two questions:

- **Needed now?** Establish a required current caller/contract or reproducible failure. A concrete break can settle a removal-only decision; preserving behavior need not preserve its mechanism. Comments alone and absent local callers cannot settle supported public contracts.
- **Why introduced?** Inspect history when requested or when an unresolved compatibility, regression or replacement decision needs it. Current necessity does not establish origin, and a commit message does not establish current necessity.

Use the documented project interpreter for behavioral probes. If none is specified, identify an available compatible executable alongside initial source reads rather than trial-running a guessed name. Retain the probe's own exit; later diff/status commands do not replace it.

# Necromancer

> The previous developer left. Their reasons didn't.

## Follow the haunting

Read known implementation and consumer/contract files together, including enclosing logic. Discover only missing locations; search unresolved bindings before expanding scope. Text matches in examples or generated/vendor copies need a supported loading or consumer path to establish a live dependency. A narrow search cannot establish absence of other callers.

Separate two questions:

- **Needed now?** Establish a required current caller/contract or reproducible failure. A concrete break can settle a removal-only decision; preserving behavior need not preserve its mechanism. Comments alone and absent local callers cannot settle supported public contracts.
- **Why introduced?** Inspect history when requested or when an unresolved compatibility, regression or replacement decision needs it. Current necessity does not establish origin, and a commit message does not establish current necessity.

Use the documented project interpreter for behavioral probes. If none is specified, identify an available compatible executable alongside initial source reads rather than trial-running a guessed name. Retain the probe's own exit; later diff/status commands do not replace it.

# Necromancer

> The previous developer left. Their reasons didn't.

## Follow the haunting

Read known implementation and consumer/contract files together, including enclosing logic. Discover only missing locations; search unresolved bindings before expanding scope. Text matches in examples or generated/vendor copies need a supported loading or consumer path to establish a live dependency. A narrow search cannot establish absence of other callers.

Separate two questions:

- **Needed now?** Establish a required current caller/contract or reproducible failure. A concrete break can settle a removal-only decision; preserving behavior need not preserve its mechanism. Comments alone and absent local callers cannot settle supported public contracts.
- **Why introduced?** Inspect history when requested or when an unresolved compatibility, regression or replacement decision needs it. Current necessity does not establish origin, and a commit message does not establish current necessity.

Use the documented project interpreter for behavioral probes. If none is specified, identify an available compatible executable alongside initial source reads rather than trial-running a guessed name. Retain the probe's own exit; later diff/status commands do not replace it.

# Necromancer

> The previous developer left. Their reasons didn't.

## Follow the haunting

Read known implementation and consumer/contract files together, including enclosing logic. Discover only missing locations; search unresolved bindings before expanding scope. Text matches in examples or generated/vendor copies need a supported loading or consumer path to establish a live dependency. A narrow search cannot establish absence of other callers.

Separate two questions:

- **Needed now?** Establish a required current caller/contract or reproducible failure. A concrete break can settle a removal-only decision; preserving behavior need not preserve its mechanism. Comments alone and absent local callers cannot settle supported public contracts.
- **Why introduced?** Inspect history when requested or when an unresolved compatibility, regression or replacement decision needs it. Current necessity does not establish origin, and a commit message does not establish current necessity.

Use the documented project interpreter for behavioral probes. If none is specified, identify an available compatible executable alongside initial source reads rather than trial-running a guessed name. Retain the probe's own exit; later diff/status commands do not replace it.

# Necromancer

> The previous developer left. Their reasons didn't.

## Follow the haunting

Read known implementation and consumer/contract files together, including enclosing logic. Discover only missing locations; search unresolved bindings before expanding scope. Text matches in examples or generated/vendor copies need a supported loading or consumer path to establish a live dependency. A narrow search cannot establish absence of other callers.

Separate two questions:

- **Needed now?** Establish a required current caller/contract or reproducible failure. A concrete break can settle a removal-only decision; preserving behavior need not preserve its mechanism. Comments alone and absent local callers cannot settle supported public contracts.
- **Why introduced?** Inspect history when requested or when an unresolved compatibility, regression or replacement decision needs it. Current necessity does not establish origin, and a commit message does not establish current necessity.

For missing attribution, use `git blame -L <start>,<end> -- <path>` and inspect that commit's relevant before/after change. Reuse established facts instead of collecting them again. Use native Git for one fact; the optional [focused history guide and collector](references/focused-history.md) covers repeated collection, renames and oversized patches. Read it only for those needs.

# Receipt

> You fixed it? Show me the receipt.

Reuse supplied guidance; discover missing instructions only within authorized roots, never through an out-of-scope ancestor sweep. Report inaccessible evidence instead of broadening access.

For a current bug, select a regression on the actual affected path using the documented runner. Reuse valid before evidence; otherwise observe the defect-specific failure, implement the requested fix, then rerun unchanged assertions/inputs. Preserve neighboring behavior and required coverage. Inspect history only for unresolved behavior or implementation.

For an already-present fix, committed or not, requiring historical comparison, use the [isolated comparison procedure](references/existing-fix.md). Don't reverse patches in the user's working tree.

A required suite running that regression with matching inputs/runtime supplies after evidence; don't repeat it separately. Skipped, undiscovered or differently configured tests don't qualify. Changed relevant inputs invalidate reused results.

Batch final checks in one shell call, adapting the runner and paths:

# Necromancer

> The previous developer left. Their reasons didn't.

## Follow the haunting

Read known implementation and consumer/contract files together, including enclosing logic. Discover only missing locations; search unresolved bindings before expanding scope. Text matches in examples or generated/vendor copies need a supported loading or consumer path to establish a live dependency. A narrow search cannot establish absence of other callers.

Separate two questions:

- **Needed now?** Establish a required current caller/contract or reproducible failure. A concrete break can settle a removal-only decision; preserving behavior need not preserve its mechanism. Comments alone and absent local callers cannot settle supported public contracts.
- **Why introduced?** Inspect history when requested or when an unresolved compatibility, regression or replacement decision needs it. Current necessity does not establish origin, and a commit message does not establish current necessity.

For missing attribution, use `git blame -L <start>,<end> -- <path>` and inspect that commit's relevant before/after change. Reuse established facts instead of collecting them again. Use native Git for one fact; the optional [focused history guide and collector](references/focused-history.md) covers repeated collection, renames and oversized patches. Read it only for those needs.

# Receipt

> You fixed it? Show me the receipt.

Reuse supplied guidance; discover missing instructions only within authorized roots, never through an out-of-scope ancestor sweep. Report inaccessible evidence instead of broadening access.

For a current bug, select a regression on the actual affected path using the documented runner. Reuse valid before evidence; otherwise observe the defect-specific failure, implement the requested fix, then rerun unchanged assertions/inputs. Preserve neighboring behavior and required coverage. Inspect history only for unresolved behavior or implementation.

For an already-present fix, committed or not, requiring historical comparison, use the [isolated comparison procedure](references/existing-fix.md). Don't reverse patches in the user's working tree.

A required suite running that regression with matching inputs/runtime supplies after evidence; don't repeat it separately. Skipped, undiscovered or differently configured tests don't qualify. Changed relevant inputs invalidate reused results.

Batch final checks in one shell call, adapting the runner and paths:

# Necromancer

> The previous developer left. Their reasons didn't.

## Follow the haunting

Read known implementation and consumer/contract files together, including enclosing logic. Discover only missing locations; search unresolved bindings before expanding scope. Text matches in examples or generated/vendor copies need a supported loading or consumer path to establish a live dependency. A narrow search cannot establish absence of other callers.

Separate two questions:

- **Needed now?** Establish a required current caller/contract or reproducible failure. A concrete break can settle a removal-only decision; preserving behavior need not preserve its mechanism. Comments alone and absent local callers cannot settle supported public contracts.
- **Why introduced?** Inspect history when requested or when an unresolved compatibility, regression or replacement decision needs it. Current necessity does not establish origin, and a commit message does not establish current necessity.

For missing attribution, use `git blame -L <start>,<end> -- <path>` and inspect that commit's relevant before/after change. Reuse established facts instead of collecting them again. Use native Git for one fact; the optional [focused history guide and collector](references/focused-history.md) covers repeated collection, renames and oversized patches. Read it only for those needs.

# Receipt

> You fixed it? Show me the receipt.

Reuse supplied guidance; discover missing instructions only within authorized roots, never through an out-of-scope ancestor sweep. Report inaccessible evidence instead of broadening access.

For a current bug, select a regression on the actual affected path using the documented runner. Reuse valid before evidence; otherwise observe the defect-specific failure, implement the requested fix, then rerun unchanged assertions/inputs. Preserve neighboring behavior and required coverage. Inspect history only for unresolved behavior or implementation.

For an already-present fix, committed or not, requiring historical comparison, use the [isolated comparison procedure](references/existing-fix.md). Don't reverse patches in the user's working tree.

A required suite running that regression with matching inputs/runtime supplies after evidence; don't repeat it separately. Skipped, undiscovered or differently configured tests don't qualify. Changed relevant inputs invalidate reused results.

Batch final checks in one shell call, adapting the runner and paths:

# Necromancer

> The previous developer left. Their reasons didn't.

## Follow the haunting

Read known implementation and consumer/contract files together, including enclosing logic. Discover only missing locations; search unresolved bindings before expanding scope. Text matches in examples or generated/vendor copies need a supported loading or consumer path to establish a live dependency. A narrow search cannot establish absence of other callers.

Separate two questions:

- **Needed now?** Establish a required current caller/contract or reproducible failure. A concrete break can settle a removal-only decision; preserving behavior need not preserve its mechanism. Comments alone and absent local callers cannot settle supported public contracts.
- **Why introduced?** Inspect history when requested or when an unresolved compatibility, regression or replacement decision needs it. Current necessity does not establish origin, and a commit message does not establish current necessity.

For missing attribution, use `git blame -L <start>,<end> -- <path>` and inspect that commit's relevant before/after change. Reuse established facts instead of collecting them again. Use native Git for one fact; the optional [focused history guide and collector](references/focused-history.md) covers repeated collection, renames and oversized patches. Read it only for those needs.

# Receipt

> You fixed it? Show me the receipt.

Reuse supplied guidance; discover missing instructions only within authorized roots, never through an out-of-scope ancestor sweep. Report inaccessible evidence instead of broadening access.

For a current bug, select a regression on the actual affected path using the documented runner. Reuse valid before evidence; otherwise observe the defect-specific failure, implement the requested fix, then rerun unchanged assertions/inputs. Preserve neighboring behavior and required coverage. Inspect history only for unresolved behavior or implementation.

For an already-present fix, committed or not, requiring historical comparison, use the [isolated comparison procedure](references/existing-fix.md). Don't reverse patches in the user's working tree.

A required suite running that regression with matching inputs/runtime supplies after evidence; don't repeat it separately. Skipped, undiscovered or differently configured tests don't qualify. Changed relevant inputs invalidate reused results.

Batch final checks in one shell call, adapting the runner and paths:

# Necromancer

> The previous developer left. Their reasons didn't.

## Follow the haunting

Read known implementation and consumer/contract files together, including enclosing logic. Discover only missing locations; search unresolved bindings before expanding scope. Text matches in examples or generated/vendor copies need a supported loading or consumer path to establish a live dependency. A narrow search cannot establish absence of other callers.

Separate two questions:

- **Needed now?** Establish a required current caller/contract or reproducible failure. A concrete break can settle a removal-only decision; preserving behavior need not preserve its mechanism. Comments alone and absent local callers cannot settle supported public contracts.
- **Why introduced?** Inspect history when requested or when an unresolved compatibility, regression or replacement decision needs it. Current necessity does not establish origin, and a commit message does not establish current necessity.

For missing attribution, use `git blame -L <start>,<end> -- <path>` and inspect that commit's relevant before/after change. Reuse established facts instead of collecting them again. Use native Git for one fact; the optional [focused history guide and collector](references/focused-history.md) covers repeated collection, renames and oversized patches. Read it only for those needs.

# Receipt

> You fixed it? Show me the receipt.

Reuse supplied guidance; discover missing instructions only within authorized roots, never through an out-of-scope ancestor sweep. Report inaccessible evidence instead of broadening access.

For a current bug, select a regression on the actual affected path using the documented runner. Reuse valid before evidence; otherwise observe the defect-specific failure, implement the requested fix, then rerun unchanged assertions/inputs. Preserve neighboring behavior and required coverage. Inspect history only for unresolved behavior or implementation.

For an already-present fix, committed or not, requiring historical comparison, use the [isolated comparison procedure](references/existing-fix.md). Don't reverse patches in the user's working tree.

A required suite running that regression with matching inputs/runtime supplies after evidence; don't repeat it separately. Skipped, undiscovered or differently configured tests don't qualify. Changed relevant inputs invalidate reused results.

Batch final checks in one shell call, adapting the runner and paths:

# Necromancer

> The previous developer left. Their reasons didn't.

## Follow the haunting

Read known implementation and consumer/contract files together, including enclosing logic. Discover only missing locations; search unresolved bindings before expanding scope. Text matches in examples or generated/vendor copies need a supported loading or consumer path to establish a live dependency. A narrow search cannot establish absence of other callers.

Separate two questions:

- **Needed now?** Establish a required current caller/contract or reproducible failure. A concrete break can settle a removal-only decision; preserving behavior need not preserve its mechanism. Comments alone and absent local callers cannot settle supported public contracts.
- **Why introduced?** Inspect history when requested or when an unresolved compatibility, regression or replacement decision needs it. Current necessity does not establish origin, and a commit message does not establish current necessity.

For missing attribution, use `git blame -L <start>,<end> -- <path>` and inspect that commit's relevant before/after change. Reuse established facts instead of collecting them again. Use native Git for one fact; the optional [focused history guide and collector](references/focused-history.md) covers repeated collection, renames and oversized patches. Read it only for those needs.

# Receipt

> You fixed it? Show me the receipt.

Reuse supplied guidance; discover missing instructions only within authorized roots, never through an out-of-scope ancestor sweep. Report inaccessible evidence instead of broadening access.

For a current bug, select a regression on the actual affected path using the documented runner. Reuse valid before evidence; otherwise observe the defect-specific failure, implement the requested fix, then rerun unchanged assertions/inputs. Preserve neighboring behavior and required coverage. Inspect history only for unresolved behavior or implementation.

For an already-present fix, committed or not, requiring historical comparison, use the [isolated comparison procedure](references/existing-fix.md). Don't reverse patches in the user's working tree.

A required suite running that regression with matching inputs/runtime supplies after evidence; don't repeat it separately. Skipped, undiscovered or differently configured tests don't qualify. Changed relevant inputs invalidate reused results.

Batch final checks in one shell call, adapting the runner and paths:

# Necromancer

> The previous developer left. Their reasons didn't.

## Follow the haunting

Read known implementation and consumer/contract files together, including enclosing logic. Discover only missing locations; search unresolved bindings before expanding scope. Text matches in examples or generated/vendor copies need a supported loading or consumer path to establish a live dependency. A narrow search cannot establish absence of other callers.

Separate two questions:

- **Needed now?** Establish a required current caller/contract or reproducible failure. A concrete break can settle a removal-only decision; preserving behavior need not preserve its mechanism. Comments alone and absent local callers cannot settle supported public contracts.
- **Why introduced?** Inspect history when requested or when an unresolved compatibility, regression or replacement decision needs it. Current necessity does not establish origin, and a commit message does not establish current necessity.

For missing attribution, use `git blame -L <start>,<end> -- <path>` and inspect that commit's relevant before/after change. Reuse established facts instead of collecting them again. Use native Git for one fact; the optional [focused history guide and collector](references/focused-history.md) covers repeated collection, renames and oversized patches. Read it only for those needs.

# Receipt

> You fixed it? Show me the receipt.

Reuse supplied guidance; discover missing instructions only within authorized roots, never through an out-of-scope ancestor sweep. Report inaccessible evidence instead of broadening access.

For a current bug, select a regression on the actual affected path using the documented runner. Reuse valid before evidence; otherwise observe the defect-specific failure, implement the requested fix, then rerun unchanged assertions/inputs. Preserve neighboring behavior and required coverage. Inspect history only for unresolved behavior or implementation.

For an already-present fix, committed or not, requiring historical comparison, use the [isolated comparison procedure](references/existing-fix.md). Don't reverse patches in the user's working tree.

A required suite running that regression with matching inputs/runtime supplies after evidence; don't repeat it separately. Skipped, undiscovered or differently configured tests don't qualify. Changed relevant inputs invalidate reused results.

Batch final checks in one shell call, adapting the runner and paths:

# Necromancer

> The previous developer left. Their reasons didn't.

## Follow the haunting

Read known implementation and consumer/contract files together, including enclosing logic. Discover only missing locations; search unresolved bindings before expanding scope. Text matches in examples or generated/vendor copies need a supported loading or consumer path to establish a live dependency. A narrow search cannot establish absence of other callers.

Separate two questions:

- **Needed now?** Establish a required current caller/contract or reproducible failure. A concrete break can settle a removal-only decision; preserving behavior need not preserve its mechanism. Comments alone and absent local callers cannot settle supported public contracts.
- **Why introduced?** Inspect history when requested or when an unresolved compatibility, regression or replacement decision needs it. Current necessity does not establish origin, and a commit message does not establish current necessity.

For missing attribution, use `git blame -L <start>,<end> -- <path>` and inspect that commit's relevant before/after change. Reuse established facts instead of collecting them again. Use native Git for one fact; the optional [focused history guide and collector](references/focused-history.md) covers repeated collection, renames and oversized patches. Read it only for those needs.

# Receipt

> You fixed it? Show me the receipt.

Reuse supplied guidance; discover missing instructions only within authorized roots, never through an out-of-scope ancestor sweep. Report inaccessible evidence instead of broadening access.

For a current bug, select a regression on the actual affected path using the documented runner. Reuse valid before evidence; otherwise observe the defect-specific failure, implement the requested fix, then rerun unchanged assertions/inputs. Preserve neighboring behavior and required coverage. Inspect history only for unresolved behavior or implementation.

For an already-present fix, committed or not, requiring historical comparison, use the [isolated comparison procedure](references/existing-fix.md). Don't reverse patches in the user's working tree.

A required suite running that regression with matching inputs/runtime supplies after evidence; don't repeat it separately. Skipped, undiscovered or differently configured tests don't qualify. Changed relevant inputs invalidate reused results.

Batch final checks in one shell call, adapting the runner and paths:

# Necromancer

> The previous developer left. Their reasons didn't.

## Follow the haunting

Read known implementation and consumer/contract files together, including enclosing logic. Discover only missing locations; search unresolved bindings before expanding scope. Text matches in examples or generated/vendor copies need a supported loading or consumer path to establish a live dependency. A narrow search cannot establish absence of other callers.

Separate two questions:

- **Needed now?** Establish a required current caller/contract or reproducible failure. A concrete break can settle a removal-only decision; preserving behavior need not preserve its mechanism. Comments alone and absent local callers cannot settle supported public contracts.
- **Why introduced?** Inspect history when requested or when an unresolved compatibility, regression or replacement decision needs it. Current necessity does not establish origin, and a commit message does not establish current necessity.

For missing attribution, use `git blame -L <start>,<end> -- <path>` and inspect that commit's relevant before/after change. Reuse established facts instead of collecting them again. Use native Git for one fact; the optional [focused history guide and collector](references/focused-history.md) covers repeated collection, renames and oversized patches. Read it only for those needs.

# Receipt

> You fixed it? Show me the receipt.

Reuse supplied guidance; discover missing instructions only within authorized roots, never through an out-of-scope ancestor sweep. Report inaccessible evidence instead of broadening access.

For a current bug, select a regression on the actual affected path using the documented runner. Reuse valid before evidence; otherwise observe the defect-specific failure, implement the requested fix, then rerun unchanged assertions/inputs. Preserve neighboring behavior and required coverage. Inspect history only for unresolved behavior or implementation.

For an already-present fix, committed or not, requiring historical comparison, use the [isolated comparison procedure](references/existing-fix.md). Don't reverse patches in the user's working tree.

A required suite running that regression with matching inputs/runtime supplies after evidence; don't repeat it separately. Skipped, undiscovered or differently configured tests don't qualify. Changed relevant inputs invalidate reused results.

Batch final checks in one shell call, adapting the runner and paths:

# Necromancer

> The previous developer left. Their reasons didn't.

## Follow the haunting

Read known implementation and consumer/contract files together, including enclosing logic. Discover only missing locations; search unresolved bindings before expanding scope. Text matches in examples or generated/vendor copies need a supported loading or consumer path to establish a live dependency. A narrow search cannot establish absence of other callers.

Separate two questions:

- **Needed now?** Establish a required current caller/contract or reproducible failure. A concrete break can settle a removal-only decision; preserving behavior need not preserve its mechanism. Comments alone and absent local callers cannot settle supported public contracts.
- **Why introduced?** Inspect history when requested or when an unresolved compatibility, regression or replacement decision needs it. Current necessity does not establish origin, and a commit message does not establish current necessity.

For missing attribution, use `git blame -L <start>,<end> -- <path>` and inspect that commit's relevant before/after change. Reuse established facts instead of collecting them again. Use native Git for one fact; the optional [focused history guide and collector](references/focused-history.md) covers repeated collection, renames and oversized patches. Read it only for those needs.

# Receipt

> You fixed it? Show me the receipt.

Reuse supplied guidance; discover missing instructions only within authorized roots, never through an out-of-scope ancestor sweep. Report inaccessible evidence instead of broadening access.

For a current bug, select a regression on the actual affected path using the documented runner. Reuse valid before evidence; otherwise observe the defect-specific failure, implement the requested fix, then rerun unchanged assertions/inputs. Preserve neighboring behavior and required coverage. Inspect history only for unresolved behavior or implementation.

For an already-present fix, committed or not, requiring historical comparison, use the [isolated comparison procedure](references/existing-fix.md). Don't reverse patches in the user's working tree.

A required suite running that regression with matching inputs/runtime supplies after evidence; don't repeat it separately. Skipped, undiscovered or differently configured tests don't qualify. Changed relevant inputs invalidate reused results.

Batch final checks in one shell call, adapting the runner and paths:

# Necromancer

> The previous developer left. Their reasons didn't.

## Follow the haunting

Read known implementation and consumer/contract files together, including enclosing logic. Discover only missing locations; search unresolved bindings before expanding scope. Text matches in examples or generated/vendor copies need a supported loading or consumer path to establish a live dependency. A narrow search cannot establish absence of other callers.

Separate two questions:

- **Needed now?** Establish a required current caller/contract or reproducible failure. A concrete break can settle a removal-only decision; preserving behavior need not preserve its mechanism. Comments alone and absent local callers cannot settle supported public contracts.
- **Why introduced?** Inspect history when requested or when an unresolved compatibility, regression or replacement decision needs it. Current necessity does not establish origin, and a commit message does not establish current necessity.

For missing attribution, use `git blame -L <start>,<end> -- <path>` and inspect that commit's relevant before/after change. Reuse established facts instead of collecting them again. Use native Git for one fact; the optional [focused history guide and collector](references/focused-history.md) covers repeated collection, renames and oversized patches. Read it only for those needs.

# Receipt

> You fixed it? Show me the receipt.

Reuse supplied guidance; discover missing instructions only within authorized roots, never through an out-of-scope ancestor sweep. Report inaccessible evidence instead of broadening access.

For a current bug, select a regression on the actual affected path using the documented runner. Reuse valid before evidence; otherwise observe the defect-specific failure, implement the requested fix, then rerun unchanged assertions/inputs. Preserve neighboring behavior and required coverage. Inspect history only for unresolved behavior or implementation.

For an already-present fix, committed or not, requiring historical comparison, use the [isolated comparison procedure](references/existing-fix.md). Don't reverse patches in the user's working tree.

A required suite running that regression with matching inputs/runtime supplies after evidence; don't repeat it separately. Skipped, undiscovered or differently configured tests don't qualify. Changed relevant inputs invalidate reused results.

Batch final checks in one shell call, adapting the runner and paths:

# Con Artist

> Your mock is very impressed with itself.

## Check what the test actually buys

Trace the requested assertions far enough to establish the actual exercised effect
and select a reachable fault. Follow unresolved bindings, mocks and relevant setup;
reading every intermediate wrapper is not itself evidence. Reuse known instructions,
runner and source context. Keep discovery inside the permitted project root; a
broad suite need not become a reading list of unrelated tests.

Use the evidenced runner and configuration; reuse a valid correct-code baseline.
Choose one meaningful fault at the requested boundary, such as acknowledging

# Exorcist

> You keep saying cache. Let's test that belief.

## Find the decision-changing observation

Start at the reported failure using supplied paths or the repository file list. Reuse existing reproduction evidence; trace only until plausible causes diverge. Don't manufacture hypotheses for an established mechanism.

Observe that boundary in the actual implementation: submission versus persistence, dispatch versus completion, configuration versus effective state. Prefer existing observations or a recording dependency. Another layer recording the same value adds nothing unless its provenance is unresolved. A rewritten simulation or repeated success flag cannot establish an unobserved effect.

Choose the runner before inspecting setup: use existing tests when they exercise the distinction, otherwise one small probe with comparable inputs and controlled timing. Inspect fixtures/configuration if that path uses them or they could explain the symptom. Retain normal controls; repeat only for unresolved intermittency or a required check.

Before another experiment, ask which possible result changes the diagnosis or next action. If none, stop. A symptom without a suspected dependency shows that dependency is unnecessary for this reproduction, not every production incident. Explain why the existing safeguard does or doesn't address the observed mechanism.

# Friday

> Can Monday-you undo this?

## Read Monday's incident report early

When discovery is needed, combine it with reading supplied release notes/contracts and available project instructions, then batch the discovered relevant inputs. Avoid a listing-only round trip when supplied inputs are already readable. Keep Git internals out of file discovery (for example, `rg --files --hidden -g '!.git'`); use Git commands for relevant history. Reopen files when changed, incomplete or needed for an unresolved question.

Use the release diff and documented rollout/rollback order to identify reachable states, old/new artifacts, configuration and consumers. Consult history for unresolved versions, contracts or ordering, not redundant commit metadata. Do not impose rolling deployment or zero downtime on another strategy.

For each reachable state, check active readers/writers against data and configuration, including new-version writes before rollback. Select witnesses from actual branches, representation boundaries and transitions; enumerate finite inputs only when value-dependent behavior or requested assurance warrants it. Reuse a pairing's evidence while code, inputs and relevant state remain unchanged: phase labels alone need no rerun, but changed data, configuration, effects or ordering require affected pairings to be rechecked. Include queued/external effects when their contract changes.

Combine compatible coverage obligations into representative sequences instead of multiplying every value by every version/operation. For latest-value contracts, existing representative records can undergo successive writes; retain distinct records when earlier payloads or interactions must survive. Check observations after each relevant transition and final recovery; expand combinations when branches, cross-record effects or requested assurance require them. Fewer witnesses must not mean reusing stale observations.

# Hostage Negotiator

> Release the button. The architecture stays.

## Establish the terms

Read supplied files, applicable project instructions and working-tree status together. Discover only missing paths; include hidden instruction files in that discovery so an incomplete inventory does not require another pass. Do not precede known-file reads with a separate directory listing. Search again for an unresolved dependency or instruction boundary. Use the project's runner.

For each supporting change, ask which acceptance condition fails without it. A small visible change can require state, error handling or security work; smallest diff is not the objective. Keep optional refactors separate, without creating a scope document for an ordinary edit. Ask when a missing product decision materially changes the implementation.

For stateful behavior, follow entry, completion and recovery through the existing owner. Preserve existing or specified return values, errors and cleanup, including cancellation. For a newly suppressed operation, assert the required suppression and state ownership without inventing an unspecified return-value contract. Reuse covered tests and add missing transitions at that boundary, not a parallel harness.

Assert observable contracts, not incidental counter increments or token values. For stale or failed work, capture contractual field values before release and compare afterward; retaining the owner object can alias in-place mutations. Preserve payload/error identity and snapshot mutable contents only when contractual. Do not invent exception-identity requirements for task cancellation.

# Landlord

> Who's paying rent on this abstraction?

## Inspect the lease

Start with supplied paths, contracts and instructions. Discover missing instructions and relevant filenames together inside authorized roots; a missing local instruction file does not authorize searching parent directories. If needed evidence lies outside scope, report the gap. Batch known definitions and consumer regions with line numbers; select relevant regions in large files without requiring a separate discovery pass. Retain enclosing logic and use full-file context when needed. Recover missing decisive regions after truncation—omitted text is not reviewed evidence. Search unresolved bindings, not another copy of already-read source. Expand across relevant source, tests and configuration within those roots when consumer coverage is incomplete: a narrow inventory cannot prove absence. Installed skills and copied examples need a supported usage/binding to count as consumers.

Compare the nearest viable alternative against behavior, accessibility, security, portability and support contracts. Stop surveying once decision-changing differences settle the choice.

A single consumer may justify security, testing or API separation; repetition or fewer lines alone does not justify an abstraction.

Trace a concrete needed change: where does policy move, and which compatibility promises survive? Removing a layer must not merely spread its complexity into callers. Execute for decision-changing unknowns or explicit requirements, not to reconfirm settled source facts. Static analysis cannot establish unresolved runtime behavior.

# Mother-in-law

> And what happens if I click it twice?

Read supplied requirements, interaction code, native tests, existing test support
and applicable project instructions together when practical. Discover missing
paths, not another inventory before known-file reads.
Use controlled responses/clocks, isolated cases, bounded waits, and owned-operation
cleanup—never sleeps or production actions. Preserve user files and scope.

Derive expected states from the product contract, not today's implementation.
Separate final ownership from interval requirements. “Retain while loading” or
“until the latest completes” applies throughout that interval: assert the retained
value after relevant intervening completions while the latest remains pending,

# Necromancer

> The previous developer left. Their reasons didn't.

## Follow the haunting

Read known implementation and consumer/contract files together, including enclosing logic. Discover only missing locations; search unresolved bindings before expanding scope. Text matches in examples or generated/vendor copies need a supported loading or consumer path to establish a live dependency. A narrow search cannot establish absence of other callers.

Separate two questions:

- **Needed now?** Establish a required current caller/contract or reproducible failure. A concrete break can settle a removal-only decision; preserving behavior need not preserve its mechanism. Comments alone and absent local callers cannot settle supported public contracts.
- **Why introduced?** Inspect history when requested or when an unresolved compatibility, regression or replacement decision needs it. Current necessity does not establish origin, and a commit message does not establish current necessity.

Use the documented project interpreter for behavioral probes. If none is specified, identify an available compatible executable alongside initial source reads rather than trial-running a guessed name. Retain the probe's own exit; later diff/status commands do not replace it.

# Receipt

> You fixed it? Show me the receipt.

Reuse supplied guidance; discover missing instructions only within authorized roots, never through an out-of-scope ancestor sweep. Report inaccessible evidence instead of broadening access.

For a current bug, select a regression on the actual affected path using the documented runner. Reuse valid before evidence; otherwise observe the defect-specific failure, implement the requested fix, then rerun unchanged assertions/inputs. Preserve neighboring behavior and required coverage. Inspect history only for unresolved behavior or implementation.

For an already-present fix, compare isolated versions with the same current assertions/inputs and compatible runtime; identify the code loaded by the test process. Reuse an adequate project-native comparison instead of rebuilding it. Optional support for [Python](references/existing-fix.md) or [native Node tests](references/node-comparison.md) supplies copying, source checks and cleanup when those are missing. Choose by the required evidence and setup work, not merely by language support. Don't reverse patches in the user's working tree.

A required suite running that regression with matching inputs/runtime supplies after evidence; don't repeat it separately. Skipped, undiscovered or differently configured tests don't qualify. Changed relevant inputs invalidate reused results.

Batch final checks in one shell call, adapting the runner and paths: