test(dummy): SimpleJob's TODO has no consumer — write the sentinel and the test it promised, or delete the job

[ivndev001]

What to build

test/dummy/app/jobs/simple_job.rb:7-9 is def perform(*args); # TODO: write a sentinel to Redis the integration test can poll for.; end. Nothing references the class — git grep SimpleJob returns
only its own definition — so the "integration test" the TODO points at was never written, and the
job is dead weight in the dummy app that every engine test boots.

Implement what the comment describes. perform does
Wurk.redis { |c| c.call('SET', "simple_job:#{args.first}", Process.pid, 'EX', 60) } — one write,
keyed by the first arg. Add test/engine/active_job_roundtrip_test.rb that enqueues
SimpleJob.perform_later("t-#{SecureRandom.hex(4)}") through the dummy app's :wurk adapter under
Wurk::Testing.inline! (docs/testing.md:32-36 documents the mode) and asserts the sentinel key
exists and holds the current pid.

The inline path is real and traced: Client#raw_push short-circuits to Testing.dispatch_push
(lib/wurk/client.rb:286-289) -> inline_push (lib/wurk/testing.rb:89-108) ->
Wurk::ActiveJob::Wrapper -> ActiveJob::Base.execute -> SimpleJob#perform. The dummy app really
does use the adapter (test/dummy/config/application.rb:29).

Three things the executor must get right

1. Write the test. Do not delete the job. An earlier version of this issue offered either
   outcome, selected on whether "an equivalent roundtrip already exists". It does not, and that call
   is now made here rather than left open: test/engine/active_job_sidekiq_adapter_test.rb asserts
   ENQUEUE PAYLOAD SHAPE only — the job class it builds has def perform(*); end and never runs. It
   is not an execution roundtrip. Implement.

2. EngineCase does NOT flush Redis between tests. RedisNamespace — the module carrying the
   FLUSHDB teardown — is included at exactly one site, test/test_helper.rb:196, inside
   class UnitCase < ::Minitest::Test. Wurk::Test::EngineCase (test/engine_test_helper.rb:18-19)
   extends ActionDispatch::IntegrationTest and includes only ::Rack::Test::Methods. So clean up
   the sentinel explicitly, the way the sibling engine test already does
   (active_job_sidekiq_adapter_test.rb:26-34), or rely deliberately on the key's own EX 60 TTL
   and say which you chose. Do not assume a teardown that is not there.

3. Confirm the transaction boundary before writing the assertion. The :wurk adapter declares
   enqueue_after_transaction_commit? => true
   (lib/active_job/queue_adapters/wurk_adapter.rb:40-42), and EngineCase inherits Rails'
   transactional tests with ActiveRecord loaded. Check that perform_later inside a
   never-committing test transaction still reaches the inline path; if it does not, disable
   transactional tests for this case and say so. This is a hazard to verify, not a known defect.

Acceptance criteria

• SimpleJob#perform writes simple_job:<first arg> holding Process.pid with a 60s TTL
• a new engine test enqueues through the dummy app's :wurk adapter under Wurk::Testing.inline!
  and asserts the sentinel key exists and equals the current pid — i.e. it fails if perform
  never runs
• the new test leaves no sentinel key behind for the next test in the file, by explicit cleanup
  or by a stated reliance on the TTL
• grep -n TODO test/dummy/app/jobs/simple_job.rb returns nothing
• test/unit/bench_compare_test.rb is byte-unchanged
• gates green: rubocop, rake test, rake test:parity (bin/check exit 0)

AFK / HITL

AFK.

Affected paths

test/dummy/app/jobs/simple_job.rb, test/engine/active_job_roundtrip_test.rb (new)

Verified against

42cc4e4

[ivndev001]

spec-gate verdict: NEEDS-SPEC

Trace complete: raw_push → Testing.dispatch_push → inline_push → Wrapper.process_job → ActiveJob::Base.execute → SimpleJob#perform. The prescribed mechanism is sound, so no fourth blocker. Final verdict below.

