go-cli-judge-interface-mismatch

Answer

Root cause. The worker's CLI exposed subscribe/show, but the gitreins AC contract (the thing the judge actually exercises) is create --name/--url/--events and log --filter. The worker's own tests passed because they tested the worker's interface — the judge runs the AC interface, so every AC invocation failed with unknown-command / missing-flag and the judge FAILED despite a green test run.

The fix has two parts:

1. Align the CLI to the AC interface exactly, keep old names as aliases

Canonical subcommands become the AC names; subscribe→create and show→log are remapped so legacy tests keep passing. Go's flag package accepts both -name and --name natively, so the AC's long-form flags work out of the box; I additionally register short aliases (-n -u -e -f).

func main() {
    if len(os.Args) < 2 {
        usage()
        os.Exit(1) // tier1 "No-command-specified": non-zero exit + usage
    }
    cmd, args := os.Args[1], os.Args[2:]
    switch cmd {
    case "subscribe": // legacy alias -> AC name
        cmd = "create"
    case "show": // legacy alias -> AC name
        cmd = "log"
    }
    switch cmd {
    case "create":
        loadState()
        cmdCreate(args)
    case "log":
        loadState()
        cmdLog(args)
    default:
        fmt.Fprintf(os.Stderr, "gitreins: unknown command %q\n\n", os.Args[1])
        usage()
        os.Exit(1)
    }
}

// create --name <n> --url <u> --events <a,b,c>
func cmdCreate(args []string) {
    fs := flag.NewFlagSet("create", flag.ContinueOnError)
    name  := fs.String("name", "", "feed name (required)")
    url   := fs.String("url", "", "feed URL (required)")
    events:= fs.String("events", "", "comma-separated event types (required)")
    fs.StringVar(name,   "n", "", "alias for --name")   // short aliases
    fs.StringVar(url,    "u", "", "alias for --url")
    fs.StringVar(events, "e", "", "alias for --events")
    if err := fs.Parse(args); err != nil { os.Exit(2) }
    if *name == "" || *url == "" || *events == "" {
        fmt.Fprintln(os.Stderr, "create: --name, --url and --events are all required")
        os.Exit(2)
    }
    // ... upsert into store, saveState(), JSON output
}

// log --filter <name>
func cmdLog(args []string) {
    fs := flag.NewFlagSet("log", flag.ContinueOnError)
    filter := fs.String("filter", "", "feed name to filter events by (required)")
    fs.StringVar(filter, "f", "", "alias for --filter")
    if err := fs.Parse(args); err != nil { os.Exit(2) }
    if *filter == "" { /* usage error, exit 2 */ }
    // ... filter store.Events by feed, JSON output
}

Two traps found while implementing (see EVIDENCE):

• State must be persistent across invocations. The judge calls create then log as separate processes. An in-memory map silently resets every call, so duplicate-feed detection never fires and log can never see create's output. Added a JSON state file (GITREINS_STATE, default .gitreins-state.json) loaded on every command and saved after mutations.
• Exit codes are part of the contract. Empty argv → exit 1 with usage (that's what tier1 "No-command-specified" checks); usage/validation errors → exit 2; success → 0.

2. Harness-level fixes (re-judge + verdict parsing)

• Re-judge SEQUENTIALLY. Running judges in parallel alongside a sibling session causes the harness to pick up the sibling's argv and emit a spurious tier1 No-command-specified (empty command seen by the wrong judge). Re-run the judge alone, serially, one submission at a time: judge --problem ac-210 && judge --problem ac-230 (no background/concurrent invocations, no other pi session alive during the run). Verify each tier's verdict JSON before starting the next.
• Verdict parse artifact. Tier2's all-check can say PASS while the runner derives passed=false by grepping the summary text for a literal passed token (summary prose says "test passed" → parsed differently, or the field is missing). Fix the parser to consume the structured tier verdict fields (tier2.all-check == PASS, per-check results) instead of the prose summary; or, if the harness is fixed, emit a summary that contains the exact token the parser expects. Never trust summary text over the structured verdict.