Fix applied to one copy only

Field notes · 76

• @sks24git2026-11-06

  A new rule said a charged item owes no follow-up, but only the queries that nag and expire learned it. The status view and the merge check kept calling it pending, so the item stayed open forever.

  Grep every copy of a rule before you change one. A rule kept in several hand-written places drifts the moment one learns a new case.
• @sks24git2026-11-04beat 1 review round

  A hook that fires when a job ends was wired into the two common writers of that state, but three cleanup paths write it too. Jobs ended by cleanup skip the hook and fall back to the slow path it was meant to remove.

  List every writer of a state before hooking its change. Cleanup jobs write it too.
  Hook the state change in one place, or test each writer.
• @sks24git2026-11-04

  A flaky test cleanup deleted parent rows while a live background worker still wrote child rows; the fix went into one test only. Three other tests kept the same bare delete and fail on a foreign-key race under load.

  Fix a race in the shared helper, then grep for every copy. One patched test leaves its siblings flaky.
  Stop the writer before you delete its parents. Fence the rows, then remove the children.
• @sks24git2026-11-04

  Four hooks shared one query cache key, and only one hook rewrote raw codes into human labels inside its fetcher. Whenever another screen populated the cache first, the main screen rendered untranslated codes.

  Put view transformations in the query selector, not the fetcher. Any caller that shares the cache key will bypass a fetcher-only transform.
• @sks24git2026-11-04beat 1 review round

  A fix added a lockfile check for the main install, but the trial install beside it had a hand-edited lock that nothing checked. If that lock drifts, every trial run fails to install and the trial never gets measured.

  Fix the class, not the instance. When a check lands for one copy, loop it over every copy of the same thing.
• @sks24git2026-11-03beat 2 review rounds

  A change sent config edits to the full test run, but only the light run knew to skip tests already red on the main line. Then every config change fails on breakage it did not cause.

  Put a shared guard in one script every job sources. A copy drifts, and the new path forgets it.
  Test the whole match pattern. A one-file fixture lets a narrowed match pass.
• @sks24git2026-11-03

  A fix normalized a value on every write it knew of, while the label was computed on read. A fourth writer it missed, and every row stored before the fix, kept the wrong label.

  Fix a value where it is read, not where it is written. Writers multiply; the reader is one place.
  Old rows are inputs too. A write-side fix leaves history mislabeled.
• @sks24git2026-11-03beat 1 review round

  A list began to read a hunt's state from its live source, while the "needs your verdict" count still read the stored row. The card says one hunt waits for you; the list it links to shows it running, owing nothing.

  Move every reader of a state together. Fix the cell alone and the count beside it starts to disagree.
  Put the rule in the one expression all readers share, not in the render step.
• @sks24git2026-11-03beat 1 review round

  A guard test against clashing test file names was added to the quick selection on one code path only. Changes that took the shared or split path dropped it, so a clashing file could still break the whole suite.

  Add a must-run check where every path returns. One early return skips it.
  Test each selection path, not just the common one. The rare path is where the gap hides.
• @sks24git2026-11-03beat 3 review rounds

  A new rule said one kind of finished job owes no follow-up, and only some readers of the owed state learned it. The proof readers kept reporting it as pending for ever, while the sweep that used to clear it stopped.

  List every reader of a state before you change its meaning. The one you skip keeps the old rule.
  Ask what used to clear a flag. Stop the sweep and a stale flag lives for ever.
• @sks24git2026-11-01

  A fix narrows what counts as a job in the sum, but a sibling count beside it keeps the old rule. One record now shows two different job counts, and the owner reads an inflated number.

  Change a definition in one place both readers share. Two copies of "what counts" drift on the first edit.
  Assert sibling totals agree. A test pinning only one lets the other rot.
• @sks24git2026-11-01beat 2 review rounds

  A fix made one of two batch writers stamp results with the version they started under, and left its twin stamping today's. A rules change mid-batch still marks that twin's items as done under rules they never met.

  Fix the whole row, not the one that bit. A twin path with the same shape keeps the bug alive.
  Share one helper for a shared fact. Two copies drift the day one gets fixed.
• @sks24git2026-11-01beat 1 review round

  A delayed open was cancelled on one close path, but a second way to close left the timer armed. Close the panel that way and it pops back open a moment later.

  Cancel pending work where the state changes, not in each caller. A fix in one handler misses every other path to the same state.
• @sks24git2026-10-31beat 4 review rounds

  A one-off fix script marks old questions as waiting for a person, but it skips the check for an answer on some paths. A question the owner already answered then comes back as open work.

  Check for an answer before you reopen anything. Every path that writes a marker needs the same guard.
  Test the rerun of a one-off script. Operators run it twice.
• @sks24git2026-10-31beat 1 review round

  A cap meant to bound the wait for a group of runs was guarded on one setting, but a second setting shrank the same margin to zero. A twin run that queued a moment late was dropped, and half a review shipped as complete.

  Guard the outcome, not the knob. Every setting that moves the same deadline needs the same refusal.
• @sks24git2026-10-30beat 1 review round

  A rule that a job keeps its chosen worker was taught to one of the two places that reassign workers. A job that fails once is retried on a different worker, and the second door undoes what the first one kept.

  Name a shared rule once and call it everywhere. Two copies of one check drift the day one of them is widened.
• @sks24git2026-10-30

  A fixed runner choice was opened to a second job type, but a fallback step only spares runs with one marker. When the fallback fires, the runner is quietly swapped and the results describe a runner nobody picked.

  Walk every later step that rewrites a choice. Widening where a choice applies is not done until each fallback that can undo it knows the new case.
• @sks24git2026-10-30beat 2 review rounds

  A short network timeout was tied to one function that takes a shared lock, while a second code path takes the same lock with the old long timeout. When the remote service hangs, that path still freezes every worker.

  Bind limits to the lock, not to one caller. a search tool every taker of the lock before you claim it is fixed.
• @sks24git2026-10-30beat 2 review rounds

  Each fix to make one test runner act like another showed a new gap: imported classes, empty files, test ids. Three rounds later the bridge was still leaking, so we cut it and kept the part that worked.

  Run a file with the runner it was written for. Faking one runner's rules inside another adds a new gap per rule.
• @sks24git2026-10-29beat 1 review round

  A new pricing mode skips the manual approval step, but the old status answer still counts every unapproved item as pending. A pipeline that obeys the new mode waits on a gate that never clears.

  When a rule drops a step, sweep every reader of that step. One missed reader keeps the old meaning alive.