golangLAKEHOUSE/internal/matrix/downgrade.go

package matrix

// Strong-model auto-downgrade gate. Port of mode.rs::execute's
// downgrade block (Rust system, 2026-04-26 pass5).
//
// What it does: if the caller resolves `codereview_lakehouse` against
// a strong model and didn't force the mode, flip to
// `codereview_isolation` so we don't pollute the prompt with matrix
// chunks the model demonstrably does better without.
//
// Why: pass5 variance test on x-ai/grok-4.1-fast — composing matrix
// corpora into codereview_lakehouse LOST 5/5 head-to-head reps
// against matrix-free codereview_isolation, p=0.031. Strong models
// have enough native capacity that bug fingerprints + adversarial
// framing + file content carry them; matrix chunks displace
// depth-of-analysis.
//
// Defaults: assume "strong" (downgrade matrix off). The explicit
// IsWeakModel predicate keeps the weak-list small — anything
// matching `:free` (OpenRouter free tier) or the local last-resort
// rungs (qwen3.5/qwen3) stays on the full lakehouse path where
// matrix demonstrably helped during the 2026-04-26 free-tier
// bake-off.

import (
	"os"
	"strings"
)

// Mode constants — exported so callers don't string-literal them.
const (
	ModeCodeReviewLakehouse = "codereview_lakehouse"
	ModeCodeReviewIsolation = "codereview_isolation"
)

// EnvForceFullEnrichment is the env var that bypasses the gate for
// diagnostic runs ("LH_FORCE_FULL_ENRICHMENT=1" or "true").
const EnvForceFullEnrichment = "LH_FORCE_FULL_ENRICHMENT"

// IsWeakModel returns true for models matrix-corpus composition
// demonstrably helped during the 2026-04-26 pass5 bake-off. Strong
// models (default) get matrix dropped to avoid the "composed lost
// 5/5 vs isolation" effect.
//
// Weak signals:
//   - `:free` suffix (OpenRouter free tier, e.g. `gpt-oss-120b:free`)
//   - `:free/` infix (handles routing-prefixed names like `or:free/x`)
//   - `qwen3.5:latest` / `qwen3:latest` — local last-resort rung
//
// Add new weak models by extending this function alongside variance
// data that justifies it.
func IsWeakModel(model string) bool {
	if strings.HasSuffix(model, ":free") || strings.Contains(model, ":free/") {
		return true
	}
	switch model {
	case "qwen3.5:latest", "qwen3:latest":
		return true
	}
	return false
}

// DowngradeInput is what MaybeDowngrade evaluates.
//
// ForcedMode: caller explicitly set their mode (mirrors Rust's
// req.force_mode.is_some()) — treated as opt-in to the chosen mode,
// skips the downgrade. Experiments need exact-mode control.
//
// ForceFullOverride: the LH_FORCE_FULL_ENRICHMENT escape hatch —
// usually populated from the env var via NewDowngradeInputFromEnv,
// but the field is explicit so callers can pass it from a config or
// test deterministically.
type DowngradeInput struct {
	Mode              string
	Model             string
	ForcedMode        bool
	ForceFullOverride bool
}

// DowngradeDecision is the output. DowngradedFrom is non-empty
// only when a downgrade fired — callers should record it for audit
// (matches the Rust EnrichmentSources.downgraded_from field).
//
// Reason is a short human-readable string for logs/responses;
// useful for debugging "why did/didn't the gate fire."
type DowngradeDecision struct {
	Mode           string `json:"mode"`
	DowngradedFrom string `json:"downgraded_from,omitempty"`
	Reason         string `json:"reason"`
}

// MaybeDowngrade applies the strong-model auto-downgrade gate.
// Pure function; no env reads. For env-driven callers see
// NewDowngradeInputFromEnv.
func MaybeDowngrade(in DowngradeInput) DowngradeDecision {
	out := DowngradeDecision{Mode: in.Mode}
	if in.Mode != ModeCodeReviewLakehouse {
		out.Reason = "mode is not " + ModeCodeReviewLakehouse + "; gate not applicable"
		return out
	}
	if in.ForcedMode {
		out.Reason = "caller forced mode; skip downgrade"
		return out
	}
	if in.ForceFullOverride {
		out.Reason = EnvForceFullEnrichment + " bypass"
		return out
	}
	if IsWeakModel(in.Model) {
		out.Reason = "weak model; matrix composition demonstrably helped (2026-04-26 free-tier bake-off)"
		return out
	}
	// Downgrade fires.
	out.Mode = ModeCodeReviewIsolation
	out.DowngradedFrom = ModeCodeReviewLakehouse
	out.Reason = "strong model; matrix composes anti-additively (pass5: composed lost 5/5 vs isolation on grok-4.1-fast, p=0.031)"
	return out
}

// NewDowngradeInputFromEnv is a convenience that reads
// LH_FORCE_FULL_ENRICHMENT from the process environment and returns
// a populated DowngradeInput. Most production callers want this;
// tests should construct DowngradeInput directly to avoid env
// pollution.
func NewDowngradeInputFromEnv(mode, model string, forcedMode bool) DowngradeInput {
	return DowngradeInput{
		Mode:              mode,
		Model:             model,
		ForcedMode:        forcedMode,
		ForceFullOverride: envForceFullEnrichment(),
	}
}

func envForceFullEnrichment() bool {
	v := strings.ToLower(strings.TrimSpace(os.Getenv(EnvForceFullEnrichment)))
	return v == "1" || v == "true"
}