feat: add durable background-job sidekiq table, store methods, and runner with recovery and reaper

[BearTS]

Summary

Introduces a generic durable background-job system ("sidekiq") that persists job state to the database, enabling long-running tasks to survive process restarts and crashes by resuming from a stored checkpoint cursor.

Changes

• Added TableSidekiqJob model with status constants (pending, running, completed, failed) and a sidekiq table backed by explicit raw SQL DDL for both Postgres and SQLite dialects, with a composite index on (status, updated_at) to support reaper and recovery scans.
• Added a add_sidekiq_table migration step that creates the table and index idempotently, falling back to GORM auto-DDL for unsupported dialects.
• Added CRUD and lifecycle methods on RDBConfigStore: CreateSidekiqJob, GetSidekiqJob, MarkSidekiqJobRunning, UpdateSidekiqJobProgress, CompleteSidekiqJob, FailSidekiqJob, ListIncompleteSidekiqJobs, and MarkStaleSidekiqJobsFailed.
• Extended the ConfigStore interface with the above methods.
• Added framework/sidekiq package containing a Runner that manages handler registration, concurrency-bounded goroutine dispatch, panic recovery, crash recovery (RecoverIncomplete), and a periodic reaper (StartReaper) that flips stale running jobs to failed when their heartbeat exceeds a configurable threshold.
• The Runner depends on a narrow Store interface rather than the full configstore, keeping it independently testable.
• Added unit tests covering: successful completion, handler errors, panic recovery, unknown-kind rejection, incomplete-job recovery, and reaper invocation.
• Added no-op sidekiq method stubs to MockConfigStore in the HTTP transport test suite to satisfy the updated interface.

Type of change

• Bug fix
• Feature
• Refactor
• Documentation
• Chore/CI

Affected areas

• Core (Go)
• Transports (HTTP)
• Providers/Integrations
• Plugins
• UI (React)
• Docs

How to test

go test ./framework/sidekiq/...
go test ./framework/configstore/...
go test ./transports/bifrost-http/lib/...

• Verify the add_sidekiq_table migration runs cleanly against both SQLite and Postgres backends and that the sidekiq table and idx_sidekiq_status_updated index are created.
• Enqueue a job via Runner.Enqueue, confirm it transitions through pending → running → completed in the database.
• Kill the process mid-job and restart; call Runner.RecoverIncomplete and confirm the job resumes from its last checkpoint metadata.
• Start the reaper with a short staleAfter duration, leave a job in running without heartbeating, and confirm it is flipped to failed.

Breaking changes

• Yes
• No

The ConfigStore interface gains eight new methods. Any existing mock or alternative implementation of ConfigStore must add stubs for all eight sidekiq methods.

Related issues

Security considerations

Job metadata is stored as a plain text JSON blob. Callers must ensure no secrets or PII are written into the metadata field, as it is persisted in plaintext and returned in query results without redaction.

Checklist

• I read docs/contributing/README.md and followed the guidelines
• I added/updated tests where appropriate
• I updated documentation where needed
• I verified builds succeed (Go and UI)
• I verified the CI pipeline passes locally if applicable

[BearTS]

• feat: add durable background-job sidekiq table, store methods, and runner with recovery and reaper #4989 : 2 dependent PRs (#5000 , #5004 ) 👈 (View in Graphite)
• dev

This stack of pull requests is managed by Graphite. Learn more about stacking.

[coderabbitai]

Caution

Review failed

The pull request is closed.

ℹ️ Recent review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro Plus

Run ID: cb41c345-6cc6-4c17-b81b-3433d9fa6be3

📥 Commits

Reviewing files that changed from the base of the PR and between b2bac0e and 220539f.

📒 Files selected for processing (9)

• framework/configstore/migrations.go
• framework/configstore/sidekiq.go
• framework/configstore/sidekiq_test.go
• framework/configstore/store.go
• framework/configstore/tables/sidekiq.go
• framework/sidekiq/sidekiq.go
• framework/sidekiq/sidekiq_test.go
• transports/bifrost-http/lib/config_test.go
• transports/bifrost-http/server/server.go

---

📝 Walkthrough

Summary by CodeRabbit

