feat: add compact window/ratio settings and unify /model persistence

Author: voocel

internal/agent/session_runtime.go

@@ -485,6 +485,7 @@ func (s *Session) SetModel(prov, model string) error {
 	})
 
 	s.reclampThinking()
+	s.updateContextFromRegistry(prov, model)
 
 	return nil
 }
@@ -500,115 +501,6 @@ func (s *Session) providerType(prov string) (string, error) {
 	return config.ResolveProviderType(prov, "")
 }
 
-func (s *Session) ResolveAndSetModel(pattern string) (resolved string, err error) {
-	defer func() {
-		if err == nil {
-			prov, model := s.Provider(), s.ModelName()
-			if e := config.PatchGlobalSettings(config.Settings{
-				Provider: &prov,
-				Model:    &model,
-			}); e != nil {
-				fmt.Fprintf(os.Stderr, "warning: persist model setting: %v\n", e)
-			}
-		}
-	}()
-
-	// Extract :thinking suffix (e.g. "model:high").
-	thinkingLevel := agentcore.ThinkingLevel("")
-	if idx := strings.LastIndex(pattern, ":"); idx > 0 {
-		suffix := pattern[idx+1:]
-		if provider.IsValidThinkingLevel(suffix) {
-			thinkingLevel = agentcore.ThinkingLevel(suffix)
-			pattern = pattern[:idx]
-		}
-	}
-
-	// Snapshot configured providers.
-	s.mu.Lock()
-	provSnapshot := make(map[string]config.ProviderConfig, len(s.providers))
-	maps.Copy(provSnapshot, s.providers)
-	s.mu.Unlock()
-
-	// Explicit provider/model or provider:model.
-	// Only split when the left side is a configured provider key so that
-	// model IDs containing slashes (e.g. OpenRouter's "openai/gpt-5") still
-	// work as explicit model IDs under the chosen provider.
-	if prov, model, ok := splitExplicitModelPattern(pattern, provSnapshot); ok {
-		if err := s.SetModel(prov, model); err != nil {
-			return "", err
-		}
-		s.updateContextFromRegistry(prov, model)
-		if thinkingLevel != "" {
-			s.SetThinkingLevel(thinkingLevel)
-		}
-		return explicitModelID(prov, model), nil
-	}
-
-	// Search across all configured providers' models lists.
-	type match struct {
-		provider string
-		model    string
-	}
-	var matches []match
-	for provName, pc := range provSnapshot {
-		for _, m := range pc.Models {
-			if strings.EqualFold(m, pattern) {
-				matches = append(matches, match{provider: provName, model: m})
-			}
-		}
-	}
-	if len(matches) == 1 {
-		m := matches[0]
-		if err := s.SetModel(m.provider, m.model); err != nil {
-			return "", err
-		}
-		s.updateContextFromRegistry(m.provider, m.model)
-		if thinkingLevel != "" {
-			s.SetThinkingLevel(thinkingLevel)
-		}
-		return m.model, nil
-	}
-	if len(matches) > 1 {
-		provs := make([]string, len(matches))
-		for i, m := range matches {
-			provs[i] = config.FormatModelID(m.provider, m.model)
-		}
-		return "", fmt.Errorf("model %q is ambiguous, found in: %s; use provider/model format", pattern, strings.Join(provs, ", "))
-	}
-
-	// Fallback: try current provider with the pattern as model name.
-	curProv := s.Provider()
-	if err := s.SetModel(curProv, pattern); err != nil {
-		return "", fmt.Errorf("model %q not found in any configured provider", pattern)
-	}
-	s.updateContextFromRegistry(curProv, pattern)
-	if thinkingLevel != "" {
-		s.SetThinkingLevel(thinkingLevel)
-	}
-	return pattern, nil
-}
-
-func splitExplicitModelPattern(pattern string, providers map[string]config.ProviderConfig) (providerKey, model string, ok bool) {
-	if prov, model, ok := strings.Cut(pattern, "/"); ok {
-		if _, exists := providers[prov]; exists && model != "" {
-			return prov, model, true
-		}
-	}
-	if prov, model, ok := strings.Cut(pattern, ":"); ok {
-		if _, exists := providers[prov]; exists && model != "" {
-			return prov, model, true
-		}
-	}
-	return "", "", false
-}
-
-func explicitModelID(providerKey, model string) string {
-	if providerKey == "" {
-		return model
-	}
-	return providerKey + "/" + model
-}
-
 // updateContextFromRegistry updates context window from registry metadata if available.
 // It tries provider-qualified lookup first (e.g. "anthropic/claude-sonnet-4-5"),
 // then falls back to bare modelID for custom providers not in the registry.
