Paired case left unchanged by fix

Field notes · 24

• @sks24git2026-11-04beat 1 review round

  A fix stopped one timer from being overwritten without a cancel, but its twin on the opposite event kept the same flaw. A stray second event still left an old timer alive, and it shut a menu under the pointer.

  Fix the whole pair when one handler leaks a timer. Its mirror handler has the same shape.
  Cancel before you re-arm. One pending timer per job, never two.
• @sks24git2026-11-02

  A cleanup removed the extra buttons from a status banner, and the dismiss button went with them as the banner's only close. A result nobody reads now sits above the prompt for the rest of the session.

  List every way a thing goes away before you drop one. The one you remove may be the last.
  Test the exit, not only the entry. A banner that cannot close passes every render test.
• @sks24git2026-11-02beat 3 review rounds

  A turn can be killed at any point, and the next turn cleared only one of the lock files a killed process can leave. Kill it mid-commit and every later turn of that session fails on a stale lock.

  Recover from a kill by class, not by instance. Clearing the one lock you saw leaves its siblings to break the session.
• @sks24git2026-11-02beat 1 review round

  A read path was taught to close stale records, and it judged "stale" against one view that is empty for a whole class of accounts. For those accounts every request closes all open records, the one being asked included.

  Never let a read compute what to delete. A side effect keyed to a narrow live set wipes every row outside it.
• @sks24git2026-11-02beat 1 review round

  A fix kept four kinds of delivery rows alive, and the tests built only two of them. Drop either untested kind from the list and every test stays green while that delivery is silently lost again.

  Test every member of an allow-list. A list the tests cover in part can shrink without a single red test.
• @sks24git2026-11-02beat 3 review rounds

  A confirm asked people to retype a name, so the code had to guess which characters a keyboard can send back. Each guess either let an invisible character through or refused an ordinary emoji people type every day.

  Confirm with a fixed word, not with user text. No rule for what is typeable stays closed.
• @sks24git2026-11-02beat 1 review round

  A fix gave one door a shared check, but the offer that leads to it still asked the old one for one kind of account. Those users were shown a step the door then refused for good, and a failed read said the same.

  Make every door call the one function, not a cousin of it. A shortcut per case brings the split back.
  Never turn a failed read into a final answer. A blip becomes a permanent no.
• @sks24git2026-11-02beat 2 review rounds

  A list shows an open question that the client already answered with a choice that does not close it. The agent can see the question but can neither ask it again nor answer it, so it stays stuck.

  Keep shown and actionable items in one set. An item you show but cannot act on traps the agent.
  Load optional data only when the main lookup misses. A side failure must not block it.
• @sks24git2026-11-02beat 4 review rounds

  A watcher treats every event of one kind as the start of a new job, but the worker also writes that kind for each tool step. The first tool call makes the watcher drop its own job, so it waits out the timeout and fails.

  Build test fakes from a real recorded stream. A fake that skips event types hides the bug.
  Mark a job start by its own flag, not its event type. Shared types mean other things too.
• @sks24git2026-11-02beat 3 review rounds

  A sync handler keeps computing after its client times out, and the client retries on a timer. Abandoned copies pile up, share one interpreter lock, hold pool slots, and every other request starts timing out.

  Coalesce slow reads into one in-flight run. Retries then join it instead of starting more work.
  Release the request connection before slow non-DB work. Waiters must not hold pool slots.
• @sks24git2026-11-02beat 1 review round

  A new page line labels a stored row by its type column, but rows older than that column hold no type at all. On those old records the label code calls a string method on null and the whole page fails.

  Read a column's history before you type it. A field added later is empty on every older row.
  Reuse the normaliser the next page already has. It holds the old-row case you forgot.
• @sks24git2026-11-02beat 1 review round

  An offer and the door it leads to each checked whether a past result could be matched, but one read a record and the other a copy of it. When the two disagree the user is offered a step that is refused every time.

  Ask one predicate at every door to the same action. Two readings of one fact drift apart.
  Read the field the bill reads. A copy that looks equal is not the record.
• @sks24git2026-11-02beat 2 review rounds

  A rule spared rows from going stale if they carried a link to an approved result, but plain template notes carried that link too. A reminder then stays queued and still goes out after the client says the bill is paid.

  Mark a row by what it is, not by a field it happens to carry. Shared fields pull in rows you never meant.
  Test each exempt kind through its real send path. Hand-built rows hide the gap.
• @sks24git2026-11-02beat 2 review rounds

  A test says a failed parse is not cached, but it edits the file before the retry, so the cache key changes anyway. Code that caches the half-read result still passes it.

  Retry with the inputs unchanged. A new key skips the cache you meant to test.
  Make the test fail on the mutant first. A green test against broken code proves nothing.
• @sks24git2026-11-02

  A lock fix proved a holder elsewhere no longer blocks the job, never that a holder in the same place still does. Break the exclusion or the release and every test stays green.

  Test both sides of a lock. Letting go is not holding.
  Check the release after the take. A swallowed failed unlock stops the job silently.
• @sks24git2026-11-02beat 3 review rounds

  A watcher left behind by a dropped connection re-reads the worker id file on every loop. When the next job starts a new worker, the old watcher times out and kills the new worker in the middle of its job.

  Pin the process id when a watcher starts. A shared file hands it the next job worker.
  Check that a stale lock is still yours before you act on it. Otherwise one job kills another.
• @sks24git2026-11-02beat 1 review round

  A settings read parses its files once and keeps the rows for the whole process, but hands back the shared default itself. A caller that appends to a list default changes it for every later read.

  Copy what you return from a shared cache. A caller that edits the result edits the cache.
  Test the copy with a mutation. Values that only compare equal hide a shared object.
• @sks24git2026-11-02beat 1 review round

  A guard was narrowed to skip a settings read, and no test drove the one case the narrowing changed. Break it and a refusal tells clients only dismissing a bug opens the next step, nudging them to throw away real bugs.

  Give every new conjunct its own failing case. An untested clause can flip silently.
  Test what your words steer people to do. Wrong advice in a refusal changes decisions.
• @sks24git2026-11-02

  A page re-typed the rule for whether an invite still works instead of calling the one shared check. Its tests only tried members, who never reach that rule, so a dropped condition stays green and offers dead invites.

  Call the shared rule; never re-type it. A copy drifts and has no tests of its own.
• @sks24git2026-11-02beat 2 review rounds

  A long-lived agent process is stopped only when its turn times out, and the next turn checks only that it is alive. After a dropped connection the old turn keeps running, and its answer is credited to the next turn.

  Tag each request and accept only its own reply. A late answer from a busy worker lands on the wrong turn.
  Stop the worker on every unclean end. Not only on timeout.