• New Features
  • Added durable Sidekiq-style background jobs with a persistent sidekiq table, status lifecycle (pending/running/completed/failed), progress checkpoints, and stale-job reaping.
  • Introduced a cluster-safe job runner with kind-based handlers, retries, ownership claiming, and periodic heartbeats.
  • Wired an optional dispatcher into the HTTP server startup/shutdown.
• Bug Fixes
  • Hardened ownership checks so stale/non-owner updates can’t overwrite newer terminal results.
• Tests
  • Added comprehensive runner/dispatcher and persistence/claiming tests, plus updated HTTP test mocks.

Walkthrough

Adds durable Sidekiq-style jobs with persistent claiming, heartbeats, progress updates, runner dispatch, server wiring, and tests for lifecycle and recovery paths.

Changes

Sidekiq background job system

Layer / File(s)	Summary
Sidekiq schema and migration framework/configstore/tables/sidekiq.go, framework/configstore/migrations.go	Defines Sidekiq job statuses and table mapping, and adds the sidekiq table migration and indexes.
ConfigStore and RDB Sidekiq persistence framework/configstore/store.go, framework/configstore/sidekiq.go	Extends the ConfigStore contract and implements create, fetch, claim, heartbeat, progress, terminal, listing, and stale-reaping operations on RDBConfigStore.
Sidekiq runner execution flow framework/sidekiq/sidekiq.go	Defines the runner API and implements enqueue, claim, heartbeat, progress, terminal updates, dispatcher polling, inflight deduplication, and shutdown.
Runner and store tests framework/configstore/sidekiq_test.go, framework/sidekiq/sidekiq_test.go	Adds fake-store runner tests and persistence tests covering creation, claiming, heartbeats, completion, failure, dispatch, recovery, reaping, concurrency, and shutdown.
Server bootstrap and test stubs transports/bifrost-http/lib/config_test.go, transports/bifrost-http/server/server.go	Adds Sidekiq runner lifecycle wiring to the HTTP server and Sidekiq method stubs to the mock config store.

Estimated code review effort: 4 (Complex) | ~45 minutes

Suggested reviewers: danpiths, Pratham-Mishra04

🚥 Pre-merge checks | ✅ 4 | ❌ 1

❌ Failed checks (1 warning)

Check name	Status	Explanation	Resolution
Docstring Coverage	⚠️ Warning	Docstring coverage is 66.67% which is insufficient. The required threshold is 80.00%.	Write docstrings for the functions missing them to satisfy the coverage threshold.

✅ Passed checks (4 passed)

Check name	Status	Explanation
Title check	✅ Passed	The title is concise and accurately summarizes the main change: adding a durable Sidekiq job table and runner with recovery/reaper behavior.
Description check	✅ Passed	The description covers the required template sections and includes summary, changes, test steps, breaking change, security, and checklist details.
Linked Issues check	✅ Passed	Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check	✅ Passed	Check skipped because no linked issues were found for this pull request.

✨ Finishing Touches

📝 Generate docstrings

• Create stacked PR
• Commit on current branch

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch 07-07-feat_add_sidekiq_job_runner

Warning

There were issues while running some tools. Please review the errors and either fix the tool's configuration or disable the tool if it's a critical failure.

🔧 golangci-lint (2.12.2)

level=error msg="[linters_context] typechecking error: pattern ./...: directory prefix . does not contain main module or its selected dependencies"

🔧 ast-grep (0.44.1)

transports/bifrost-http/lib/config_test.go

ast-grep timed out on this file

---

_{Comment @coderabbitai help to get the list of available commands.}

[greptile-apps]

Confidence Score: 5/5

Safe to merge; the new store methods and runner are well-structured, atomic claim fencing is correct, and all previously raised terminal-state guard issues have been addressed.

The two new findings are minor edge cases with no current production impact: an off-by-one in the max-attempts guard that allows one fewer handler invocation than the constant implies, and a StartDispatcher default that would silently override single-node recovery semantics if called (it is not called anywhere today). Core correctness—atomic claiming, heartbeat cancellation on ownership loss, panic recovery, and reaper fencing—is sound.