@@ -633,13 +525,23 @@ func (s *Session) updateContextFromRegistry(providerKey, modelID string) {
 }
 
 func (s *Session) applyContextWindow(window int) {
+	// Re-apply user-configured compaction caps to the new model window so that
+	// mid-session model switches honor compact_window / compact_ratio.
+	if cap := s.settings.CompactWindow; cap > 0 && cap < window {
+		window = cap
+	}
+	reserve := 0
+	if r := s.settings.CompactRatio; r > 0 && r < 1 {
+		reserve = window - int(float64(window)*r)
+	}
 	s.agent.SetContextWindow(window)
 	s.mu.Lock()
 	s.settings.ContextWindow = window
 	cm := s.contextManager
 	s.mu.Unlock()
 	if engine, ok := cm.(*agentctx.ContextEngine); ok {
 		engine.SetContextWindow(window)
+		engine.SetReserveTokens(reserve)
 	}
 }
 

internal/agent/session_test.go

@@ -547,96 +547,6 @@ func TestSetModelDoesNotRewriteGlobalSettings(t *testing.T) {
 	}
 }
 
-func TestResolveAndSetModelSupportsExplicitProviderSyntax(t *testing.T) {
-	t.Parallel()
-
-	cases := []struct {
-		name         string
-		pattern      string
-		wantResolved string
-		wantProvider string
-		wantModel    string
-		wantThinking string
-	}{
-		{
-			name:         "provider slash model preserves provider-qualified return",
-			pattern:      "openrouter/openai/gpt-5",
-			wantResolved: "openrouter/openai/gpt-5",
-			wantProvider: "openrouter",
-			wantModel:    "openai/gpt-5",
-			wantThinking: "low",
-		},
-		{
-			name:         "provider colon model normalizes to slash form",
-			pattern:      "anthropic:claude-sonnet-4-5",
-			wantResolved: "anthropic/claude-sonnet-4-5",
-			wantProvider: "anthropic",
-			wantModel:    "claude-sonnet-4-5",
-			wantThinking: "low",
-		},
-		{
-			name:         "provider colon model with thinking suffix",
-			pattern:      "anthropic:claude-sonnet-4-5:high",
-			wantResolved: "anthropic/claude-sonnet-4-5",
-			wantProvider: "anthropic",
-			wantModel:    "claude-sonnet-4-5",
-			wantThinking: "high",
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-
-			dir := t.TempDir()
-			s := NewSession(SessionConfig{
-				Agent: agentcore.NewAgent(agentcore.WithModel(&stubChatModel{})),
-				Settings: config.Resolved{
-					Provider:      "openai",
-					Model:         "gpt-4.1",
-					ThinkingLevel: "low",
-					Providers: map[string]config.ProviderConfig{
-						"openai": {
-							APIKey: "openai-key",
-							Models: []string{"gpt-4.1", "gpt-5"},
-						},
-						"anthropic": {
-							APIKey: "anthropic-key",
-							Models: []string{"claude-sonnet-4-5"},
-						},
-						"openrouter": {
-							APIKey: "openrouter-key",
-							Models: []string{"openai/gpt-5"},
-						},
-					},
-				},
-				Cwd: dir,
-				CreateModel: func(_ string, model string, _ string, _ string) (agentcore.ChatModel, error) {
-					return &namedChatModel{name: model}, nil
-				},
-			})
-			t.Cleanup(s.Close)
-
-			resolved, err := s.ResolveAndSetModel(tc.pattern)
-			if err != nil {
-				t.Fatalf("ResolveAndSetModel(%q) error: %v", tc.pattern, err)
-			}
-			if resolved != tc.wantResolved {
-				t.Fatalf("resolved = %q, want %q", resolved, tc.wantResolved)
-			}
-			if got := s.Provider(); got != tc.wantProvider {
-				t.Fatalf("provider = %q, want %q", got, tc.wantProvider)
-			}
-			if got := s.ModelName(); got != tc.wantModel {
-				t.Fatalf("model = %q, want %q", got, tc.wantModel)
-			}
-			if got := s.Settings().ThinkingLevel; got != tc.wantThinking {
-				t.Fatalf("thinking = %q, want %q", got, tc.wantThinking)
-			}
-		})
-	}
-}
-
 func TestResolveCredentialsPerProvider(t *testing.T) {
 	t.Parallel()
 

internal/bootstrap/assemble_runtime.go

@@ -28,7 +28,11 @@ func assembleRuntime(input *resolvedInput, services *bootServices, assembly *ses
 	baseTools = append(baseTools, assembly.baseTools...)
 	baseTools = append(baseTools, taskTools...)
 
-	contextEngine, summaryCompact := buildContextEngine(assembly.chatModel, assembly.settings.ContextWindow)
+	reserveTokens := 0 // 0 = engine default (fixed buffer)
+	if r := assembly.settings.CompactRatio; r > 0 && r < 1 {
+		reserveTokens = assembly.settings.ContextWindow - int(float64(assembly.settings.ContextWindow)*r)
+	}
+	contextEngine, summaryCompact := buildContextEngine(assembly.chatModel, assembly.settings.ContextWindow, reserveTokens)
 	agentCore, err := buildAgent(assembly, services, contextEngine, taskRT, tools)
 	if err != nil {
 		return nil, err
@@ -69,7 +73,7 @@ func assembleRuntime(input *resolvedInput, services *bootServices, assembly *ses
 	}, nil
 }
 
-func buildContextEngine(chatModel agentcore.ChatModel, contextWindow int) (*agentctx.ContextEngine, *agentctx.FullSummaryStrategy) {
+func buildContextEngine(chatModel agentcore.ChatModel, contextWindow, reserveTokens int) (*agentctx.ContextEngine, *agentctx.FullSummaryStrategy) {
 	toolCompact := agentctx.NewToolResultMicrocompact(agentctx.ToolResultMicrocompactConfig{
 		Classifier: agent.CodebotToolClassifier,
 		KeepRecent: 5,
@@ -80,6 +84,7 @@ func buildContextEngine(chatModel agentcore.ChatModel, contextWindow int) (*agen
 	})
 	engine := agentctx.NewEngine(agentctx.EngineConfig{
 		ContextWindow: contextWindow,
+		ReserveTokens: reserveTokens,
 		Strategies: []agentctx.Strategy{
 			toolCompact,
 			trimCompact,

internal/bootstrap/assemble_session.go

@@ -94,6 +94,11 @@ func resolveActiveModel(input *resolvedInput) (config.Resolved, string, agentcor
 	} else if settings.ContextWindow <= 0 {
 		settings.ContextWindow = 128000
 	}
+	// Apply user cap: effective = min(detected, CompactWindow). Never raise above
+	// the model's real window — that would trigger API errors.
+	if cap := settings.CompactWindow; cap > 0 && cap < settings.ContextWindow {
+		settings.ContextWindow = cap
+	}
 	settings.Provider = activeProvider
 	settings.Model = activeModel
 

internal/config/settings.go

@@ -93,6 +93,13 @@ type Settings struct {
 
 	MaxTurns *int `json:"max_turns,omitempty"`
 
+	// CompactWindow caps the effective context window used for compaction.
+	// Effective = min(model's detected window, CompactWindow). 0 = disabled.
+	CompactWindow *int `json:"compact_window,omitempty"`
+	// CompactRatio triggers compaction when usage >= effective * ratio.
+	// Range (0, 1). 0 = engine default (fixed headroom buffer).
+	CompactRatio *float64 `json:"compact_ratio,omitempty"`
+
 	SearchProvider *string `json:"search_provider,omitempty"`
 	SearchAPIKey   *string `json:"search_api_key,omitempty"`
 
@@ -116,7 +123,9 @@ type Resolved struct {
 	SmallModel string                    // sub-agent model; equals Model when not configured
 	Providers  map[string]ProviderConfig // per-provider credentials
 
-	ContextWindow int // auto-detected from model registry at boot
+	ContextWindow int // effective window after applying CompactWindow cap
+	CompactWindow int // user-configured cap on effective window; 0 = disabled
+	CompactRatio  float64 // usage ratio that triggers compaction; 0 = engine default
 	ThinkingLevel string
 	MaxTurns       int
 	SearchProvider string
@@ -215,6 +224,15 @@ func (s Settings) Resolve() Resolved {
 	if s.MaxTurns != nil {
 		r.MaxTurns = *s.MaxTurns
 	}
+	if s.CompactWindow != nil && *s.CompactWindow > 0 {
+		r.CompactWindow = *s.CompactWindow
+	}
+	if s.CompactRatio != nil {
+		ratio := *s.CompactRatio
+		if ratio > 0 && ratio < 1 {
+			r.CompactRatio = ratio
+		}
+	}
 	if s.SearchProvider != nil {
 		r.SearchProvider = *s.SearchProvider
 	}
@@ -241,6 +259,15 @@ func ProjectConfigExists(cwd string) bool {
 	return err == nil
 }
 
+// ProjectSettingsDefinesModel reports whether the project settings file
+// exists and explicitly sets provider or model. Callers use this to decide
+// whether /model persistence should target the project file (so the choice
+// sticks across restarts) or the global file.
+func ProjectSettingsDefinesModel(cwd string) bool {
+	s := loadSettingsFile(SettingsPath(cwd))
+	return s.Provider != nil || s.Model != nil
+}
+
 // GlobalSettingsPath returns ~/.codebot/settings.json.
 func GlobalSettingsPath() string {
 	return filepath.Join(UserConfigDir(), "settings.json")
@@ -390,6 +417,12 @@ func mergeSettings(base, override Settings) Settings {
 	if override.MaxTurns != nil {
 		base.MaxTurns = override.MaxTurns
 	}
+	if override.CompactWindow != nil {
+		base.CompactWindow = override.CompactWindow
+	}
+	if override.CompactRatio != nil {
+		base.CompactRatio = override.CompactRatio
+	}
 	if override.SearchProvider != nil {
 		base.SearchProvider = override.SearchProvider
 	}