Skip to content

fix(taskq): settle an unleased retry_wait row its tombstone proves ended - #22252

Closed
cruisercohen wants to merge 2 commits into
mainfrom
fix/22244-retry-wait-boot-settle
Closed

cruisercohen wants to merge 2 commits into
mainfrom
fix/22244-retry-wait-boot-settle

Conversation

@cruisercohen

@cruisercohen cruisercohen commented Oct 19, 2026 •

Copy link
Copy Markdown
Contributor

Problem / Motivation

Goal: A gateway restart clears a chat slot that a stranded retry_wait sub-agent row left answering 409 on every turn.

When a sub-agent run's own terminal write is lost while its task row sits in retry_wait with no lease (the shape #17158 described: a Stop whose cancel was refused, with the run's tombstone already recording the stop), the row is never settled. count_pending keeps counting it, _attached_verdict keeps treating the parent slot as attached, and every turn on that slot gets 409 slot_subagents_running. In the reported case the row was also not re-claimed across two gateway restarts, and the only repair was a hand edit of the task store.

Why it matters

The parent chat slot is unusable until someone edits the task store by hand, and restarting the gateway, the obvious recovery, does not help. #17161 stops the dropped cancel that produced this shape; a row already stranded, or one that reaches the same shape another way, stays wedged.

Not a goal

What changed (motivation → approach → change)

Symptom: a slot answers 409 forever after a stopped child. Root cause: reconcile_on_boot (taskq/reconcile.py) reads store.active_rows(), which selects the ACTIVE states; retry_wait is in CLAIMABLE, not ACTIVE, so a restart never looks at the row.

Change: after the existing ACTIVE pass, a second, narrower pass reads every retry_wait row with no lease (all pages first, then the writes, so a settled row cannot shift a later page) and settles it on ONE ending: a stop its current attempt recorded, written as cancel with only_from={retry_wait} and the generation the pass read. Every other verdict leaves the row to its dispatcher as today: done has no edge from retry_wait; started or no verdict is the dispatcher's to re-run; and failed is not written, because a wait wake or a park also lands a row in retry_wait for a retry without writing a claim, so a failure there cannot be told apart from one the dispatcher was meant to retry (#22244 reports a stop). A probe that raises is recorded in report.errors, so _log_unsettled names the row at boot, and leaves that row alone. The pass is counted in a new ReconcileReport.parked_examined, so examined keeps meaning the ACTIVE pass. docs/system-specs/modules/taskq.md describes the pass.

The stop must be the CURRENT attempt's, matched by identity, not by time (second commit). A claim reads no artifact and the run folder is the row id's, so a row whose ending was lost can be claimed and run again over the folder its earlier attempt ended in; the in-memory guard against that, _stopped_while_claimed, reads only _agents, which a restart or a dismissed card empties. So an attempt is named by the generation of the claim that began it:

  • the store's claimed event already records that generation;
  • the registered run keeps it as SubagentInfo._taskq_attempt, set at registration beside _taskq_generation (a wait wake moves _taskq_generation, never the attempt);
  • every tombstone the run writes (_write_tombstone) records it as taskq_attempt, and a later bookkeeping rewrite that carries no ending of its own (the delivery acknowledgement) carries it forward, as it carries outcome and leaked_process.

The pass reads each row's latest claimed event (store.latest_events, one query per page) and calls the same artifact_probe with attempt=<that generation>; the ArtifactProbe type says so, and the ACTIVE pass still calls it without. The subagent probe (taskq_artifact_probe) then answers only from a tombstone whose taskq_attempt equals that attempt. No wall clock is compared anywhere.

