INSPECT · COMPARE · VERIFY

Agent hotfix: verify the fix without skipping regression evidence

Replay an incident fixture, patch assertion, adjacent contracts, and a canary rollback check.

Four exact checks · sixty-second inspection
1. Reproduce the incidentWaiting

The original fixed request must exhibit the expected repaired behavior.

2. Exercise the patchWaiting

The changed branch must pass a focused assertion with its known edge input.

3. Run adjacent contractsWaiting

Previously working tool and state contracts must remain intact.

4. Check canary rollbackWaiting

A small cohort must meet the synthetic error bound before promotion.

Decision trace

    What this lab demonstrates

    A hotfix narrows the change but often shortens the time available to check it. This lab models four pieces of evidence that should remain separate: the original incident no longer reproduces, the patch works on its edge input, adjacent contracts are still valid, and a small canary stays below a rollback threshold. The injected defect menu lets a learner hide a different failure at each stage. A green reproduction alone cannot establish that a nearby tool call or state transition remained intact. The final card makes the deployment decision depend on an explicit canary observation.

    How to use each control

    Select an Injected defect, then choose how many checks the hotfix team actually runs. The first check repeats a fixed incident request; later checks exercise the patch branch, unchanged contracts, and a synthetic canary. Play test run advances one check every fifteen seconds. Pause holds the view, Restart returns to the first stage, and the timeline slider jumps to a precise stage or final decision. Speed changes only playback pace. The trace states whether a check passed, failed, or was skipped. A skipped regression test must never be interpreted as evidence that the regression is absent.

    Try a controlled failure

    Choose Adjacent contract regresses while including only the first two checks. The incident and focused patch look healthy, yet the regression escapes because the nearby contract is never exercised. Add the third check and replay; release should be blocked. Next choose Canary error spike and include three checks. The offline sequence remains green, but the live-cohort problem is invisible until the fourth check is selected. Compare these outcomes with Original incident still reproduces, which the first check can catch. Write down the fastest *safe* path to evidence for the injected problem, rather than simply removing checks to shorten a clock.

    What this model simplifies

    All requests, contracts, and canary counts are deterministic fixtures. This is not a deployed agent or a measured incident timeline, and sixty seconds of animation does not represent real test duration. A production hotfix requires a real reproduction case, an artifact tied to the incident, verified rollback, dependency and secret checks, and monitoring that can distinguish the patched cohort from the baseline. The particular synthetic defect is known to the learner; real incidents often involve several interacting failures. A passing hotfix gate does not eliminate the need for post-release monitoring.

    Verify the incident and the surrounding behavior

    The hotfix sequence distinguishes reproducing the original incident, exercising the changed branch, checking adjacent contracts and inspecting a canary rollback gate. An urgent patch can fix the triggering example while breaking a neighboring tool or state contract. This lesson makes that coverage gap explicit. The stages contain predefined fault labels, not an actual patch, source-code diff or running deployment. Read each stage description to identify which assertion would have to exist in a real incident-specific regression suite.

    Choose coverage deliberately

    Injected defect selects one known fault, or a clean fixture. Checks included runs the first one, two, three or all four checks in their displayed order. This is prefix coverage, not a random sample and not a selection of arbitrary individual checks. A skipped check provides no evidence. The model uses an explicit mapping from defect identifiers to checks that detect them; it does not execute Java code, call an LLM, compile a package or infer semantic correctness. An escaped defect is visible because the simulator knows which fault you injected, whereas a real test runner would need independent evidence to discover that escape.

    Reproduce a coverage gap

    Choose Adjacent contract regresses and include two checks. Seek to the end: the incident and focused patch checks pass, while the regression check is skipped and the defect escapes. Include three checks to block that defect. Next choose Canary error spike with three checks: the escape returns because the relevant fourth gate is missing. Adding the fourth check catches that separate problem without changing what the first three checks cover.

    Interpret the failure boundary

    Original incident still reproduces is caught by the first selected check, even at minimum coverage. This does not mean every future incident can be detected by one example. The model assumes a perfect detector for each named fault and has no flaky tests, multi-fault interactions, rollback side effects or operational approval system. A clean run only means no defect was injected into this small fixture. It cannot estimate a real hotfix failure rate or promise recovery time.

    Inspect the replay

    Play starts the sixty-second inspection and becomes Pause while running. Pause holds the current stage; Restart returns to the beginning without changing the experiment settings. Speed changes viewing pace rather than model outcomes. Timeline seeks directly to a stage and pauses playback. Changing a scenario setting recomputes the deterministic fixture and rewinds it. The final decision appears at the end, so move Timeline to sixty to compare completed runs. Stage cards and the text trace describe the same selected fixture; their elapsed viewing time is not measured agent execution latency.