issue: 486
repo: developerz-ai/wurk
bodyRevision: live
verdict: NEEDS-SPEC
checklist:
  - id: C1
    name: No-op against the stated problem
    status: pass
    evidence: |
      Neither branch is inert. Implement branch traces clean end-to-end:
      /home/ivann/ws/developerz.ai/Projects/wurk/lib/wurk/client.rb:286-289 (raw_push short-circuits
      to Testing.dispatch_push) -> lib/wurk/testing.rb:89-108 (inline_push calls
      process_job) -> lib/wurk/active_job/wrapper.rb:19-21 (ActiveJob::Base.execute)
      -> SimpleJob#perform. Dummy app really does use the adapter:
      test/dummy/config/application.rb:29 `config.active_job.queue_adapter = :wurk`.
      Delete branch removes genuinely dead code. Text/fixture carve-out also applies.
  - id: C2
    name: Standing ruling reversed without authorization
    status: pass
    evidence: |
      No posture reversal proposed. Draft quotes no rule, proposes no config or policy
      change, and nothing in CLAUDE.md's "Never" list or .dz/pipeline/agent-pipeline.json
      is overturned. No authorization artifact required.
  - id: C3
    name: Repo-wide lockout
    status: pass
    evidence: |
      /home/ivann/ws/developerz.ai/Projects/wurk/.dz/pipeline/agent-pipeline.json declares
      merge.reviewGate "ci-only" with NO policy.module, so isPolicyRepo is false and the
      review-gate-conflict refusal cannot fire. Draft changes no config, no required check,
      no ruleset. Nothing can make the gate refuse universally.
  - id: C4
    name: Live-test provenance
    status: pass
    evidence: |
      Non-deploying slice: touches test/dummy (a fixture app) and adds a test; no deployed
      or runtime behavior changes. Repo commits policy.defaultTier "GREEN" in
      .dz/pipeline/agent-pipeline.json, so the fenceless carve-out genuinely resolves to
      NOT_REQUIRED. No fence demanded — inventing one would only add signalling hazard.
  - id: C5
    name: Checkable acceptance
    status: fail
    evidence: |
      (1) AC#2 blesses two OPPOSITE artifacts ("Either a new engine test ... or
      simple_job.rb is removed"). The selector — "if an equivalent roundtrip already
      exists" — is undefined. I resolved it: test/engine/active_job_sidekiq_adapter_test.rb
      asserts ENQUEUE PAYLOAD SHAPE only; its job body is `def perform(*); end` (:67) and is
      never executed. So it is NOT an execution roundtrip and the delete branch should not
      fire — but an unattended agent reading a file named active_job_sidekiq_adapter_test.rb
      containing test_perform_later_enqueues_canonical_wrapper_payload could plausibly call
      it equivalent and delete instead. Both outcomes pass AC, so no stranger can verify the
      right thing was built.
      (2) AC#1 `grep -rn TODO lib app test frontend/src` returns nothing — is unsatisfiable
      on origin/main (42cc4e4): 5 matches, 4 of them in test/unit/bench_compare_test.rb:146-157.
      (3) No GUARANTEED mutation-sensitive criterion: the delete branch asserts no behavior,
      and AC#3 ("gates green / bin/check exit 0") is the "suite is green" non-criterion.
  - id: C6
    name: Draft's own evidence
    status: fail
    evidence: |
      STALE ON ARRIVAL — "Use the engine test base ... teardown flushes the DB so no explicit
      cleanup is needed" is false for the layer prescribed. The only FLUSHDB teardown is
      test/support/redis_namespace.rb:9-10, included ONLY at test/test_helper.rb:196 inside
      `class UnitCase < ::Minitest::Test` (:195). EngineCase
      (test/engine_test_helper.rb:18-19) extends ActionDispatch::IntegrationTest and includes
      only ::Rack::Test::Methods. Verified this was ALREADY true at the draft's own stamped
      revision c346bc9, and engine_test_helper.rb has not changed since 463f55a (2026-08-08),
      three weeks before filing — so it never matched HEAD. Corroborated by the existing
      engine test doing explicit DEL/SREM cleanup (active_job_sidekiq_adapter_test.rb:26-34).
      Everything else resolves exactly: simple_job.rb:7-9 quoted byte-exact; test_helper.rb:21-27
      is precisely the per-worker Redis DB block; docs/testing.md:32-36 is precisely the
      three-modes table incl. the :inline row; Wurk.redis (lib/wurk.rb:139) and
      Wurk::Testing.inline! (lib/wurk/testing.rb:28) both exist.
  - id: C7
    name: Fail-open
    status: pass
    evidence: |
      NOT hard-class by function: test/dummy/app/jobs/simple_job.rb and a new test/engine/*
      file decide nothing about whether a PR may merge, what review it carries, how a diff is
      classified, whether a live test is required, or whether a revert arms. Limbs (a)/(b)
      therefore do not arise, and the absent `hitl` label has nothing to waive. The prescription
      as written removes no blocker, widens no accept condition, relaxes no fail-closed default.
      The AC#1 collateral hazard is real but is a consequence of the C5 defect, recorded in
      notes rather than double-counted here.
  - id: C8
    name: Blast radius and reversibility
    status: pass
    evidence: |
      One concern, 2 files, one PR's worth. Fully reversible by reverting the merge commit;
      no repo settings, rulesets, secrets, other issues' state, or deletions the pipeline
      cannot undo. No credential is minted, rotated, or read, so the HITL secret trigger
      does not fire.
  - id: C9
    name: Work is real
    status: pass
    evidence: |
      Limb (a): multiple citations resolve independently — simple_job.rb:7-9 exists and matches,
      and the "nothing references SimpleJob" claim verifies (`git grep SimpleJob origin/main`
      returns only the class's own definition line). The dead-weight problem is real.
      Limb (b): draft carries no `## Parent` section, so this limb is unaffected.
blockers:
  - criterion: C5
    defect: >-
      AC#2 accepts two opposite outcomes (write the test OR delete the job), so no reviewer can
      verify the executor built the right thing; the "equivalent roundtrip already exists"
      selector is undefined and the existing adapter test is enqueue-shape-only, not execution.
    fix: >-
      Pick ONE outcome. If keeping the either/or, restate the selector as a checkable predicate —
      e.g. "delete only if an existing engine test asserts SimpleJob#perform actually executed;
      test/engine/active_job_sidekiq_adapter_test.rb does not, so implement." Preferably drop the
      delete branch outright and require the test.
  - criterion: C5
    defect: >-
      AC#1 ("grep -rn TODO lib app test frontend/src returns nothing") is unsatisfiable on
      origin/main without gutting test/unit/bench_compare_test.rb's deliberate #487 regression
      guard — a direct collision with the repo's test-integrity rule.
    fix: >-
      Scope the grep to the affected path: "grep -n TODO test/dummy/app/jobs/simple_job.rb returns
      nothing". Better, replace it with a presence assertion (the sentinel key is written and holds
      the pid), since a bare absence-grep is satisfiable by deleting correct text.
  - criterion: C6
    defect: >-
      "teardown flushes the DB so no explicit cleanup is needed" is false for EngineCase, which
      does not include RedisNamespace. Stale on arrival — already false at the draft's own stamped
      revision.
    fix: >-
      Drop that sentence and either prescribe explicit teardown cleanup (as the sibling engine test
      does) or state plainly that the sentinel's own `EX 60` TTL is the cleanup mechanism.
notes: >-
  Audited the LIVE body (no userContentEdits pinned by the caller). No comments on the issue.
  Labels are area/backend, size/1h, afk — NO `hitl`, so C7's attended waiver was unavailable and
  was not applied. Weighted for autonomy accordingly: .dz/maintainer/maintainer.yml sets
  pr.auto_merge: true with required_approving_review_count 0, so a READY here really would let an
  unattended agent build and merge with no human reading the diff. That is why AC#2's either/or is
  disqualifying rather than merely untidy — under an auto-merge lane there is no reviewer to catch
  the wrong branch.

  DRIFT vs STALE-ON-ARRIVAL, checked rather than assumed, and the two citations split:
  (a) The TODO-free claim is DRIFT and is only a NOTE. It was TRUE when filed — the four extra
  matches in test/unit/bench_compare_test.rb landed in 6635e0f (2026-09-03T10:49:54Z, "drop dead
  (TODO)-label skip, closes #487"), a day AFTER the issue was created (2026-09-02T16:41:24Z) and
  after the stamp c346bc9 (2026-09-02T01:56:14Z). The core mechanism (SimpleJob has no consumer)
  survives intact. The draft is not at fault here; the repo moved.
  (b) The teardown claim is STALE ON ARRIVAL and is the leg carrying the C6 FAIL — it never matched
  the revision the author stamped. Per the skill's own consequence, an author who did not verify
  against HEAD once warrants re-opening the rest; I did re-open all of them, and every remaining
  citation is exact.

  CONCRETE HARM behind blocker 2, recorded here rather than as a separate C7 failure so one defect
  is not counted twice: the guard AC#1 would push an executor to delete is
  test_todo_labelled_bench_is_compared_not_skipped, which pins that a bench labelled "(TODO)" still
  trips the >5% regression gate. That gate blocks merge under CLAUDE.md pillar 3, so satisfying
  AC#1 literally is a fail-open path into a merge-gating guard — reached by accident, not by
  prescription, which is why C7 stays pass.

  THE FOUR CONVENTIONS THE CALLER NAMED:
  1. Tests never edited to make them pass — VIOLATED in effect by AC#1 (blocker 2 above); this is
     the repo-native framing of that blocker.
  2. Parity tests are oracles — draft does not touch test/parity/. Clean.
  3. Redis never mocked in integration/parity — the prescription uses real Redis
     (Wurk.redis { |c| c.call('SET', ...) }) and mocks nothing. Compliant.
  4. SimpleCov line AND branch >=90% on lib/ — not a hazard either way. test_helper.rb:12 sets
     add_filter '/test/', which covers test/dummy/**, so neither branch moves lib/ coverage; the
     implement branch can only exercise more of lib/ (adapter, testing, wrapper).

  UNVERIFIED CAVEAT for whoever fixes this draft, flagged because I did not trace it and it is not
  load-bearing for the verdict: the :wurk adapter declares enqueue_after_transaction_commit? => true
  (lib/active_job/queue_adapters/wurk_adapter.rb:40-42), and EngineCase inherits Rails'
  transactional tests with ActiveRecord loaded. Whether perform_later inside a never-committing test
  transaction still reaches the inline path is worth the executor confirming before writing the
  assertion. Raised as a hazard, not asserted as a defect.

  REPO-CONFIG findings: none. The repo is correctly configured for this slice — policy.defaultTier
  "GREEN" is committed, so the C4 carve-out was granted on the repo's own declaration rather than
  waived. The precheck's stamp requirement is satisfied: c346bc9 resolves and is an ancestor of
  origin/main (42cc4e4).

  All three blockers are cheap draft edits, none require code investigation by the author, and the
  underlying work is real and worth doing. This is a NEEDS-SPEC on verifiability, not on merit.

Verdict: NEEDS-SPEC. The work is real and the draft is unusually well-cited — the problem is that it cannot be verified as done.

The disqualifying defect is that the acceptance criteria bless two opposite artifacts. On a repo whose .dz/maintainer/maintainer.yml sets pr.auto_merge: true with zero required approvals, "write the test or delete the job" means an unattended agent can merge either outcome and both pass the gate. I resolved the ambiguity myself — /home/ivann/ws/developerz.ai/Projects/wurk/test/engine/active_job_sidekiq_adapter_test.rb asserts enqueue payload shape only, its job body is def perform(*); end and never runs — so the delete branch should not fire. But the draft delegates that call to the executor with no criterion.

Two supporting blockers, both cheap to fix:

• grep -rn TODO lib app test frontend/src returns nothing is now unsatisfiable without gutting test_todo_labelled_bench_is_compared_not_skipped, the deliberate chore(bench-compare): drop the "(TODO)" stub-bench skip that no bench can trigger and no test covers #487 guard in /home/ivann/ws/developerz.ai/Projects/wurk/test/unit/bench_compare_test.rb. That collides head-on with the repo's test-integrity rule, and that guard protects a merge-gating bench check.
• "teardown flushes the DB so no explicit cleanup is needed" is false for the layer prescribed: RedisNamespace#teardown is included only in UnitCase (test/test_helper.rb:196), while EngineCase includes only Rack::Test::Methods (test/engine_test_helper.rb:18-19).

Two things worth flagging that cut for the draft: the TODO claim was accurate when filed and broke a day later via 6635e0f — that is drift, so it is a NOTE, not a mark against the author. And the prescribed inline mechanism genuinely works; I traced raw_push → dispatch_push → inline_push → Wrapper#perform → ActiveJob::Base.execute rather than trusting the prose. The teardown claim is the one that was wrong from the start, which is why it carries the C6 failure.

run: a5cd6523630dd93cc
provider: anthropic
model: claude-opus-5

[developerz-ai]

Issue scoped and dispatched to the maintainer's coding agent.

🤖 Posted by developerz.ai — the maintainer agent, not a human.

[developerz-ai]

test(dummy): SimpleJob's TODO has no consumer — write the sentinel and the test it promised

• Picked up
• Surveying the repo — 2026-09-17 18:55 UTC
• Working — 2026-09-17 18:56 UTC
• Pull request opened
• Done

Stopped — this needs a human. Nothing was merged.
Reason: [team] verify failed and the baseline fails it too (./bin/check, exit 1) — this box's baseline is red, so the diff was never graded; not spending an attempt on it the diff run's tail: ...............................................................................................................................…

1h03m · 157 tool calls · 26 messages

Sessions: coding run

---

🤖 developerz.ai maintainer bot — Silent Ibis (developerz-ai[bot]) · model MiniMax-M3 on router.ai.developerz.ai

[ivndev001]

spec-gate verdict: READY

Confirmed: include RedisNamespace appears at exactly one site (test/test_helper.rb:196, inside UnitCase at :195). Every other hit is a comment or the module definition. No inclusion reaches ActiveSupport::TestCase, so EngineCase genuinely does not get the FLUSHDB teardown — the draft's corrected claim #2 holds, universal quantifier included.

issue: 486
repo: developerz-ai/wurk
bodyRevision: live
verdict: READY
checklist:
  - id: C1
    name: No-op against the stated problem
    status: pass
    evidence: |
      Not inert. `SimpleJob#perform` goes from an empty body to a real Redis write, and a new
      execution test is added where none existed. Traced the inline path through code rather
      than prose: lib/wurk/client.rb:282-289 (`raw_push` short-circuits on
      `::Wurk::Testing.enabled?` to `dispatch_push`) -> lib/wurk/testing.rb:89-91
      (`dispatch_push`) -> :105-108 (`inline_push` does
      `::Object.const_get(payload['class'].to_s).process_job(payload)`) ->
      lib/wurk/worker.rb:276-287 (`process_job` -> `execute_job` -> `worker.perform(*args)`) ->
      lib/wurk/active_job/wrapper.rb:19-21 (`::ActiveJob::Base.execute`) -> `SimpleJob#perform`.
      Adapter is really wired: test/dummy/config/application.rb:29
      `config.active_job.queue_adapter = :wurk`.
  - id: C2
    name: Standing ruling reversed without authorization
    status: pass
    evidence: |
      No posture reversal, so no authorization artifact is required. CLAUDE.md's "Never" list is
      untouched: the sentinel `simple_job:<arg>` is a fixture-app key, not Wurk's wire schema
      (no queue/schedule/JSON field changes); Redis is real, never mocked; no license check or
      tier flag. The repo's test-integrity rule ("never modify tests to make them pass") is
      actively honored rather than reversed — AC#5 pins test/unit/bench_compare_test.rb
      byte-unchanged, protecting the #487 guard at :146-160.
  - id: C3
    name: Repo-wide lockout
    status: pass
    evidence: |
      origin/main:.dz/pipeline/agent-pipeline.json declares merge.reviewGate "ci-only" and NO
      policy.module, so `isPolicyRepo` is false and `decideMerge`'s `posture === "ci-only"`
      refusal cannot fire. No legacy root .agent-pipeline.json exists. The draft changes no
      config, no required status check, no branch ruleset, and adds no fail-closed branch.
  - id: C4
    name: Live-test provenance
    status: pass
    evidence: |
      Non-deploying slice — a fixture job under test/dummy/ plus one new test file; no deployed
      or runtime behavior changes. The repo commits policy.defaultTier "GREEN" in
      .dz/pipeline/agent-pipeline.json, so the fenceless carve-out genuinely resolves to
      NOT_REQUIRED rather than parking. No fence demanded; inventing one would only import the
      signalling hazard for no benefit. No REPO-CONFIG finding.
  - id: C5
    name: Checkable acceptance
    status: pass
    evidence: |
      All three prior C5 legs are closed, verified rather than taken:
      (a) EITHER/OR GONE. Body states "Write the test. Do not delete the job." and justifies it;
      AC#1 and AC#2 both require the job to exist and execute, so the delete branch is closed.
      The justification checks out: test/engine/active_job_sidekiq_adapter_test.rb builds its job
      with `def perform(*); end` (:67) and asserts only the LRANGE'd payload shape (:45-61) — it
      is not an execution roundtrip.
      (b) GREP SCOPED. AC#4 is now `grep -n TODO test/dummy/app/jobs/simple_job.rb`, which returns
      exactly one match today (simple_job.rb:8) and nothing after the fix. I re-derived all five
      repo-wide TODO matches myself: 1 in simple_job.rb, 4 in test/unit/bench_compare_test.rb
      :146-157. The collision with the #487 guard is eliminated, and AC#5 additionally pins that
      file byte-unchanged.
      (c) MUTATION-SENSITIVE CRITERION PRESENT. AC#2 names the behavior ("asserts the sentinel key
      exists and equals the current pid — i.e. it fails if `perform` never runs") and is red
      against today's code, where `perform` writes nothing. AC#6 ("gates green") is the
      suite-is-green non-criterion but is not load-bearing.
      Brittleness: no bare absolute counts; every line reference is symbol-anchored.
  - id: C6
    name: Draft's own evidence
    status: pass
    evidence: |
      Every citation opened at origin/main (42cc4e4), which is also the body's own
      `## Verified against` stamp, and every one resolves exactly:
      simple_job.rb:7-9 (quote byte-exact, rendered inline with `;`); `git grep SimpleJob` returns
      only :4, its own class definition; client.rb:286-289; testing.rb:89-108 (dispatch_push at 89,
      inline_push 105-108); test/dummy/config/application.rb:29; docs/testing.md:32-36 (the
      three-modes table incl. the `:inline` row); test_helper.rb:196; engine_test_helper.rb:18-19;
      active_job_sidekiq_adapter_test.rb:26-34 (the DEL/SREM teardown); wurk_adapter.rb:40-42
      (`def enqueue_after_transaction_commit?` / `true` / `end`).
      The prior gate's C6 FAIL is genuinely repaired, not merely reworded: the false "EngineCase
      teardown flushes the DB" claim is replaced by its correct inverse, and I re-derived the
      corrected claim independently INCLUDING its universal quantifier —
      `git grep -n RedisNamespace origin/main` shows `include RedisNamespace` at exactly one site
      (test_helper.rb:196, inside `class UnitCase < ::Minitest::Test` at :195); every other hit is
      a comment or test/support/redis_namespace.rb:8 itself. Nothing includes it into
      ActiveSupport::TestCase, so EngineCase really does not inherit the FLUSHDB teardown.
      No drift and no stale-on-arrival citations found in this revision.
  - id: C7
    name: Fail-open
    status: pass
    evidence: |
      Not hard-class by FUNCTION: test/dummy/app/jobs/simple_job.rb (a fixture job nothing
      references) and a new test/engine/* file decide nothing about whether a PR may merge, what
      review it carries, how a diff is classified, whether a live test is required, or whether a
      revert arms. Being SUBJECT to a required check is not DECIDING one. Limbs (a)/(b) therefore
      do not arise. Direction is strengthening, not weakening: the draft adds a test and removes
      no blocker, widens no accept condition, relaxes no fail-closed default, shortens no wait,
      and makes no absent signal count as permission. The one genuinely gate-deciding file nearby
      — bench_compare_test.rb's `test_todo_labelled_bench_is_compared_not_skipped` (:150-160),
      which pins that a "(TODO)"-labelled bench still trips the merge-gating >5% regression check
      — is pinned byte-unchanged by AC#5, so the prior revision's collateral fail-open path into
      it is closed. No `## Blocked by` section, correctly: both files are independent of any other
      issue landing first.
  - id: C8
    name: Blast radius and reversibility
    status: pass
    evidence: |
      One concern, two files (one modified, one new), one PR's worth. Fully reversible by
      reverting the merge commit; touches no repo settings, no rulesets, no secrets, no other
      issues' bodies or labels, and deletes nothing. No credential is minted, rotated, or read,
      so the HITL secret trigger does not fire. No auto-revert can arm on a wrong outcome either:
      the draft carries no `## Live test` fence and the repo resolves GREEN via
      policy.defaultTier, so `runLiveTest` returns NOT_REQUIRED.
  - id: C9
    name: Work is real
    status: pass
    evidence: |
      Limb (a): many citations resolve independently — the full list under C6 — and the stated
      problem verifies rather than being asserted: `git grep SimpleJob origin/main` returns only
      the class's own definition line, and `git grep -i simple_job origin/main` returns nothing,
      so there is no snake_case or dynamic consumer either. The TODO at simple_job.rb:8 is real
      and its promised test genuinely does not exist (test/engine/ contains no roundtrip file).
      Limb (b): the draft carries no `## Parent` section, so this limb is unaffected.
blockers: []
notes: >-
  Audited the LIVE body (the caller pinned no revision). This is a RE-GATE; I scored the current
  text on its own merits and re-derived every claim rather than diffing against the prior verdict.
  All four repairs the rewrite claims were checked at source and all four hold: (1) the either/or
  is genuinely collapsed to one outcome and the justification is true — the sibling test's job body
  really is `def perform(*); end` at active_job_sidekiq_adapter_test.rb:67 and it asserts only
  LRANGE payload shape; (2) the TODO grep really is scoped to the single file and AC#5 now
  additionally protects test/unit/bench_compare_test.rb byte-for-byte; (3) the false
  EngineCase-flushes-Redis claim really is replaced by the correct inverse, and I verified the
  "exactly one inclusion site" universal with `git grep -n RedisNamespace origin/main` rather than
  reading one line; (4) the `enqueue_after_transaction_commit?` hazard really is present and is
  framed honestly as something to confirm, not as a known defect.

  AUTONOMY WEIGHTING. Labels are area/backend, size/1h, afk with NO `hitl`, so C7's attended waiver
  was unavailable and was not applied. .dz/maintainer/maintainer.yml sets `pr.auto_merge: true`
  and its own comments record `required_approving_review_count: 0`, and
  .dz/pipeline/agent-pipeline.json sets `merge.standingAuthorization: true`. A READY here really
  does authorize build-and-merge with no human reading the diff, and I scored it on that basis.
  What makes that acceptable on this draft is that the deliverable is now single-valued and AC#2
  is red today, so the required `test + coverage (latest ruby/rails)` check is a real net rather
  than a formality.

  FOUR EXECUTOR NOTES — none is a blocker, none needs a draft edit, all are cheap to get wrong:
  1. `Wurk::Testing.inline!` HAS A GLOBAL FORM. docs/testing.md:41-42 (just outside the range the
     draft cites) states the no-block form sets the mode PROCESS-GLOBALLY while the block form is
     thread-local and scoped. Use the block form, or reset in teardown; a leaked global `:inline`
     would execute jobs other tests only expect to enqueue. It would show up as a red suite rather
     than a silent bad merge, which is why it is a note and not a blocker.
  2. AC#3's headline is internally inconsistent with its own second branch — under the stated
     `EX 60` TTL reliance the key IS left behind for up to 60s, contradicting "leaves no sentinel
     key behind". Still verifiable (read the test, see which mechanism was chosen and whether it is
     stated) and harmless in practice, since the `SecureRandom.hex(4)` suffix makes a leftover key
     non-colliding. Loose wording, not an unfalsifiable criterion.
  3. AC#4 is a bare absence-grep, satisfiable in principle by deleting correct text. Recorded as a
     NOTE per C5 rather than a FAIL because it is not the sole criterion covering the change —
     AC#1 and AC#2 are presence assertions and the body explicitly forbids deleting the job.
  4. Redis returns the sentinel as a STRING, so the assertion must compare against
     `Process.pid.to_s`, not the Integer.

  THE TRANSACTION HAZARD, as far as it is checkable read-only. Both halves of the draft's claim
  verify structurally: the adapter declares `enqueue_after_transaction_commit? => true`
  (wurk_adapter.rb:40-42, exact), and EngineCase does inherit Rails' transactional tests —
  engine_test_helper.rb:13 requires `rails/test_help`, application.rb:8 requires
  `active_record/railtie`, and `sqlite3` is in the Gemfile's test group, so ActiveRecord::TestFixtures
  reaches ActionDispatch::IntegrationTest with a live connection. Whether Rails 8.1 (CI pins
  RAILS_VERSION "8.1") still consults the adapter method, and whether the test transaction's
  `joinable: false` makes the enqueue fire immediately anyway, I could NOT settle read-only: no Ruby
  gems are installed on this box. This is scored not-load-bearing because the AC pins the outcome
  either way — if the deferral does block the inline path the new test goes red and the required
  status check stops the merge, so the failure mode is a parked PR, not a bad one.

  REPO-CONFIG findings: none. The repo is correctly configured for this slice — policy.defaultTier
  "GREEN" is committed, so the C4 carve-out was granted on the repo's own declaration rather than
  waived. The `## Verified against` stamp 42cc4e42d20ca4ddfb2dfb8d7d02cc481735e986 is exactly
  origin/main's tip, so every citation was checked against the same tree the author stamped.

  ATTENDANCE, recorded per C2's standing caveat: no attendance test was performed or relied on, and
  none was needed — this draft requires no authorization artifact at all, so the unrestorable
  two-hop chain (agent-pipeline #872) does not bear on the verdict.

  This is a READY on a draft that failed twice-over on verifiability and was repaired at the
  specific points that failed. The underlying work is real, single-valued, and the acceptance
  criteria would catch an executor that built the wrong thing.

Verdict: READY.

Key files (all read at origin/main = 42cc4e42d20ca4ddfb2dfb8d7d02cc481735e986, never the working tree, which is on docs/474-bin-check-exit-contract):

• /home/ivann/ws/developerz.ai/Projects/wurk/test/dummy/app/jobs/simple_job.rb
• /home/ivann/ws/developerz.ai/Projects/wurk/test/engine/active_job_sidekiq_adapter_test.rb
• /home/ivann/ws/developerz.ai/Projects/wurk/test/engine_test_helper.rb
• /home/ivann/ws/developerz.ai/Projects/wurk/test/test_helper.rb
• /home/ivann/ws/developerz.ai/Projects/wurk/test/support/redis_namespace.rb
• /home/ivann/ws/developerz.ai/Projects/wurk/lib/wurk/testing.rb, lib/wurk/client.rb, lib/wurk/worker.rb, lib/wurk/active_job/wrapper.rb
• /home/ivann/ws/developerz.ai/Projects/wurk/lib/active_job/queue_adapters/wurk_adapter.rb
• /home/ivann/ws/developerz.ai/Projects/wurk/test/unit/bench_compare_test.rb
• /home/ivann/ws/developerz.ai/Projects/wurk/.dz/pipeline/agent-pipeline.json, .dz/maintainer/maintainer.yml

Three things worth your attention beyond the verdict:

1. All four claimed repairs are real, and I checked the one the advisor flagged as the likeliest place for a rewrite to introduce a new defect — the draft's new claim that RedisNamespace is included at "exactly one site" is a universal, and I had initially only confirmed the one site rather than the absence of others. git grep -n RedisNamespace origin/main confirms it: one include, at test_helper.rb:196 inside UnitCase, nothing reaching ActiveSupport::TestCase.

2. One hazard the draft does not name: docs/testing.md:41-42 — one line past the range the draft cites — says the no-block Wurk::Testing.inline! sets the mode process-globally. A leaked global would make jobs other tests only enqueue actually run. It is a note rather than a blocker because it surfaces as a red suite, and test + coverage (latest ruby/rails) is a required status check.

3. What I could not settle read-only: whether Rails 8.1 still honors the adapter's enqueue_after_transaction_commit?, and whether the test transaction's joinable: false short-circuits it. No Ruby gems are installed on this box. Scored not-load-bearing because the acceptance criterion pins the outcome either way — if the deferral blocks the inline path, the new test goes red and the PR parks rather than merging wrong.

run: acf5873d4f67fd0ca
provider: anthropic
model: claude-opus-5

[ivndev001]

Correction to the audit above. Not a new gate record — the READY assessment is unchanged and all
nine checklist statuses stand. This corrects one claim inside it and settles the one question it
left open.

What was wrong: the audit stated "no Ruby gems are installed on this box." That is false. Rails
8.1.3.1 is installed under ~/.local/share/mise/installs/ruby/3.4.10/..., and wurk's own dummy-app
bundle is vendored under test/dummy/vendor/bundle/ruby/3.4.0/gems/. The search that produced the
claim used -maxdepth 8; the mise path is roughly eleven levels deep. A bounded search returning
empty was converted into "it does not exist", which is the actual error here.

What that unblocks: the transaction hazard the body asks the executor to confirm is now settled,
and it resolves in the draft's favour.

On ActiveJob 8.1.3.1 — the version CI pins via RAILS_VERSION="8.1" — the adapter's
enqueue_after_transaction_commit? is dead code. Grepping all of activejob-8.1.3.1/lib/ finds
no call to any adapter-side method, and queue_adapters/abstract_adapter.rb does not mention it.
The governing switch is the job-class attribute enqueue_after_transaction_commit
(enqueuing.rb:53, default: false), read at enqueue_after_transaction_commit.rb:26. Railties'
application/configuration.rb has zero references, so no load_defaults version — including the
dummy app's 7.1 — flips it, and railtie.rb:60-65 explicitly excludes it from global application
("This config can't be applied globally"). So raw_enqueue takes the else super branch, enqueues
immediately, and reaches the inline path. The prescribed test works as written, with no
transactional-tests workaround.

The hazard was still worth raising, and the body's framing of it was right. The Gemfile floats to
gem 'rails', '>= 7.1' when RAILS_VERSION is unset — a local dev run. On Rails 7.2/8.0 the adapter
method was consulted, and ActiveRecord.after_all_transactions_commit branches on
all_open_transactions being empty rather than on joinable?, so the deferral would attach to a
transaction that never commits and the job would never run. Real off the CI pin, inert on it. Point
3 of the body stays as written; an executor hitting a silent no-op locally now knows why.

This does not disturb the evidence check: the body cited wurk_adapter.rb:40-42 accurately and
claimed only that the adapter declares the method, which is true. It never claimed Rails consults
it.