framework/sidekiq/sidekiq.go — MaxAttempts boundary check and StartDispatcher staleAfter override logic.

Important Files Changed

Filename	Overview
framework/sidekiq/sidekiq.go	New Runner with claim/heartbeat/dispatch lifecycle; off-by-one in MaxAttempts guard and StartDispatcher overrides OSS stale semantics.
framework/configstore/sidekiq.go	Well-fenced CRUD + lifecycle methods; UpdateSidekiqJobProgress still missing AND status=running guard (flagged in prior thread, not yet addressed).
framework/configstore/migrations.go	Adds migrationAddSidekiqTable with dialect-specific DDL for postgres/sqlite and idempotent CREATE TABLE/INDEX.
framework/configstore/tables/sidekiq.go	TableSidekiqJob struct; Kind field carries index:idx_sidekiq_status_updated annotation creating a 3-column GORM index while raw DDL builds a 2-column one (prior comment).
framework/configstore/store.go	Adds 9 sidekiq methods to ConfigStore interface including MarkStaleSidekiqJobsFailed.
framework/sidekiq/sidekiq_test.go	Good coverage for claim exclusivity, panic recovery, heartbeat cancellation, and concurrency bounding; TestMaxAttemptsExhaustedFailsWithoutRunningHandler passes with either >= or > so the off-by-one is not caught.
framework/configstore/sidekiq_test.go	Integration tests against real SQLite store; covers claim fencing, stale re-claim, reaper guard, and progress fencing.
transports/bifrost-http/server/server.go	Creates SidekiqRunner in Bootstrap; no StartDispatcher call so crash recovery remains inactive (previously flagged).

Sequence Diagram

%%{init: {'theme': 'neutral'}}%%
sequenceDiagram
    participant Caller
    participant Runner
    participant Store
    participant Handler

    Caller->>Runner: Enqueue(id, kind, metadata)
    Runner->>Store: "CreateSidekiqJob (status=pending)"
    Runner->>Runner: spawn goroutine (sem slot)
    Runner->>Store: ClaimSidekiqJob (pending→running, attempts++)
    Runner->>Store: GetSidekiqJob (re-fetch cursor)
    Runner->>Runner: startHeartbeat goroutine
    Runner->>Handler: fn(jobCtx, job, progress)
    Handler-->>Store: UpdateSidekiqJobProgress (checkpoint)
    Handler-->>Runner: finalMetadata, err
    alt "err == nil"
        Runner->>Store: CompleteSidekiqJob (running→completed)
    else "err != nil"
        Runner->>Store: FailSidekiqJob (running→failed)
    end
    Runner->>Runner: stopHeartbeat

    Note over Runner,Store: Periodic dispatcher (StartDispatcher)
    Runner->>Store: ListClaimableSidekiqJobs (pending OR stale-running)
    Runner->>Store: ClaimSidekiqJob (stale-running re-claimed)

    Note over Store: Reaper (MarkStaleSidekiqJobsFailed)
    Store->>Store: "running + updated_at < staleBefore → failed"

Loading

%%{init: {'theme': 'base', 'themeVariables': {"darkMode": true, "background": "#0d1117", "primaryColor": "#21262d", "primaryTextColor": "#e6edf3", "primaryBorderColor": "#8b949e", "lineColor": "#8b949e", "textColor": "#e6edf3", "edgeLabelBackground": "#161b22", "actorBkg": "#21262d", "actorBorder": "#8b949e", "actorTextColor": "#e6edf3", "actorLineColor": "#8b949e", "signalColor": "#8b949e", "signalTextColor": "#e6edf3", "noteBkgColor": "#373320", "noteBorderColor": "#d4a72c", "noteTextColor": "#f0e6c0", "labelBoxBkgColor": "#21262d", "labelBoxBorderColor": "#8b949e", "labelTextColor": "#e6edf3", "loopTextColor": "#e6edf3", "activationBkgColor": "#30363d", "activationBorderColor": "#8b949e"}}}%%
sequenceDiagram
    participant Caller
    participant Runner
    participant Store
    participant Handler

    Caller->>Runner: Enqueue(id, kind, metadata)
    Runner->>Store: "CreateSidekiqJob (status=pending)"
    Runner->>Runner: spawn goroutine (sem slot)
    Runner->>Store: ClaimSidekiqJob (pending→running, attempts++)
    Runner->>Store: GetSidekiqJob (re-fetch cursor)
    Runner->>Runner: startHeartbeat goroutine
    Runner->>Handler: fn(jobCtx, job, progress)
    Handler-->>Store: UpdateSidekiqJobProgress (checkpoint)
    Handler-->>Runner: finalMetadata, err
    alt "err == nil"
        Runner->>Store: CompleteSidekiqJob (running→completed)
    else "err != nil"
        Runner->>Store: FailSidekiqJob (running→failed)
    end
    Runner->>Runner: stopHeartbeat

    Note over Runner,Store: Periodic dispatcher (StartDispatcher)
    Runner->>Store: ListClaimableSidekiqJobs (pending OR stale-running)
    Runner->>Store: ClaimSidekiqJob (stale-running re-claimed)

    Note over Store: Reaper (MarkStaleSidekiqJobsFailed)
    Store->>Store: "running + updated_at < staleBefore → failed"

