[FEATURE] Reviewer slice-awareness: a sliced Workload is judged against the whole issue and always fails

Open
#1,679 0 comments 0 reactions 0 assignees View on GitHub

Maintainers usually reply within 1 day

Nobody has claimed this yet.

Assessment

Difficulty
5/5
Estimated time
Over a week
Newbie friendliness
35/100
Issue type
Feature
Clarity
Mostly clear
Activity status
Quiet
Tech stack
go, kubernetes

Research direction

Start by tracing how spec.intent reaches the coder and how the reviewer builds its prompt from the issue body; the issue does not name files or tests. Compare the proposed scope field with passing intent through to identify where slice boundaries can enter the review task. Done means the reviewer judges a Workload against its assigned slice and does not flag work outside that slice as incomplete.

Written by the indexing model from the issue text.

Description

enhancement

Feature Description

Give the reviewer a way to know which part of an issue the task under review is
responsible for, so that splitting one issue across several Workloads does not
guarantee a NO-GO on every slice after the first.

Problem Statement

The reviewer fetches and reviews against the issue body. A Workload's
spec.intent is visible to the coder and invisible to the reviewer. So when one
issue is deliberately sliced across Workloads, the reviewer measures each slice
against the whole issue and correctly reports it incomplete.

Observed live on 2026-08-27. #1674 asks to wire the coder stage, wire the gate
stage, and record evidence. It was split into three Workloads, each intent
carrying an explicit scope fence, for example:

SCOPE: slice 1 covers the coder stage (Rule 1). DO NOT implement that here.

wl-1674-s2a-gate-claim did exactly what it was told and was rejected:

REQUEST-CHANGES: #1674 asks to wire both coder and gate stages into the
cross-stage contradiction detector; diff only implements gate stage, leaving
coder stage unaddressed. Missing coder-stage wiring violates the issue's scope.

findings: [ blocker: "Issue #1674 explicitly requires wiring both coder and gate
stages. This diff only implements gate stage wiring ..." ]

The finding is accurate about the issue and wrong about the task. No coder
behaviour can satisfy it, so the revision cycle it opened could not converge.

Why this matters

Slicing is the mitigation for the "locally correct, globally incomplete" failure
mode, and it works: the same #1674 split turned a 30-minute EditFreeStreak
death into a 7-minute GO once the evidence slice was given a concrete shape. But
slicing currently costs a guaranteed false NO-GO per slice plus the wasted
revision run behind it.

It also interacts with #1678: a false NO-GO with no actionable findings is
exactly the shape that opens an unconvergeable iteration.

Proposed Solution

Carry the slice boundary into the review task and have the reviewer judge
against it rather than against the raw issue. Roughly, in preference order:

  1. A first-class field, e.g. spec.pipeline[].payload.scope or a Workload-level
    spec.sliceOf, rendered into the reviewer prompt as "this task owns X; the
    rest of the issue is out of scope for this review".
  2. Failing that, pass spec.intent (or a scope excerpt of it) to the reviewer
    the way it already reaches the coder.

Either way the reviewer should be able to distinguish "did not do the whole
issue" from "did not do its slice", and only the second is a finding.

Alternatives Considered

  • Write one issue per slice. Works, but fragments the tracker and loses the
    parent context that makes the slices legible.
  • Tell the coder to restate its scope in the PR body. Reviewer-visible, but
    it is the coder asserting its own boundary, which is exactly the kind of
    self-certification the harness rails exist to distrust.

Additional Context

Related: #1678 (empty demotions opening unconvergeable iterations), #1548
(making agent verdicts verifiable).

Dominant language
Go
Stars
232
Forks
37
Avg merge
21h 42m
Merged PRs (30d)
244

Getting set up

Open in Codespaces

Starts the project's dev container in your browser, under your own GitHub account.

First steps

  1. Read the whole issue, then the project's contributing guide.
  2. Comment on the issue to say you are picking it up — it saves two people doing the same work.
  3. Fork the repository and make your change on a branch.
  4. Open a pull request that references the issue number.

More from defilantech/LLMKube

All issues in defilantech/LLMKube

Similar issues

More Go issues

Get new issues in your inbox

A short digest of beginner-friendly GitHub issues.