Every case it cannot match leaves the row untouched, exactly as on main:

  • a tombstone naming an earlier attempt, whatever the wall clock did between that stop and the later claim;
  • a tombstone written before tombstones named their attempt. Rows stranded before this change are NOT auto-settled: their tombstones carry no attempt, so nothing proves which attempt they ended. kirocrew doctor (feat(doctor): name task rows that are not terminal, unleased and long past due #22270) already names such a row once its due time is long past, the reported shape, as stranded with no lease;
  • a row with no claimed event, or a page whose claim history cannot be read (each row named in report.errors);
  • a probe that does not take attempt (it raises, which is recorded in report.errors).

With no artifact_probe the pass reads no row. The one production caller, taskq_open, passes the subagent probe, so the boot open gets the fix.

Alternative considered: adding retry_wait to ACTIVE. Rejected, because the ACTIVE pass also requeues and recovers rows by side-effect class, which would re-run work the dispatcher already owns.

Backwards compatibility

Compatible: the pass only writes cancelled, and only on an unleased retry_wait row whose current attempt's own tombstone records a stop; every other row, state and verdict is handled exactly as before, and a tombstone written before this change settles nothing.

Removes nothing: no key, field, function or validator is removed or tightened. ReconcileReport gains parked_examined, SubagentInfo gains _taskq_attempt, tombstones gain an optional taskq_attempt key that no existing reader requires, and taskq_artifact_probe gains an optional attempt, which the retry_wait pass passes and the ACTIVE pass does not.

Tests

Failing first on origin/main 3e39e7a, passing with the fix (test/test_taskq_reconcile.py):

  • test_an_unleased_retry_wait_row_whose_run_was_stopped_is_cancelled_at_boot: the reported shape (claimed, starting, the stop's tombstone.json with cause: user_stop, outcome: stopped and taskq_attempt naming that claim, released to retry_wait, no lease, due time six hours past) read through the real subagent probe. On main the row stays retry_wait and the parent's count_pending stays 1; with the fix the row is cancelled, count_pending is 0 and the row cannot be claimed.
  • test_an_unleased_retry_wait_row_is_settled_only_on_a_proven_stop: cancelled settles (red on main); failed, done, started and no verdict leave the row in retry_wait with its generation and no lease. The probe is asked once, with the generation of the row's latest claim.
  • test_a_retry_wait_probe_that_raises_leaves_its_row_and_settles_the_rest: a raising probe is named in report.errors, its row is untouched, and the next row is still settled (red on main).

The attempt match (second commit), through the gateway's own boot open (taskq_open), test_the_boot_pass_settles_a_parked_row_only_on_its_current_attempts_tombstone:

  • (b) [False-True-0.0-cancelled], the stop names the attempt the latest claim began: the row is cancelled.
  • (a) [True-True-3600.0-retry_wait], clock rollback: the row is claimed and started again after the stop with the wall clock stepped back an hour, so the old tombstone's died is LATER than the new claim. The row stays retry_wait with its generation and count_pending 1. Fails on 85e99b5 and on the previous head 632155e (assert 'cancelled' == 'retry_wait'): both cancelled the live later attempt.
  • (c) [False-False-0.0-retry_wait], a tombstone with no taskq_attempt (written before this change): the row is left untouched. Fails on 85e99b5 and 632155e.
  • [True-True-0.0-retry_wait], re-claimed with no rollback: untouched. Fails on 85e99b5.

Also: test_a_failed_run_woken_or_parked_into_retry_wait_is_left_to_its_dispatcher[wake|park] (a run that timed out while waiting, its row woken or parked into retry_wait, its tombstone naming the current attempt: left alone; fails on 632155e); test_the_subagent_probe_answers_a_parked_row_only_for_its_own_attempt (matching, earlier, missing, boolean and string taskq_attempt, and the ACTIVE call with no attempt); test_a_parked_row_with_no_claim_is_not_asked_about; test_a_probe_that_cannot_name_the_attempt_settles_no_parked_row; test_a_retry_wait_row_whose_claims_cannot_be_read_is_named_and_left.

The claim path carries the identity, test_taskq_admission_integration.py::test_a_registered_run_carries_its_claims_attempt_into_its_tombstone: a real spawn through the manager and its store. The registered run's _taskq_attempt equals the generation of the row's claimed event; a wake-shaped bump of _taskq_generation leaves it unchanged; the run's own _write_tombstone records it; mark_delivered's rewrite keeps it; and with the row released to retry_wait, reconcile_on_boot with the manager's probe cancels it.

Run locally: all 17 test/test_taskq*.py files plus the 81 suites that open the store, call the boot reconcile, wait for the manager's store open, write or read tombstones, or read the run record's taskq fields, with the dependency coordinator and session health (4,692 passed together); test_taskq_bridge_bindings.py with taskq_artifact_probe's new signature pinned; test_taskq_unconditional_cancel_callers.py passes with no new allowance because the new cancel carries only_from. black, isort and flake8 on the touched files, mypy over the whole package; the comment-history, brand, harness-parity, feature-map and docs-lint gates.

Manual verification

N/A: unit coverage sufficient. The tests drive the real TaskStore file across a close and reopen, as a restarted gateway sees it, through the real subagent artifact probe.

Related Issues

Fixes #22244

Pattern harvest

Not generalizable: the miss is one state outside one sweep's selection set, and the state machine already documents why retry_wait is not ACTIVE; the fix is a narrow pass for that state, not a rule other code can break the same way.

Checklist

  • At most two commits (one is the norm), with a Conventional Commits title (feat|fix|docs|style|refactor|perf|test|chore|ci|build|revert: ...)
  • Existing tests pass and new tests added for new functionality
  • Self-review completed; code follows project style guidelines
  • Documentation updated (if applicable)
  • No secrets, credentials, or internal references in the diff

Contribution License Agreement

Contributed under the project's Apache-2.0 license.

@github-actions github-actions Bot added the readiness: checking Automated validation is still running label Oct 19, 2026
@github-actions

github-actions Bot commented Oct 19, 2026 •

Copy link
Copy Markdown
Contributor

UX Review (Opus 5.5) — ⏭️ skipped

Revision a033334b97b50f33e7199b25bfb0c49b71260ec2 touches no user-facing surface (no changes under website/ or committed screenshots), so the UX review was skipped. Does not block merge.

@github-actions

github-actions Bot commented Oct 19, 2026 •

Copy link
Copy Markdown
Contributor

Design Review (Opus 5.5) — ✅ PASS

Design-level review of 29c9ef401ca63efc5d8aab6f645b6b4dc6069cd3 — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS/CONCERNS are advisory.

Design-Verdict: PASS

Check that the taskq_generation passed when gate.py registers a run is always a claim's generation. If some path passes another value, those stopped rows never match and stay stranded.

[DESIGN-REVIEWED] 29c9ef4

Description read

[DESCRIPTION-READ] 7b8fa969d2a9da6b35f59d51cabbc37299ad701d58cfaf8f1f8172a53138cbc5

That sha256 names everything this verdict read: the PR description, plus the 1 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with .github/scripts/pr-description-capture.sh over the same inputs; if it differs, the description or that evidence changed after this verdict was formed and any finding drawn from either is unproven.

@github-actions

github-actions Bot commented Oct 19, 2026 •

Copy link
Copy Markdown
Contributor

First Principles Review (Opus 5.5) — 🟡 CONCERNS

Premise-level review of 29c9ef401ca63efc5d8aab6f645b6b4dc6069cd3 — why this exists and whether the shipped surface is the smallest honest version. Updated in place on each push. A BLOCK verdict blocks PR readiness; PASS/CONCERNS are advisory.

First-Principles-Verdict: CONCERNS

The new boot pass won't clear the row that was actually reported, and #17161 already removed what produced it. Nothing names a remaining cause it would catch.

Not justified as shipped

  • Item 1 — inherited: the Goal says "A gateway restart clears a chat slot that a stranded retry_wait sub-agent row left answering 409", but the description itself says "Rows stranded before this change are NOT auto-settled". It also says "fix(taskq): stop fencing a user stop on the generation it read #17161 stops the dropped cancel that produced this shape". So the pass only helps a row that "reaches the same shape another way", and no such way is named, reproduced or linked. The tests build the stranded shape by hand.
    Clears when: a linked issue or reproduction shows a path to an unleased retry_wait row with a stop tombstone that still exists once fix(taskq): stop fencing a user stop on the generation it read #17161 is in place.

What this change ships

Inventory (6 items) — 5 justified

Intent: a gateway restart should free a chat slot that a stopped sub-agent's stranded retry_wait row keeps answering 409 on. FIX.

  1. On restart, an unleased retry_wait row whose current attempt's tombstone records a stop becomes cancelled — inherited: no live cause named after fix(taskq): stop fencing a user stop on the generation it read #17161
  2. Each tombstone records which claim attempt it ended (taskq_attempt), and a rewrite keeps it — justified
  3. A registered run remembers the attempt its claim began (_taskq_attempt) — justified
  4. The artifact probe can be asked about one specific attempt — justified
  5. The boot log and report gain a parked_examined count — justified
  6. A probe that raises, or a row whose claims can't be read, is named at boot and the row is left alone — justified

[FIRST-PRINCIPLES-REVIEWED] 29c9ef4

Description read

[DESCRIPTION-READ] ecdab70486a2a05cc775f16cd12c19b8bd82bfd108c2b909419b92de98d0c789

That sha256 names the PR description this verdict read. Recompute it with .github/scripts/pr-description-capture.sh; if it differs, the description changed after this verdict was formed and any finding drawn from the description is unproven.

@github-actions

github-actions Bot commented Oct 19, 2026 •

Copy link
Copy Markdown
Contributor

GPT 6.1 Review — ✅ no blocking findings

GPT 6.1 completed its review of a033334b97b50f33e7199b25bfb0c49b71260ec2 and found no blocking issues.

This comment is updated in place on each push.

Review details

No findings.
[GPT-REVIEWED] a033334

False positive or not applicable? A repository writer can comment:
/ai-review override gpt a033334b97b50f33e7199b25bfb0c49b71260ec2: <one-sentence reason>

@github-actions

github-actions Bot commented Oct 19, 2026 •

Copy link
Copy Markdown
Contributor

Opus 5.5 Review — ✅ no blocking findings

Reviewed 29c9ef401ca63efc5d8aab6f645b6b4dc6069cd3 — this comment is updated in place on each push.

Review details

No findings.

[OPUS-REVIEWED] 29c9ef4

Verdict parsed from the review's SHA-scoped output markers for commit 29c9ef401ca63efc5d8aab6f645b6b4dc6069cd3.

False positive or not applicable? A repository writer can comment:
/ai-review override fable 29c9ef401ca63efc5d8aab6f645b6b4dc6069cd3: <one-sentence reason>

@cruisercohen

Copy link
Copy Markdown
Contributor Author

Design review note on 85e99b5 (a parked row whose probe says done still counts in count_pending): correct, and left out on purpose. retry_wait -> done is closed in the transition table so a finished run whose terminal write was refused stays loud rather than being settled from its artifacts; this PR keeps that edge closed and settles only the endings retry_wait accepts (failed, cancelled). The reported shape is a user stop, which this covers. A done row in retry_wait stays claimable for its dispatcher, as on main; it is listed under Not a goal.

@cruisercohen
cruisercohen marked this pull request as ready for review October 19, 2026 19:12
@cruisercohen
cruisercohen requested review from a team and KiroCrewCaptain as code owners October 19, 2026 19:12
@cruisercohen
cruisercohen enabled auto-merge (squash) October 19, 2026 19:12
@github-actions github-actions Bot added readiness: passed Eligible automated validation passed for the current revision and removed readiness: checking Automated validation is still running labels Oct 19, 2026
@iamwhatever

Copy link
Copy Markdown
Contributor

HOLD (AI review check not answered; boot-time task ending reserved for human review) at 85e99b5.

The pass is narrow. It writes only failed or cancelled, fences each write on the state and generation it read, and leaves done, started and no-verdict rows to their dispatcher (reconcile.py L188-L214). The Design note has a sound reply, and CI is green.

Blockers:

  1. The First Principles check has no reply: can a retry_wait row that is waiting for a real re-dispatch carry a stop or failure tombstone from an earlier attempt? If so, this pass cancels or fails live work. The probe maps any tombstone cause except gateway_restart to an ending without checking which attempt wrote it (taskq_bridge.py L313-L318). retry_wait is also entered by the dependency park (dependency.py L127) and by non-resident wait wakes. Please reply with the evidence that each retry_wait entry path either clears or never sees such a tombstone, ideally with a test.
  2. The change ends queued work at boot, so it needs a human maintainer's review either way.

— crew-pr-reviewer (r113)

@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: passed Eligible automated validation passed for the current revision labels Oct 20, 2026
@cruisercohen
cruisercohen force-pushed the fix/22244-retry-wait-boot-settle branch from a5b65c1 to 632155e Compare October 20, 2026 02:50
@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running labels Oct 20, 2026
@cruisercohen
cruisercohen force-pushed the fix/22244-retry-wait-boot-settle branch from 632155e to 29c9ef4 Compare October 20, 2026 03:50
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention readiness: passed Eligible automated validation passed for the current revision and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Oct 20, 2026
@cruisercohen

Copy link
Copy Markdown
Contributor Author

Reply to the HOLD at 85e99b5, on 29c9ef4.

1. First Principles: can a retry_wait row waiting for a real re-dispatch carry an earlier attempt's stop or failure tombstone? Yes. A claim reads no artifact, and the run folder is the row id's. The guard against re-claiming a stopped row, _stopped_while_claimed, reads only _agents, and a restart or a dismissed card empties that. So a row whose ending was lost can be claimed and run again over the folder its earlier attempt ended in. 85e99b5 then read that earlier ending as the parked attempt's and ended live work. Probe: test_the_boot_pass_settles_a_parked_row_only_on_its_current_attempts_tombstone[True-True-0.0-retry_wait] (the row stopped, then claimed and started again) fails on 85e99b5 with assert 'cancelled' == 'retry_wait'.

Fix, in the second commit:

  • An attempt is named by the generation of the claim that began it. The claimed event records it, the registered run keeps it as _taskq_attempt (a wait wake moves _taskq_generation, not this), and the run's tombstone records it as taskq_attempt, carried through the delivery rewrite.
  • The parked pass calls the probe with the latest claim's generation, and the subagent probe answers only from a tombstone that names that attempt. No wall clock is compared.
  • The pass writes only cancelled. failed is left to the dispatcher, because a dependency park from starting and a non-resident wait wake or park also land a row in retry_wait for a retry without a claim. Re-dispatch makes a new claim, so the earlier tombstone no longer matches.
  • A tombstone that names no attempt settles nothing. Rows stranded before this change are not auto-settled; kirocrew doctor (feat(doctor): name task rows that are not terminal, unleased and long past due #22270) names such a row once its due time is long past, the reported shape.

Tests, through taskq_open:

  • (a) clock rollback: an old stop, then a later claim with an earlier wall time. The row is left alone.
  • (b) matching attempt: the row is cancelled.
  • (c) a tombstone with no attempt: the row is left alone.

(a) and (c) fail on 85e99b5 and on 632155e. test_taskq_admission_integration.py::test_a_registered_run_carries_its_claims_attempt_into_its_tombstone drives a real spawn: the claim's generation reaches _taskq_attempt and the run's tombstone, and the boot pass cancels the released row.

A remaining path to this shape after #17161: the stop's settle is a best-effort store write. taskq_settle logs a TaskStoreUnavailable (a locked or busy database) at debug and drops it, and a posted write still queued when shutdown's bounded report drain runs out is cancelled. Either leaves the row in retry_wait with the stop recorded.

2. A boot-time task ending reserved for human review: that part is a maintainer call, left to you.

@iamwhatever

Copy link
Copy Markdown
Contributor

HOLD (reserved for human review: a boot-time pass that ends queued work) at 29c9ef4.

The r113 question is answered. The pass now settles a parked row only on a stop recorded by its current attempt: the probe matches the tombstone's taskq_attempt to the generation of the row's latest claimed event (taskq_bridge.py L324-L328), and it writes only cancelled, fenced on retry_wait and the generation it read (reconcile.py L244-L270). Every mismatch leaves the row as it is on main. The First Principles concern has a reply that names a live cause, and I confirmed it: a TaskStoreUnavailable on the stop's settle is logged at debug and dropped (taskq_bridge.py L587-L589). The deferred items have linked issues (#22247, #22248, #18165). The GPT and Opus lanes found nothing, and CI is green.

Blocker:

  1. This change decides which queued work gets ended at boot, so a human maintainer needs to review it. I found no defect in it.

— crew-pr-reviewer (r114)

@github-actions github-actions Bot added the merge conflict Branch has merge conflicts with its base — author must resolve before merge label Oct 21, 2026
reconcile_on_boot examined only the ACTIVE states, and retry_wait is
CLAIMABLE, not ACTIVE. A retry_wait row left with no lease after its
run's own terminal write was lost (a Stop whose cancel was dropped) was
never looked at on restart, and count_pending kept counting it, so the
parent slot's attached-children guard answered 409
slot_subagents_running on every turn until the store was edited by hand.

Add a second, narrower boot pass over every unleased retry_wait row:
read all pages first, then settle a row whose artifact probe proves an
ending the transition table accepts from retry_wait (failed or
cancelled), fenced on the state and generation the pass read. done is
not written (retry_wait -> done stays closed), and started or no
verdict leaves the row to its dispatcher.

Fixes #22244
A claim reads no artifact and the run folder is the row id's, so a
retry_wait row whose ending was lost can be claimed and run again over
the folder its earlier attempt ended in. The boot pass then read that
earlier ending as the parked attempt's and ended live work.

An attempt is now named by the generation of the claim that began it:
the claimed event records it, the registered run keeps it as
_taskq_attempt, and the run's tombstone records it as taskq_attempt,
carried through a delivery rewrite. The retry_wait pass calls the
artifact probe with attempt=<latest claim generation>, and the subagent
probe answers only from a tombstone naming that attempt; no wall clock
is compared. A tombstone that names no attempt, written before this
change, settles nothing.

The pass also writes only cancelled: a wait wake or a park parks a row
for a retry without a claim, so a failed ending there is left to the
dispatcher.
@cruisercohen
cruisercohen force-pushed the fix/22244-retry-wait-boot-settle branch from 29c9ef4 to a033334 Compare October 21, 2026 07:58
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention merge conflict Branch has merge conflicts with its base — author must resolve before merge and removed readiness: passed Eligible automated validation passed for the current revision merge conflict Branch has merge conflicts with its base — author must resolve before merge readiness: checking Automated validation is still running labels Oct 21, 2026
@bolichen97

Copy link
Copy Markdown
Contributor

Thanks for this PR. It now conflicts with main. Could you rebase onto the latest main and resolve the conflicts? We will review it again once it is rebased and CI is green.

@bolichen97

Copy link
Copy Markdown
Contributor

[operator: bolichen97] Continuing this in #33155; thanks for the start.

bolichen97 added a commit that referenced this pull request Nov 8, 2026
…33155)

A sub-agent row left in retry_wait with no lease, whose run's tombstone
already records a user stop, was never settled: the boot reconcile's
queued pass reads retry_wait rows but acts only on the refusal and
queued-stop markers, so count_pending kept the parent slot answering
409 slot_subagents_running on every turn until the store was edited by
hand.

The queued pass now cancels such a row when the stop belongs to the
row's current attempt. An attempt is named by the generation of the
claim that began it: the registered run keeps it as _taskq_attempt,
its tombstone records it as taskq_attempt (carried through the
delivery rewrite), and the pass asks the subagent probe about the
generation of the row's latest claimed event. A stop from an earlier
attempt, or one that names no attempt, leaves the row as it was. The
cancel is fenced on retry_wait and the generation read.

Builds on #22252 by @cruisercohen.

Closes #22244
buluoray added a commit that referenced this pull request Nov 8, 2026
…33155)

A sub-agent row left in retry_wait with no lease, whose run's tombstone
already records a user stop, was never settled: the boot reconcile's
queued pass reads retry_wait rows but acts only on the refusal and
queued-stop markers, so count_pending kept the parent slot answering
409 slot_subagents_running on every turn until the store was edited by
hand.

The queued pass now cancels such a row when the stop belongs to the
row's current attempt. An attempt is named by the generation of the
claim that began it: the registered run keeps it as _taskq_attempt,
its tombstone records it as taskq_attempt (carried through the
delivery rewrite), and the pass asks the subagent probe about the
generation of the row's latest claimed event. A stop from an earlier
attempt, or one that names no attempt, leaves the row as it was. The
cancel is fenced on retry_wait and the generation read.

Builds on #22252 by @cruisercohen.

Closes #22244

Original author: Bolin Chen
(cherry picked from commit e7836f7)
@iamwhatever

Copy link
Copy Markdown
Contributor

Thank you for this work! It continued in #33155, which has now merged. Closing this one as superseded by #33155.

@iamwhatever iamwhatever closed this Nov 8, 2026
auto-merge was automatically disabled November 8, 2026 19:43

Pull request was closed

@github-actions github-actions Bot removed the readiness: action required A blocking check or review needs attention label Nov 8, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

merge conflict Branch has merge conflicts with its base — author must resolve before merge

Projects

None yet

Development

Successfully merging this pull request may close these issues.

taskq: boot reconcile never settles a retry_wait row left with no lease, so its slot keeps answering 409

3 participants