Loading

_{Reviews (7): Last reviewed commit: "feat: respect sidekiq over clustering" | Re-trigger Greptile}

[coderabbitai]

Actionable comments posted: 5

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@framework/configstore/sidekiq.go`:
- Around line 53-71: The status guard in MarkSidekiqJobRunning does not actually
prevent terminal jobs from being updated because the query only filters by id.
Update the WHERE clause in RDBConfigStore.MarkSidekiqJobRunning to also require
a non-terminal/currently runnable status so completed/failed rows cannot be
flipped back to running, and keep the existing RowsAffected error path aligned
with that intent. Make sure the error message and guard behavior match what
Enqueue and RecoverIncomplete expect.

In `@framework/sidekiq/sidekiq.go`:
- Around line 157-165: Guard the terminal update paths in sidekiq job handling
so only the current owner can mark a job complete or failed. In the job
execution flow around fn, CompleteSidekiqJob, and FailSidekiqJob, add a
state/lease compare-and-set check or persist and verify a runner token before
writing the terminal result. Update the store methods and their call sites so a
late runner cannot overwrite another node’s outcome or a reaper-driven failure.
- Around line 196-197: The Runner.StartReaper method should validate both
interval and staleAfter before creating the ticker, since time.NewTicker panics
on non-positive interval and a non-positive staleAfter breaks the stale cutoff
logic. Add upfront checks in StartReaper to return a no-op stop function or
normalize to safe defaults before calling time.NewTicker, using the StartReaper
symbol to keep the fix localized.

In `@transports/bifrost-http/server/server.go`:
- Around line 1825-1827: Guard the Sidekiq runner setup in the server bootstrap
so it only runs when ConfigStore is present, since sidekiq.New and the
reaper/enqueue paths can panic on a nil store. Update the initialization around
s.SidekiqRunner and the related reaper startup in server.go to check
s.Config.ConfigStore first, and skip creating the runner or launching background
goroutines when the store is absent.
- Around line 1825-1827: The Sidekiq startup flow initializes the runner in the
server bootstrap but never restores unfinished work. Update the server
initialization around sidekiq.New in the startup path to call RecoverIncomplete
on s.SidekiqRunner before the service begins processing jobs, so pending/running
jobs from a prior restart are resumed instead of later being marked failed.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro Plus

Run ID: 88cb9a43-ff0a-41ed-9ced-b95297ceabef

📥 Commits

Reviewing files that changed from the base of the PR and between d9577ba and 7701041.

📒 Files selected for processing (8)

• framework/configstore/migrations.go
• framework/configstore/sidekiq.go
• framework/configstore/store.go
• framework/configstore/tables/sidekiq.go
• framework/sidekiq/sidekiq.go
• framework/sidekiq/sidekiq_test.go
• transports/bifrost-http/lib/config_test.go
• transports/bifrost-http/server/server.go

[greptile-apps]

UpdateSidekiqJobProgress is fenced only on runner_id, not on status = running. The reaper (MarkStaleSidekiqJobsFailed) sets status = failed without changing runner_id. So between the reaper firing and the next heartbeat tick (up to 1 minute), the still-running goroutine can call progress(), which hits this WHERE clause, matches the unchanged runner_id, and successfully overwrites the metadata of a job already in failed state. This corrupts the checkpoint cursor stored for future resume. CompleteSidekiqJob and FailSidekiqJob already carry AND status = ? guards for this exact reason — UpdateSidekiqJobProgress needs the same treatment.

Suggested change

	res := s.DB().WithContext(ctx).
	Model(&tables.TableSidekiqJob{}).
	Where("id = ? AND runner_id = ?", id, runnerID).
	Updates(map[string]any{
	"metadata": metadata,
	"updated_at": time.Now(),
	})
	res := s.DB().WithContext(ctx).
	Model(&tables.TableSidekiqJob{}).
	Where("id = ? AND runner_id = ? AND status = ?", id, runnerID, tables.SidekiqStatusRunning).
	Updates(map[string]any{
	"metadata": metadata,
	"updated_at": time.Now(),
	})

[coderabbitai]

Actionable comments posted: 1

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (2)

framework/configstore/sidekiq.go (1)

111-118: 🗄️ Data Integrity & Integration | 🟠 Major | ⚡ Quick win

Fence progress updates to running jobs only.

Line 114 allows a stale owner to update metadata/updated_at after the reaper has marked the same runner_id row failed, because MarkStaleSidekiqJobsFailed does not clear ownership. Match the terminal/heartbeat guards and require status = running.

🛡️ Proposed fix

 	res := s.DB().WithContext(ctx).
 		Model(&tables.TableSidekiqJob{}).
-		Where("id = ? AND runner_id = ?", id, runnerID).
+		Where("id = ? AND runner_id = ? AND status = ?", id, runnerID, tables.SidekiqStatusRunning).
 		Updates(map[string]any{

As per path instructions, “Review persistence, streaming, and shared framework changes for backward-compatible data formats and careful memory ownership.”

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@framework/configstore/sidekiq.go` around lines 111 - 118, Fence sidekiq
progress writes to active jobs only: in UpdateSidekiqJobProgress, add the same
running-state guard used by the other Sidekiq heartbeat/terminal checks so stale
owners cannot update rows after MarkStaleSidekiqJobsFailed has marked them
failed. Update the query in UpdateSidekiqJobProgress to require status = running
alongside id and runner_id, keeping the metadata and updated_at updates
unchanged.

