Getting Things Done sorts tasks by context: what you can do at a phone, at a computer, on an errand. Agent work sorts the same way, and the context decides what the work can produce.

The last row is the subject of this note. The first three make the spec; the last one checks whether the spec and the code agree while something real is happening. A session moves down the table and back up: a question asked by voice becomes a spec in a repository, which becomes a run against a live process, whose evidence goes back up as a decision.

A live mutant is a function redefined in a running process. To learn anything from one, four parts have to be named:

Joined, they give each mutant one of four outcomes, the cells of the RIPR model (reach, infection, propagation, revealability): never reached; reached but never changed an output; changed outputs but no check noticed; killed. A property-based tester on its own reports only the last.

This is also what context surfaces lacked: a surface says what can be read from a running system, and nothing about what moves it. Every new surface added to an agent's context needs the same four named.

The baseline is about a hundred lines of plain Clojure with the classic property shapes: run-length encoding (round trip, maximal runs), merge sort (against sort, idempotent, stable), binary search (against a linear scan), a sorted-vector set and a two-list queue (each against a model, with its invariant). All eight properties hold.

The observer is a probe that replaces one var:

(defn probe [original mutant log]
  (fn [& args]
    (if *shadow*
      (apply original args)                 ; the original's own recursive calls skip the probe
      (let [expected (binding [*shadow* true] (apply original args))
            actual   (apply mutant args)]
        (swap! log #(-> % (update :calls inc)
                          (update :infected + (if (same? expected actual) 0 1))))
        actual))))

Each mutant is swapped in with with-redefs-fn (what alter-var-root does from a REPL), and every property runs at a fixed seed. Six mutants, seeds 42, 1 and 7, the same result at each:

Counts are from seed 42. Two rows say more than "killed". rle-runs-of-two still decodes correctly, so the round trip, the property everyone writes first, cannot see it; only the invariant on the encoding can. And insert-le was reached three thousand times without once changing an output: no property should kill it, and a mutation score that counts it as a survivor is wrong about the tests.

The page is a small shop whose catalogue changes underneath it: a data driver reprices pets, sells them out and puts them on backorder on a schedule, and the page has to keep up within 2,000 ms (Bombadil for SPAs covers the explorer). Bombadil explores it for 75 s with 18 temporal laws. Thirty seconds in, one store function in the running server is redefined through a loopback-only route, and the moment it went in is recorded. A reset route undoes it, on every exit path.

No violation came before a mutant went in, and the clean run had none. The killers match those of the same faults set by a switch at start. The new column is the first one: because the probe records when the mutated call first made a difference, time-to-kill splits into reach (waiting for the program to exercise the change) and detection (the laws noticing). Detection was 20 to 222 ms. backorder-as-201 took ten seconds because an order has to land on a backordered pet before the mutant does anything, the same ten seconds it took as a switch.

silent-reprice, frame by frame. Before the mutant, the catalogue is at v49:

368 ms after it, the first violation: the cart still quotes Waffles at $29.99 while the catalogue says $30.99, totals $290.85, and checkout is in flight. A correct store answers 409, stale price:

The next state: "Order #33 placed: $294.85". Four dollars more than the quote, four Waffles at a dollar each, reported to the shopper as success:

A live change goes in at one of two places. Redefining code keeps every state the run reaches one the program built itself; only a transition is wrong, so a counterexample is a finding. Writing state (memory through a debugger, a database row, the DOM) can start the run from a state the program could never reach, and a counterexample from there is a bug in the harness. The umoria harness's crashes were mostly of that kind: a player outside his own screen panel, an over-full pack, an uninitialised item. Its fix is the one the shop's data driver already follows: change the world only through the program's own transitions.

The contract is language-neutral; what changes is how a call site is redefined while the process runs.

The TypeScript port made a calls count about ten times lower (fast-check's default arrays stop at ten elements; test.check's grow) and the same outcome in every cell. The Ruby port's shrinker barely shortens arrays, so its witnesses are longer (eleven zeros for rle-runs-of-two, not three fours), and the verdicts are the same. Counts are a property of the generator; the cells and the killers are a property of the tests.

• C1. The observer's equality is no coarser than the checker's.
• C2. Redefine code; don't write state, or check the program's invariants on any state you write.
• C3. Restore on every exit path, and have the reset path undo every redefinition.
• C4. One mutant at a time.
• C5. A mutant changes one decision and lets the rest run.
• C6. The checker never reads the observer.

• Apply times of 10 s and 50 s, twice each, before the detection lags are more than one sample.
• The browser-side version: a page function patched over the DevTools protocol while Bombadil drives the same Chrome.
• Rung 4 in the other stacks, behind Express, Django and Rails versions of the shop.