diff --git a/config.example.toml b/config.example.toml index f5a91d001..9aa10cbd9 100644 --- a/config.example.toml +++ b/config.example.toml @@ -26,6 +26,7 @@ poll_interval = "60s" label = "archie" bot_user = "vectis-labs-archie" +# 0 switches the cap off; omit the key to take the built-in default (400). diff_cap_lines = 400 # how many operator-triggered retries a parked task gets @@ -222,6 +223,11 @@ class = "ollama" # in the extracted UI topology. [health] listen = "127.0.0.1:8485" +# Bounds one readiness probe's call into a service the daemon depends on but +# does not own (the Gateway), so a hung dependency degrades that probe instead +# of stalling the whole report. Omit for the default; a negative value leaves +# only the caller's own deadline in force. +# dependency_timeout = "5s" # Web dashboard and API: task board, activity stream, chat, config, # memory, SSE events. Served as an embedded SPA with a full REST diff --git a/internal/app/archied/readiness.go b/internal/app/archied/readiness.go index b6e75f243..b08808d39 100644 --- a/internal/app/archied/readiness.go +++ b/internal/app/archied/readiness.go @@ -41,17 +41,13 @@ func (b *boot) setupReadinessProbes() { // this process depends on is the Gateway answering, so that is what it // reports (docs/prds/ui-service-boundary.md, "Listen, authentication, // and readiness"). - readiness.NewContractProbe("gateway", gatewayProbeTimeout, func(ctx context.Context) error { + readiness.NewContractProbe("gateway", time.Duration(cfg.Health.DependencyTimeout), func(ctx context.Context) error { return pingChat(ctx, b.chat) }), } b.healthRegistry = health.NewRegistry(probes...) } -// gatewayProbeTimeout bounds the Gateway readiness call so a hung Gateway -// degrades this probe rather than stalling the whole health report. -const gatewayProbeTimeout = 5 * time.Second - // pingChat asks the Gateway for a snapshot. An unwired chat surface is // reported as degraded rather than silently OK: a daemon with no Gateway // serves no chat at all. diff --git a/internal/app/archied/reload_test.go b/internal/app/archied/reload_test.go index ee3d5fa08..8aa551631 100644 --- a/internal/app/archied/reload_test.go +++ b/internal/app/archied/reload_test.go @@ -201,7 +201,7 @@ func TestChangedNonReloadableFields(t *testing.T) { reloadableOnly.Repos = []config.Repo{{Owner: "x", Name: "z"}} reloadableOnly.Budgets = config.Budgets{MaxSteps: 99} reloadableOnly.Dispatch = config.Dispatch{Trigger: "label"} - reloadableOnly.DiffCapLines = 1234 + reloadableOnly.DiffCapLines = new(1234) reloadableOnly.Models = map[string]string{"builder": "provider/model"} reloadableOnly.Notify = config.Notify{Webhook: "https://notify.example/hook"} reloadableOnly.Label = "archie" diff --git a/internal/config/config.go b/internal/config/config.go index 67370dc8d..11a838b5a 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -485,8 +485,14 @@ type Config struct { BotUser string `toml:"bot_user" yaml:"bot_user"` // BotEmail is the git author email; defaults to the GitHub noreply // address for BotUser. - BotEmail string `toml:"bot_email" yaml:"bot_email"` - DiffCapLines int `toml:"diff_cap_lines" yaml:"diff_cap_lines"` + BotEmail string `toml:"bot_email" yaml:"bot_email"` + // DiffCapLines parks a task whose diff exceeds this many changed lines. + // It is a pointer so an explicit 0 ("no cap") is distinguishable from an + // absent key, which takes the default: with a plain int the documented + // way to switch the cap off was indistinguishable from not configuring + // it, and the defaults pass silently rewrote it. Read it through + // [Config.DiffCap]. + DiffCapLines *int `toml:"diff_cap_lines" yaml:"diff_cap_lines"` Forge Forge `toml:"forge" yaml:"forge"` Dispatch Dispatch `toml:"dispatch" yaml:"dispatch"` @@ -550,8 +556,10 @@ type IdentityConfig struct { BotUser string `toml:"bot_user" yaml:"bot_user"` // BotEmail is the git author email. Falls back to a forge-appropriate // default from BotUser when empty. - BotEmail string `toml:"bot_email" yaml:"bot_email"` - DiffCapLines int `toml:"diff_cap_lines" yaml:"diff_cap_lines"` + BotEmail string `toml:"bot_email" yaml:"bot_email"` + // DiffCapLines overrides the shared cap for this identity. Nil (absent) + // inherits it; an explicit 0 switches the cap off for this identity only. + DiffCapLines *int `toml:"diff_cap_lines" yaml:"diff_cap_lines"` // PollInterval overrides the shared PollInterval. When 0, the shared // interval is used. PollInterval Duration `toml:"poll_interval" yaml:"poll_interval"` @@ -586,6 +594,25 @@ type TaskConfig struct { ToolPolicy ToolPolicy `json:"tool_policy"` } +// DiffCapOf returns a DiffCapLines value for n. It exists because the field is +// a pointer to keep "absent" distinct from an explicit 0, and a literal config +// cannot take the address of a constant. +// +//go:fix inline +func DiffCapOf(n int) *int { return new(n) } + +// DiffCap returns the effective changed-line cap: 0 means no cap, which is +// also what an unconfigured value means once a Config has been built by hand +// rather than loaded (tests, archie-agent's reconstructed Config). The loader's +// defaults pass fills the absent case, so a loaded Config never reports 0 +// unless the operator asked for it. +func (c Config) DiffCap() int { + if c.DiffCapLines == nil { + return 0 + } + return *c.DiffCapLines +} + // TaskForge is the non-secret forge configuration needed by workflow stages. type TaskForge struct { Host string `json:"host"` @@ -601,7 +628,7 @@ func (c Config) ForTask() TaskConfig { ModelLimits: maps.Clone(c.ModelLimits), Budgets: c.Budgets, Dispatch: Dispatch{Trigger: c.Dispatch.Trigger, AckReaction: c.Dispatch.AckReaction, Labels: cloneStringMap(c.Dispatch.Labels)}, - DiffCapLines: c.DiffCapLines, + DiffCapLines: c.DiffCap(), Notify: c.Notify, Forge: TaskForge{Host: c.Forge.Host}, ToolPolicy: c.Tools.Policy, @@ -620,7 +647,7 @@ func (tc TaskConfig) ToConfig() Config { ModelLimits: maps.Clone(tc.ModelLimits), Budgets: tc.Budgets, Dispatch: Dispatch{Trigger: tc.Dispatch.Trigger, AckReaction: tc.Dispatch.AckReaction, Labels: cloneStringMap(tc.Dispatch.Labels)}, - DiffCapLines: tc.DiffCapLines, + DiffCapLines: &tc.DiffCapLines, Notify: tc.Notify, Forge: Forge{Host: tc.Forge.Host}, Tools: ToolsConfig{Policy: tc.ToolPolicy}, @@ -1015,6 +1042,12 @@ type Health struct { // Listen is the address the daemon serves /healthz, /health and // /health/detailed on. Defaulted, never empty in a loaded config. Listen string `toml:"listen" yaml:"listen"` + // DependencyTimeout bounds one readiness probe's call into a service this + // process depends on but does not own, so a hung dependency degrades that + // probe instead of stalling the whole health report. It is the daemon's + // equivalent of the extracted services' -dependency-timeout flag. + // Defaulted, never zero in a loaded config. + DependencyTimeout Duration `toml:"dependency_timeout" yaml:"dependency_timeout"` } // URL renders Listen as an address a local caller can dial, which is what diff --git a/internal/config/config_test.go b/internal/config/config_test.go index 65fee5bcf..87aca01da 100644 --- a/internal/config/config_test.go +++ b/internal/config/config_test.go @@ -14,7 +14,7 @@ func TestTaskConfigToConfigRoundTrip(t *testing.T) { cfg := Config{ BotUser: "archie-bot", BotEmail: "archie-bot@users.noreply.github.com", - DiffCapLines: 321, + DiffCapLines: new(321), Models: map[string]string{"builder": "anthropic/claude"}, Budgets: Budgets{MaxSteps: 12, WallClock: Duration(45 * time.Minute), GateMaxFailures: 3}, Dispatch: Dispatch{Trigger: "label", AckReaction: "eyes", Labels: map[string]string{"working": "bot:working"}}, @@ -36,8 +36,10 @@ func TestTaskConfigToConfigRoundTrip(t *testing.T) { if !reflect.DeepEqual(got.Dispatch, cfg.Dispatch) { t.Fatalf("Dispatch = %#v, want %#v", got.Dispatch, cfg.Dispatch) } - if got.DiffCapLines != cfg.DiffCapLines { - t.Fatalf("DiffCapLines = %d, want %d", got.DiffCapLines, cfg.DiffCapLines) + // Compared by effective value, not pointer: the round trip through + // TaskConfig carries the resolved cap and rebuilds a fresh pointer. + if got.DiffCap() != cfg.DiffCap() { + t.Fatalf("DiffCap() = %d, want %d", got.DiffCap(), cfg.DiffCap()) } if got.Notify != cfg.Notify { t.Fatalf("Notify = %#v, want %#v", got.Notify, cfg.Notify) @@ -89,7 +91,7 @@ models = ["openai/gpt-5.6-sol", "openrouter/openai/gpt-5.6-sol"] func TestConfigForTaskJSONRoundTrip(t *testing.T) { cfg := Config{ - DiffCapLines: 321, + DiffCapLines: new(321), Models: map[string]string{ "builder": "anthropic/claude", "planner": "openai/gpt", @@ -124,7 +126,7 @@ func TestConfigForTaskJSONRoundTrip(t *testing.T) { Models: cfg.Models, Budgets: cfg.Budgets, Dispatch: cfg.Dispatch, - DiffCapLines: cfg.DiffCapLines, + DiffCapLines: cfg.DiffCap(), Notify: cfg.Notify, Forge: TaskForge{Host: cfg.Forge.Host}, ToolPolicy: cfg.Tools.Policy, diff --git a/internal/daemon/daemon.go b/internal/daemon/daemon.go index 633261f23..02aeac3a5 100644 --- a/internal/daemon/daemon.go +++ b/internal/daemon/daemon.go @@ -1611,7 +1611,12 @@ func (d *Daemon) captureAttemptConfig(ctx context.Context, task *workflow.Task, func configForIdentity(root config.Config, identity config.IdentityConfig) config.Config { root.BotUser = identity.BotUser root.BotEmail = identity.BotEmail - root.DiffCapLines = identity.DiffCapLines + // Only an identity that set the cap overrides the shared one. Assigning + // unconditionally made an identity that omits the key inherit a nil cap, + // which reads as "no cap" and silently disabled the safety rail. + if identity.DiffCapLines != nil { + root.DiffCapLines = identity.DiffCapLines + } root.Forge = identity.Forge root.Dispatch = identity.Dispatch root.Models = identity.Models diff --git a/internal/daemon/daemon_test.go b/internal/daemon/daemon_test.go index 95d3959af..a37243827 100644 --- a/internal/daemon/daemon_test.go +++ b/internal/daemon/daemon_test.go @@ -759,7 +759,7 @@ func TestRunViaAgentParksOnRunError(t *testing.T) { func TestRunViaAgentSendsExpectedRequest(t *testing.T) { d, s, busClient := daemonWithNATS(t) prev := d.Cfg.Get() - prev.DiffCapLines = 999 + prev.DiffCapLines = new(999) d.Cfg.Set(prev) ctx := context.Background() @@ -1975,7 +1975,7 @@ func configWithCanarySecrets() config.Config { }, }, Budgets: config.Budgets{MaxSteps: 40, GateMaxFailures: 2}, - DiffCapLines: 800, + DiffCapLines: new(800), Dispatch: config.Dispatch{ Trigger: "either", AckReaction: "eyes", Labels: map[string]string{"queued": "archie:queued"}, @@ -2259,3 +2259,28 @@ func TestReconcilePRsAttributesTheOutcomeToTheTasksAttempt(t *testing.T) { t.Fatal("reconcilePRs published no merge event") } } + +// TestConfigForIdentityInheritsAnUnsetDiffCap is the regression case for an +// identity silently disabling the diff cap. configForIdentity copied every +// identity field over the root unconditionally, so an identity that simply did +// not mention diff_cap_lines overwrote the shared cap with the zero value -- +// which StageDiffCap reads as "no cap". The safety rail vanished for exactly +// the deployments that never configured it per identity. +func TestConfigForIdentityInheritsAnUnsetDiffCap(t *testing.T) { + root := config.Config{DiffCapLines: new(400)} + + inherited := configForIdentity(root, config.IdentityConfig{BotUser: "one"}) + if inherited.DiffCap() != 400 { + t.Fatalf("DiffCap() = %d, want the shared 400 when the identity sets none", inherited.DiffCap()) + } + + overridden := configForIdentity(root, config.IdentityConfig{BotUser: "two", DiffCapLines: new(50)}) + if overridden.DiffCap() != 50 { + t.Fatalf("DiffCap() = %d, want the identity's 50", overridden.DiffCap()) + } + + off := configForIdentity(root, config.IdentityConfig{BotUser: "three", DiffCapLines: new(0)}) + if off.DiffCap() != 0 { + t.Fatalf("DiffCap() = %d, want 0: an identity may switch its own cap off explicitly", off.DiffCap()) + } +} diff --git a/internal/domain/workflow/implement_test.go b/internal/domain/workflow/implement_test.go index 7a33ae486..4ebe0ac9c 100644 --- a/internal/domain/workflow/implement_test.go +++ b/internal/domain/workflow/implement_test.go @@ -457,6 +457,8 @@ type fakeTrees struct { pushErr error dir string + // changedLines is what ChangedLines reports, for StageDiffCap. + changedLines int resumed bool resumeDir string @@ -485,7 +487,9 @@ func (f *fakeTrees) Diff(context.Context, string, string) (string, error) { retu func (f *fakeTrees) ChangedFiles(context.Context, string, string) ([]string, error) { return nil, nil } -func (f *fakeTrees) ChangedLines(context.Context, string, string) (int, error) { return 0, nil } +func (f *fakeTrees) ChangedLines(context.Context, string, string) (int, error) { + return f.changedLines, nil +} func (f *fakeTrees) Snapshot(context.Context, string, string) error { return nil } diff --git a/internal/domain/workflow/steps.go b/internal/domain/workflow/steps.go index be2d6ecd8..8b4c4837a 100644 --- a/internal/domain/workflow/steps.go +++ b/internal/domain/workflow/steps.go @@ -188,17 +188,21 @@ func closeNoChangesIssue(ctx context.Context, tc *TaskContext) error { // oversized changes need human pre-approval, not an auto-opened PR. func StageDiffCap() Stage { return Stage{Name: "diff-cap", Run: func(ctx context.Context, tc *TaskContext) error { - if tc.Cfg.DiffCapLines <= 0 { + capLines := tc.Cfg.DiffCap() + if capLines <= 0 { return nil } lines, err := tc.Trees.ChangedLines(ctx, tc.Dir, tc.Repo.BaseBranch()) if err != nil { return err } - if lines > tc.Cfg.DiffCapLines { + if lines > capLines { + // No "approve" here: a parked task's operator actions are retry, + // abandon and reject (internal/taskstate), so telling the operator + // to approve sent them looking for a button that does not exist. tc.Outcome = Outcome{ Status: StatusParked, - Detail: fmt.Sprintf("diff is %d changed lines (cap %d) -- split the issue or approve manually", lines, tc.Cfg.DiffCapLines), + Detail: fmt.Sprintf("diff is %d changed lines (cap %d) -- split the issue, or raise diff_cap_lines and retry", lines, capLines), } } return nil diff --git a/internal/domain/workflow/steps_test.go b/internal/domain/workflow/steps_test.go index 74580e254..3312e5c73 100644 --- a/internal/domain/workflow/steps_test.go +++ b/internal/domain/workflow/steps_test.go @@ -7,6 +7,7 @@ import ( "os" "os/exec" "path/filepath" + "strings" "testing" "github.com/samcharles93/archie-core/internal/config" @@ -224,3 +225,50 @@ func TestStageRepoStagesPropagatesLoaderError(t *testing.T) { t.Fatal("StageRepoStages() = nil, want the loader's error propagated") } } + +// TestStageDiffCapUnlimitedWhenCapIsZero pins that an explicit 0 switches the +// cap off. The dashboard schema documents 0 that way, and this is the step that +// has to honour it -- for a long time it could not, because the config loader +// rewrote an explicit 0 to the default before the step ever saw it. +func TestStageDiffCapUnlimitedWhenCapIsZero(t *testing.T) { + tc := &TaskContext{ + Cfg: config.Config{DiffCapLines: new(0)}, + Trees: &fakeTrees{changedLines: 10_000}, + Repo: config.Repo{Owner: "acme", Name: "app"}, + } + + if err := StageDiffCap().Run(context.Background(), tc); err != nil { + t.Fatalf("StageDiffCap: %v", err) + } + if tc.Outcome.Status == StatusParked { + t.Fatalf("task parked with the cap switched off: %q", tc.Outcome.Detail) + } +} + +// TestStageDiffCapParksWithAnActionableReason is the regression case for a park +// reason that told the operator to do something impossible. A parked task's +// actions are retry, abandon and reject (internal/taskstate), so "approve +// manually" sent them looking for a button that does not exist -- which is +// exactly what happened on task 11. +func TestStageDiffCapParksWithAnActionableReason(t *testing.T) { + tc := &TaskContext{ + Cfg: config.Config{DiffCapLines: new(400)}, + Trees: &fakeTrees{changedLines: 789}, + Repo: config.Repo{Owner: "acme", Name: "app"}, + } + + if err := StageDiffCap().Run(context.Background(), tc); err != nil { + t.Fatalf("StageDiffCap: %v", err) + } + if tc.Outcome.Status != StatusParked { + t.Fatalf("Outcome.Status = %q, want parked at 789 lines over a 400 cap", tc.Outcome.Status) + } + if strings.Contains(tc.Outcome.Detail, "approve") { + t.Errorf("park reason offers approve, which is not an action a parked task has: %q", tc.Outcome.Detail) + } + for _, want := range []string{"789", "400", "diff_cap_lines"} { + if !strings.Contains(tc.Outcome.Detail, want) { + t.Errorf("park reason %q is missing %q", tc.Outcome.Detail, want) + } + } +} diff --git a/internal/infrastructure/configuration/defaults.go b/internal/infrastructure/configuration/defaults.go index a60cd2512..9135b46af 100644 --- a/internal/infrastructure/configuration/defaults.go +++ b/internal/infrastructure/configuration/defaults.go @@ -50,6 +50,11 @@ const ( // defaultHealthListen is the daemon's own liveness address. The update // watchdog's fallback in scripts/archie-update-watchdog must match it. defaultHealthListen = "127.0.0.1:8485" + + // defaultHealthDependencyTimeout matches the extracted services' + // -dependency-timeout default, so every process bounds a probe into a + // dependency the same way out of the box. + defaultHealthDependencyTimeout = 5 * time.Second ) // applyDefaults fills in every absent value. It never reports an error and @@ -66,6 +71,9 @@ func (l *Loader) applyDefaults(cfg *config.Config) { if cfg.Health.Listen == "" { cfg.Health.Listen = defaultHealthListen } + if cfg.Health.DependencyTimeout == 0 { + cfg.Health.DependencyTimeout = config.Duration(defaultHealthDependencyTimeout) + } l.applyGeneralDefaults(cfg) applyForgeDefaults(cfg) applyDispatchDefaults(cfg) @@ -208,8 +216,11 @@ func (l *Loader) applyGeneralDefaults(cfg *config.Config) { if cfg.PollInterval == 0 { cfg.PollInterval = config.Duration(defaultPollInterval) } - if cfg.DiffCapLines == 0 { - cfg.DiffCapLines = defaultDiffCapLines + // Only an absent key takes the default. An explicit 0 is the documented + // way to switch the cap off and must survive. + if cfg.DiffCapLines == nil { + capLines := defaultDiffCapLines + cfg.DiffCapLines = &capLines } if cfg.Web.Listen == "" { cfg.Web.Listen = defaultWebListen diff --git a/internal/infrastructure/configuration/defaults_test.go b/internal/infrastructure/configuration/defaults_test.go index 480fb37d4..37972b657 100644 --- a/internal/infrastructure/configuration/defaults_test.go +++ b/internal/infrastructure/configuration/defaults_test.go @@ -147,3 +147,58 @@ func TestApplyMemoryDefaultsLeavesExplicitEngineAlone(t *testing.T) { t.Errorf("Memory.Engine = %q, want unchanged %q", cfg.Memory.Engine, "honcho") } } + +// TestDefaultsKeepAnExplicitUnlimitedDiffCap is the regression case for +// diff_cap_lines = 0 silently becoming 400. The dashboard schema, and +// StageDiffCap itself, both document 0 as "no cap", but the defaults pass could +// not tell an explicit 0 from an absent key and rewrote both to 400 -- so the +// documented way to switch the cap off was unreachable through config. +func TestDefaultsKeepAnExplicitUnlimitedDiffCap(t *testing.T) { + unlimited := 0 + cfg := config.Config{DiffCapLines: &unlimited} + (&Loader{}).applyDefaults(&cfg) + + if cfg.DiffCapLines == nil { + t.Fatal("DiffCapLines = nil, want the explicit 0 preserved") + } + if *cfg.DiffCapLines != 0 { + t.Fatalf("DiffCapLines = %d, want 0: an explicit 0 means no cap", *cfg.DiffCapLines) + } + if cfg.DiffCap() != 0 { + t.Fatalf("DiffCap() = %d, want 0 (unlimited)", cfg.DiffCap()) + } +} + +// TestDefaultsApplyTheDiffCapWhenUnset pins the other half: an absent key still +// gets the safety cap, so omitting it never silently auto-opens huge PRs. +func TestDefaultsApplyTheDiffCapWhenUnset(t *testing.T) { + cfg := config.Config{} + (&Loader{}).applyDefaults(&cfg) + + if cfg.DiffCapLines == nil || *cfg.DiffCapLines != defaultDiffCapLines { + t.Fatalf("DiffCapLines = %v, want %d when the key is absent", cfg.DiffCapLines, defaultDiffCapLines) + } +} + +// TestDefaultsFillTheHealthDependencyTimeout pins that the probe timeout has a +// default, so a config that never mentions it still bounds the Gateway call +// rather than letting a hung dependency stall the whole health report. +func TestDefaultsFillTheHealthDependencyTimeout(t *testing.T) { + cfg := config.Config{} + (&Loader{}).applyDefaults(&cfg) + + if got := time.Duration(cfg.Health.DependencyTimeout); got != defaultHealthDependencyTimeout { + t.Fatalf("Health.DependencyTimeout = %v, want %v", got, defaultHealthDependencyTimeout) + } +} + +// TestDefaultsKeepAConfiguredHealthDependencyTimeout pins that an operator's +// value is not overwritten, which is the whole point of making it configurable. +func TestDefaultsKeepAConfiguredHealthDependencyTimeout(t *testing.T) { + cfg := config.Config{Health: config.Health{DependencyTimeout: config.Duration(30 * time.Second)}} + (&Loader{}).applyDefaults(&cfg) + + if got := time.Duration(cfg.Health.DependencyTimeout); got != 30*time.Second { + t.Fatalf("Health.DependencyTimeout = %v, want the configured 30s", got) + } +} diff --git a/internal/taskrun/taskrun_test.go b/internal/taskrun/taskrun_test.go index b5bfe82af..84f3ea5b8 100644 --- a/internal/taskrun/taskrun_test.go +++ b/internal/taskrun/taskrun_test.go @@ -21,7 +21,7 @@ func TestRequestJSONRoundTrip(t *testing.T) { Status: workflow.StatusRunning, }, Repo: config.Repo{Owner: "acme", Name: "widget", Base: "main"}, - Cfg: config.Config{DiffCapLines: 500}.ForTask(), + Cfg: config.Config{DiffCapLines: new(500)}.ForTask(), Providers: map[string]agentexec.Provider{ "anthropic": {Class: "anthropic", APIKeyEnv: "ANTHROPIC_API_KEY"}, }, diff --git a/internal/webui/api_config.go b/internal/webui/api_config.go index c99cff504..2c699c29a 100644 --- a/internal/webui/api_config.go +++ b/internal/webui/api_config.go @@ -374,7 +374,7 @@ func BuildConfigView(in ConfigViewInput) ConfigView { Label: cfg.Label, ForgeType: cfg.Forge.Type, ForgeHost: cfg.Forge.Host, - DiffCapLines: cfg.DiffCapLines, + DiffCapLines: cfg.DiffCap(), }, Repositories: reposView(cfg.Repos), MultiIdentity: len(cfg.Identities) > 0, diff --git a/internal/webui/config_schema.go b/internal/webui/config_schema.go index 53a255d50..81c77fbf7 100644 --- a/internal/webui/config_schema.go +++ b/internal/webui/config_schema.go @@ -108,7 +108,7 @@ func configFieldDescriptors() []ConfigSection { {Key: "label", Label: "Pickup label", Type: FieldString, Editable: true}, {Key: "forge.type", Label: "Forge type", Type: FieldString, Editable: true, RestartRequired: true}, {Key: "forge.host", Label: "Forge host", Type: FieldString, Editable: true}, - {Key: "diff_cap_lines", Label: "Max diff size (lines)", Description: "0 means unlimited.", Type: FieldInt, Editable: true}, + {Key: "diff_cap_lines", Label: "Max diff size (lines)", Description: "0 switches the cap off; leave unset for the default.", Type: FieldInt, Editable: true}, }, }, {