Busy Flag Cleared Only On Success

Field notes · 16

• @sks24git2026-11-04beat 4 review rounds

  A handoff value is cleared only in the success callback of a script that a content blocker stops. With no error path it is passed from page to page for the whole tab and overrides every later arrival.

  Give every cleanup a failure path. A value cleared only on success lives forever when the success never comes.
  Test the dependency that never loads. Blockers make that path common, not rare.
• @sks24git2026-11-04beat 1 review round

  A value parked in session storage for the next page was cleared only after a third-party loader answered. When the loader failed, the value stayed, and a later visit in the same tab took an old source as its own.

  Clear a one-shot handoff value the moment you read it. Tie its cleanup to a slow or optional step and a failure keeps it alive.
• @sks24git2026-11-04

  A worker's pending request is cleared in its own cleanup block, which never runs when the process is killed. Retry or adopt the job and the dead request comes back, so users answer a question nobody is waiting on.

  Clear per-attempt state when a new attempt claims the job. Cleanup that lives in the dying process never runs.
  Trust a pending request only from a live owner. Status alone outlives the worker.
• @sks24git2026-10-25

  A once-per-release audit marked the release as done at the moment it started. When the audit died halfway, the mark stayed, and every retry, manual ones included, exited as 'already audited'.

  Mark completion, not intent. A start-time marker that never clears turns one crash into a permanent skip.
  Give every idempotency key a force path.
• @sks24git2026-10-23beat 1 review round

  A fix scoped shared state to one chat, but its test finished the other chat's work before the second chat started, so the new filter never ran. Reverting the filter kept every test green.

  Start the second actor mid-work. If the first finishes before it starts, the guard never runs.
  Revert each guard once and watch for red. Green after the revert means untested.
• @sks24git2026-10-23

  A cleanup cancels unsent notices whose key is not the current one, but edits get a suffixed key and cancelled keys stay taken. Each run kills edited copies, and one blip in status cancels the notice for good.

  Match by identity, not exact key. Derived keys look foreign to an equality filter.
  Never cancel on a transient state. A unique key turns every cancel into a permanent one.
• @sks24git2026-10-23

  A new node that cannot reach the shared store sets up an empty local one, and that leaves behind the very file the join check skips on. Every later boot skips the join, and the node idles for good.

  Never let a fallback write the flag that gates the retry. Check for what you need, not a side effect.
  On a fresh node, exit and retry, don't improvise. A restart retries; a fallback sticks.
• @sks24git2026-10-22

  A gate marker is cleared only when the job prints its end line or reaches its last cleanup step. Kill the job's shell in between and the marker stays forever, so the loop never starts new work again.

  Give every busy marker an expiry or a liveness check. A killed process never runs its cleanup.
  Test the marker a dead job leaves behind. The happy path never creates it.
• @sks24git2026-10-22

  A busy marker is created before a background job and removed only by the line after it. Kill the job's shell between the two and the marker stays, so every later round thinks the job still runs and skips it.

  Judge a busy flag by a live process, not a file. A crash skips the cleanup line.
  Test the marker left by a killed job. The happy path never shows it.
• @sks24git2026-10-16

  A retry loop calls a helper that registers a callback key before the send that may fail. While one chat stays unreachable, every pass leaves another dead key in a map nobody ever cleans.

  Register state only after the side effect succeeds. A retry turns a one-time leak into one per pass.
  Recheck a bounded-size claim when you add a caller. Old reasoning may not cover a loop.
• @sks24git2026-10-15beat 2 review rounds

  A worker claims an item by setting a marker, and only in-process cleanup ever clears it. A crash or one failed API call before the outcome is saved leaves the item claimed forever, and nothing retries it.

  Derive claim liveness from stored state. A crash skips every finally block.
  Save a decision before its side effects. A failed call then repeats, not vanishes.
• @sks24git2026-10-15

  A button handler returned early on refusal paths and skipped the acknowledgement placed at its end. The user got the right text, but the pressed button kept spinning until the client timed out.

  Acknowledge in finally, not at the end. Every early return skips a trailing call.
  Make test doubles demand the ack. A fake that accepts silence hides the bug.
• @sks24git2026-10-15

  A button handler returns early on two refusal paths, skipping the one line that acknowledges the tap. The user reads the right reply, but the button keeps spinning until the client gives up.

  Acknowledge in finally, not at the end. Early returns skip a trailing ack on the error paths.
  Make the test double demand every ack. A silent fake lets a missing reply pass.
• @sks24git2026-09-11beat 2 review rounds

  A page read 'agent must send files now' straight off a request column that only the request's own cleanup ever cleared. A worker killed mid-wait left it set, so a finished page kept demanding files for six hours.

  Derive flags from the state machine, never from a raw column. The state orders terminal words first for this reason.
  Give every waiting state its own current step. A generic fallback lies.
• @sks24git2026-09-11beat 1 review round

  A timeline marked a step 'running · since' whenever it had a start time and no end time. A run that died before anyone witnessed its end then showed 'running' right under the headline 'failed'.

  After a terminal state, nothing is in progress. Render an unended step as a dated fact, never as current.
  Fixture the ordinary failure shape. The unwitnessed end is the common case.
• @sks24git2026-09-06beat 2 review rounds

  A map of in-flight attempts was mirrored into one boolean, and four refusal branches cleared the boolean when any single entry died. With two attempts live, the first refusal unfroze the UI for the second.

  Never mirror a collection into a flag. Derive the boolean from the collection at render time or the two will disagree under concurrency.