Closes #353

Summary

Adds first-class support for model-backed review/judge stages in workflow pipelines. A judge stage can run after implementation and tests, using a different model/provider to review the work before PR creation.

Changes

Pipeline Schema (pkg/hub/pipeline/pipeline.go)

• New JudgeAction in OnEnter:

  • model -- different LLM model than the implementer
  • inputs -- bounded inputs: issue, git_diff, test_output, files
  • require.verdict -- required verdict (pass or fail)
  • instructions -- system prompt for the judge
  • output -- pipeline output name for structured verdict storage
  • continue_on_error -- allow pipeline to continue on judge failure
  • max_tokens / timeout -- response limits

• New judge_verdict trigger type -- enables auto-transition after judge:

  • judge_verdict: pass -> transition to PR stage
  • judge_verdict: fail -> transition to fix stage

Execution Engine (pkg/hub/pipeline_runner.go)

• executeJudgeAction() -- collects bounded inputs, calls LLM, parses structured JSON
• parseJudgeResponse() -- extracts JSON from markdown fences, validates schema
• autoTransitionAfterJudge() -- finds next stage by verdict and transitions
• Judge results persisted as pipeline outputs for later stage reference
• Judge results injected into claw chat as structured messages

Tests

• TestParseJudgeAction -- full judge action parsing
• TestParseJudgeActionMinimal -- minimal config parsing
• TestJudgeInputConstants -- input type constants
• TestStageForJudgeVerdictPass/NoMatch/CaseInsensitive -- trigger matching
• TestParseJudgeResponseValid/Fail/WithMarkdownFences/MissingVerdict/InvalidVerdict -- response parsing
• TestJudgeTimeoutDefault/Custom/Invalid -- timeout handling
• TestRunOnEnterJudgeBlocksOnFail -- blocking behavior
• TestRunOnEnterJudgeContinueOnError -- continue_on_error behavior
• TestAutoTransitionAfterJudge -- auto-transition logic

Verification

• go build ./... passes
• go test ./pkg/hub/... passes
• go test ./pkg/hub/pipeline/... passes

Example Workflow

stages:
  - id: implement
    label: "Implement"
    entry: true
    on_enter:
      inject: |
        Implement the issue. Commit changes. Run tests. When done, say "[DONE]".

  - id: test
    label: "Test"
    triggers:
      - message_contains: "[DONE]"
    on_enter:
      run:
        command: go test ./...
        output: test_output

  - id: review
    label: "Review"
    triggers:
      - message_contains: "[DONE]"
    on_enter:
      judge:
        model: anthropic/claude-sonnet-4-6
        inputs:
          - issue
          - git_diff
          - test_output
        require:
          verdict: pass
        instructions: |
          Review the diff for correctness, security, regressions, and missing tests.
          Return pass/fail with specific required fixes.
        output: review_result
        timeout: 2m

  - id: pr
    label: "Create PR"
    triggers:
      - judge_verdict: pass
    on_enter:
      inject: |
        Review passed. Create a PR with: [DONE] https://github.com/org/repo/pull/...

  - id: fix
    label: "Fix Issues"
    triggers:
      - judge_verdict: fail
    on_enter:
      inject: |
        Review failed. Please fix these issues and re-run tests:

        {{ .Outputs.review_result.required_fixes }}

        Then say "[DONE]" again.

  - id: merged
    label: "Merged"
    triggers:
      - pr_merged:
    terminal: true

  - id: stopped
    label: "Stopped"
    triggers:
      - message_contains: "stop"
    terminal: true

This workflow:

1. Implement stage — agent implements the issue
2. Test stage — runs go test ./... on [DONE], stores output
3. Review stage — judge (different model) reviews issue + diff + test output
4. If pass → auto-transition to PR stage
5. If fail → auto-transition to Fix stage with findings injected
6. Agent fixes, re-runs tests, hits review again (bounded retry)
7. Merged or Stopped terminal stages