Source: Path instructions

framework/sidekiq/sidekiq.go (1)

149-166: 🩺 Stability & Availability | 🟠 Major | 🏗️ Heavy lift

Avoid parking one goroutine per enqueued job while the semaphore is full.

spawn marks a job inflight, starts a goroutine, then blocks on r.sem. A burst of Enqueue calls can create an unbounded number of parked goroutines even though execution is capped. Prefer a fixed worker/dispatcher path or a bounded internal queue for immediate enqueue wakeups.

As per coding guidelines, Go review should check “bounded goroutines/channels.”

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@framework/sidekiq/sidekiq.go` around lines 149 - 166, The spawn path in
Runner currently creates one goroutine per Enqueue and then parks it on r.sem,
which can lead to unbounded goroutine buildup under load. Refactor Runner.spawn
and the related execution path to use a bounded dispatcher model instead of
blocking inside the goroutine: queue immediate jobs into a fixed-size internal
channel or have a small worker pool consume jobs when concurrency slots free up.
Keep tryMarkInflight, clearInflight, and execute behavior intact while ensuring
the enqueue wakeup path never grows goroutines without bound.

Source: Coding guidelines

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@framework/sidekiq/sidekiq.go`:
- Around line 276-283: StartDispatcher on Runner is overriding an intentionally
empty-runner staleAfter value, which breaks immediate reclaim behavior. Update
Runner.StartDispatcher to preserve a zero staleAfter when Runner was created
with runnerID "" (for example by distinguishing an unset argument from an
explicit empty-runner mode) so New and StartDispatcher do not replace 0 with
StaleAfter; keep the logic localized around Runner.StartDispatcher and the
staleAfter handling used by New.

---

