feat(offload): extract_llm_sweep — co-reference index, economic trigger, and the fixes that let it act

cmd/cg-selarm/main_test.go

@@ -0,0 +1,72 @@
+package main
+
+import "testing"
+
+// Every case below is a reply shape MEASURED on this corpus or on the gateway, not an invented one.
+// The taxonomy exists because the first live run of this tool folded all four into "no verdicts" and
+// reported failures=0 while 17 of 30 batches never produced a judgement.
+func TestClassifyReplySeparatesTheFourOutcomes(t *testing.T) {
+	for _, tc := range []struct {
+		name       string
+		reply      string
+		candidates int
+		want       string
+		wantN      int
+	}{{
+		name:       "a complete verdict array is the only measurement",
+		reply:      `[{"i":0,"needed_by":"none","verdict":"drop"},{"i":1,"needed_by":"none","verdict":"keep"}]`,
+		candidates: 2, want: replyOK, wantN: 2,
+	}, {
+		// The shape that produced the 94-row file: prose, no array at all. Remedy is the prompt.
+		name:       "prose with no array is unparseable, not truncated",
+		reply:      "I have considered the outputs but will not produce a verdict array here.",
+		candidates: 3, want: replyUnparseable,
+	}, {
+		// Remedy is the opposite -- raise max_tokens -- so it must not be reported as unparseable.
+		name:       "an array opened and never closed is truncated",
+		reply:      `[{"i":0,"needed_by":"none","verdict":"drop"},{"i":1,"needed_by":"a","quote":"I will run the su`,
+		candidates: 3, want: replyTruncated,
+	}, {
+		// The QUIET failure: it parses, so nothing errors, but the omitted candidates would read as
+		// deliberate keeps in a scorer that defaults absent to keep.
+		name:       "a short but valid array is partial",
+		reply:      `[{"i":0,"needed_by":"none","verdict":"drop"}]`,
+		candidates: 6, want: replyPartial, wantN: 1,
+	}, {
+		// A deliberate keep-all. It MUST NOT read as junk: ParseVerdicts documents this distinction
+		// as the one a live arm turned on.
+		name:       "a closed empty array is a decision, not a failure",
+		reply:      `[]`,
+		candidates: 0, want: replyOK,
+	}} {
+		t.Run(tc.name, func(t *testing.T) {
+			vs, kind := classifyReply(tc.reply, tc.candidates)
+			if kind != tc.want {
+				t.Errorf("kind = %q, want %q", kind, tc.want)
+			}
+			if len(vs) != tc.wantN {
+				t.Errorf("verdicts = %d, want %d", len(vs), tc.wantN)
+			}
+		})
+	}
+}
+
+// An unparseable reply must yield NO verdicts, so the caller cannot write decisions derived from a
+// reply it already classified as junk.
+//
+// HONEST LIMIT ON THIS TEST: it cannot fail against today's code, and a mutation run confirmed that
+// -- changing `return nil, replyUnparseable` to `return vs, replyUnparseable` leaves every test
+// green, because `ParseVerdicts` itself returns `nil, false` on failure, so the two lines are
+// identical. It is kept as a contract assertion on that callee: if ParseVerdicts is ever changed to
+// salvage a partial slice from a reply it rejects, this is what trips. Read it as documentation of a
+// dependency, NOT as evidence that classifyReply drops verdicts on its own.
+func TestAnUnparseableReplyYieldsNoVerdicts(t *testing.T) {
+	for _, r := range []string{
+		"no array here",
+		`[{"i":0,"needed_by":"none","verdict":"dr`,
+	} {
+		if vs, kind := classifyReply(r, 4); len(vs) != 0 {
+			t.Errorf("%q classified %s but returned %d verdicts", r, kind, len(vs))
+		}
+	}
+}

cmd/context-guru-proxy/main.go

@@ -1188,10 +1188,32 @@ func modelWindows() modelinfo.Resolver {
 		}
 		return chain
 	}
-	return append(chain,
-		modelinfo.NewLiteLLM(os.Getenv("MODEL_INFO_URL"), nil, 0),
-		modelinfo.DefaultStatic(),
-	)
+	url := strings.TrimSpace(os.Getenv("MODEL_INFO_URL"))
+	live := modelinfo.NewLiteLLM(url, nil, 0)
+	if url == "" {
+		// The public map. A fetch failure here is a network inconvenience, not a misconfiguration, so
+		// the embedded table remains the right answer and the chain keeps its fallback.
+		return append(chain, live, modelinfo.DefaultStatic())
+	}
+	// AN EXPLICIT MODEL_INFO_URL IS AN AUTHORITY THE OPERATOR NAMED, and guessing past it is wrong for
+	// the same reason MODEL_PRICES is fatal rather than skipped a few lines up: a silently-absent
+	// document is indistinguishable from one that says something different, and every fraction-based
+	// threshold in the pipeline would then be evaluated against a window nobody chose. Probed
+	// SYNCHRONOUSLY here because the resolver's own fetch is a background refresh — by the time it
+	// fails, requests are already being served against DefaultStatic's 1,000,000 for a claude model.
+	//
+	// This is the check that would have stopped iteration 024. Its rig passed a correct 64k document on
+	// a URL the proxy could not reach; the proxy resolved 1,000,000 on all 2,207 requests, summarize's
+	// 0.78 trigger became 780,000 and never fired once in either arm, the econ trigger's horizon came
+	// out 16x too long and authorised 626 asks, and the run completed with every counter healthy. Six
+	// hours of benchmark time and $207 per arm bought numbers that described no configuration.
+	if err := live.Load(context.Background()); err != nil {
+		log.Fatalf("MODEL_INFO_URL %s: no context window could be resolved from it (%v). Refusing to "+
+			"start: every fraction-based trigger would be evaluated against a built-in default instead "+
+			"of the document you configured, and nothing downstream can tell the difference.", url, err)
+	}
+	// The fallback stays BEHIND the probed document, for models the document does not list.
+	return append(chain, live, modelinfo.DefaultStatic())
 }
 
 // cheapModelFromEnv builds the static "config"-source LLM client for NeedsModel

components/offload/commitgate_test.go

@@ -184,6 +184,21 @@ func gateCases() []gateCase {
 			body := strings.Repeat("a line of log output that goes on for a while\n", 80)
 			return c.(components.Offload), toolMsgs(body, body+"tail\n"), ctxFor(st)
 		}},
+		{"coref", func(t *testing.T, st store.Store) (components.Offload, *bschemas.BifrostChatRequest, *components.Ctx) {
+			// Driven rather than exempted, because coref DID have the defect this table exists to
+			// catch: it ignored commitMark's return and spliced plus froze regardless.
+			//
+			// min_later_turns AND min_batch_frac are both defaulted out of the way, the same as
+			// corefFor does. Leaving the opportunity floor at its default of 8 protects this
+			// fixture's tail candidate, nothing is cut, and the saturated case below would then
+			// pass vacuously -- which this table's own precondition catches.
+			c, err := newCoref([]byte("min_tokens: 20\nmin_batch_frac: 0\nmin_later_turns: 0\n" +
+				"break_even: false\n"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			return c.(components.Offload), corefReq(), corefCtx(st)
+		}},
 		{"dedup", func(t *testing.T, st store.Store) (components.Offload, *bschemas.BifrostChatRequest, *components.Ctx) {
 			c, err := newDedup([]byte("min_tokens: 20\n"))
 			if err != nil {