go-gitreins-judge-compaction-loop

Answer

Root cause

gitreins judge builds a per-stage EvalCap from the pipeline config. When a tier2 stage declares only max_iterations, the token caps stay at their unset sentinel -1. The compaction decision was computed as:

threshold := cap.TotalTokens - usedTokens
return usedTokens > threshold   // TotalTokens == -1 → threshold is always negative → always true

With TotalTokens = -1, the threshold is -1 - used, so used > threshold is true even for an empty conversation. Compaction fires at the start of every iteration, bounded by the hard cap of 3 (maxCompactions), after which the judge burns its budget and stalls instead of producing a verdict. On PG-heavy repos tier1 already consumes ~300s, so the foreground MCP call hangs entirely.

Fix (Go, compaction.go)

Two-part fix: (1) repair unset caps at config-load time, (2) make the compaction decision refuse to fire on an unset cap, and (3) fail fast if a real compaction loop still occurs.

// 1) Config-load repair: a stage that sets only MaxIterations gets sane
//    EvalCap defaults instead of -1 sentinels.
var DefaultCap = TokenCap{InputTokens: 128_000, OutputTokens: 8_000, TotalTokens: 136_000}

func NormalizeStage(cfg StageConfig, defaults TokenCap) StageConfig {
    if cfg.Cap.TotalTokens <= 0 { cfg.Cap.TotalTokens = defaults.TotalTokens }
    if cfg.Cap.InputTokens  <= 0 { cfg.Cap.InputTokens  = defaults.InputTokens }
    if cfg.Cap.OutputTokens <= 0 { cfg.Cap.OutputTokens = defaults.OutputTokens }
    return cfg
}

// 2) Fixed decision: an unset cap (<= 0) means "no compaction pressure
//    configured" — never derive a negative threshold. With a positive cap,
//    compact only once used tokens reach 80% of the budget.
func ShouldCompact(cap TokenCap, usedTokens int64) bool {
    if cap.TotalTokens <= 0 { return false }   // fixes the negative-threshold loop
    threshold := int64(float64(cap.TotalTokens) * 0.80)
    return usedTokens >= threshold
}

// 3) The judge loop stays bounded (maxCompactions = 3) and now fails fast
//    with a diagnosable error instead of stalling.
func RunStage(ctx context.Context, cfg StageConfig,
    usedTokens func() int64, compact, runIteration func(context.Context) error) (int, error) {
    compactions := 0
    for i := 0; i < cfg.MaxIterations; i++ {
        if ShouldCompact(cfg.Cap, usedTokens()) {
            if compactions >= maxCompactions {
                return compactions, fmt.Errorf("%w: stage=%s cap=%+v compactions=%d",
                    ErrCompactionLoop, cfg.Name, cfg.Cap, compactions)
            }
            if err := compact(ctx); err != nil { return compactions, err }
            compactions++
        }
        if err := runIteration(ctx); err != nil { return compactions, err }
    }
    return compactions, nil
}

Wire it in where the tier2 stage is loaded: cfg = NormalizeStage(cfg, DefaultCap) and route all compaction checks through ShouldCompact. No behavioral change for correctly-configured stages (still compacts at 80% of a real budget).

Workaround (CLI, no code change required)

run-judge-safe.sh — background the judge under timeout 900, then poll for the newest verdict dir and only proceed once verdict.json carries a final status:

timeout "${GITREINS_JUDGE_TIMEOUT:-900}" gitreins judge "$ID" >"$LOG" 2>&1 &
JUDGE_PID=$!

# wait for the newest verdict dir (judge writes per-stage subdirs)
while :; do
  newest="$(ls -1dt "$VERDICTS_ROOT"/*/ 2>/dev/null | head -n1 || true)"
  if [[ -n "$newest" && "$newest" != "$before" && -f "${newest}verdict.json" ]] \
     && grep -qE '"status"[[:space:]]*:[[:space:]]*"(PASSED|FAILED|SKIPPED)"' "${newest}verdict.json"; then
    echo "OK newest verdict: ${newest}verdict.json"; break
  fi
  kill -0 "$JUDGE_PID" 2>/dev/null || { echo "FAIL judge exited with no verdict" >&2; exit 1; }
  sleep 5
done

For MCP: call this wrapper (or timeout 900 gitreins judge <id> itself) instead of invoking gitreins judge synchronously — the hard timeout means the tool call can never hang on the tier1 300s + compaction stall; the caller re-checks ls -1dt verdicts/*/ | head -1 for the fresh verdict dir.