Outside diff comments:
In `@framework/configstore/sidekiq.go`:
- Around line 111-118: Fence sidekiq progress writes to active jobs only: in
UpdateSidekiqJobProgress, add the same running-state guard used by the other
Sidekiq heartbeat/terminal checks so stale owners cannot update rows after
MarkStaleSidekiqJobsFailed has marked them failed. Update the query in
UpdateSidekiqJobProgress to require status = running alongside id and runner_id,
keeping the metadata and updated_at updates unchanged.

In `@framework/sidekiq/sidekiq.go`:
- Around line 149-166: The spawn path in Runner currently creates one goroutine
per Enqueue and then parks it on r.sem, which can lead to unbounded goroutine
buildup under load. Refactor Runner.spawn and the related execution path to use
a bounded dispatcher model instead of blocking inside the goroutine: queue
immediate jobs into a fixed-size internal channel or have a small worker pool
consume jobs when concurrency slots free up. Keep tryMarkInflight,
clearInflight, and execute behavior intact while ensuring the enqueue wakeup
path never grows goroutines without bound.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro Plus

Run ID: fbc442b5-f562-45e3-964f-ddcb1941f94d

📥 Commits

Reviewing files that changed from the base of the PR and between ff342ae and b2bac0e.

📒 Files selected for processing (9)

• framework/configstore/migrations.go
• framework/configstore/sidekiq.go
• framework/configstore/sidekiq_test.go
• framework/configstore/store.go
• framework/configstore/tables/sidekiq.go
• framework/sidekiq/sidekiq.go
• framework/sidekiq/sidekiq_test.go
• transports/bifrost-http/lib/config_test.go
• transports/bifrost-http/server/server.go

🚧 Files skipped from review as they are similar to previous changes (6)

• framework/configstore/store.go
• framework/sidekiq/sidekiq_test.go
• framework/configstore/tables/sidekiq.go
• transports/bifrost-http/lib/config_test.go
• transports/bifrost-http/server/server.go
• framework/configstore/sidekiq_test.go

[coderabbitai]

🩺 Stability & Availability | 🟠 Major | ⚡ Quick win

Preserve the empty-runner immediate-reclaim mode.

New(..., runnerID: "") initializes staleAfter to 0, but StartDispatcher(…, 0) rewrites it to StaleAfter, delaying OSS crash recovery instead of making running jobs immediately claimable as documented.

🛠️ Proposed fix

 	if staleAfter <= 0 {
-		staleAfter = StaleAfter
+		if r.runnerID == "" {
+			staleAfter = 0
+		} else {
+			staleAfter = StaleAfter
+		}
 	}

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

	func (r *Runner) StartDispatcher(interval, staleAfter time.Duration) (stop func()) {
	if interval <= 0 {
	interval = DispatchInterval
	}
	if staleAfter <= 0 {
	staleAfter = StaleAfter
	}
	r.staleAfter.Store(int64(staleAfter))
	func (r *Runner) StartDispatcher(interval, staleAfter time.Duration) (stop func()) {
	if interval <= 0 {
	interval = DispatchInterval
	}
	if staleAfter <= 0 {
	if r.runnerID == "" {
	staleAfter = 0
	} else {
	staleAfter = StaleAfter
	}
	}
	r.staleAfter.Store(int64(staleAfter))

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@framework/sidekiq/sidekiq.go` around lines 276 - 283, StartDispatcher on
Runner is overriding an intentionally empty-runner staleAfter value, which
breaks immediate reclaim behavior. Update Runner.StartDispatcher to preserve a
zero staleAfter when Runner was created with runnerID "" (for example by
distinguishing an unset argument from an explicit empty-runner mode) so New and
StartDispatcher do not replace 0 with StaleAfter; keep the logic localized
around Runner.StartDispatcher and the staleAfter handling used by New.

[Pratham-Mishra04]

Merge activity

• Jul 9, 12:16 PM UTC: A user started a stack merge that includes this pull request via Graphite.
• Jul 9, 12:17 PM UTC: Graphite rebased this pull request as part of a merge.
• Jul 9, 12:18 PM UTC: @Pratham-Mishra04 merged this pull request with Graphite.