Tooling: Add allowlist to file-length check

- `file-length-allowlist.json` maps paths to accepted line counts
- Files at or below their allowlisted count are silently suppressed
- Files that grow past their allowlist are reported with both counts
- New long files not in the allowlist are reported normally
- Missing allowlist file = backwards-compatible (all files reported)
- Added 31 current long files as the initial allowlist baseline

Author: vdavid

scripts/check/CLAUDE.md

@@ -95,7 +95,8 @@ go run ./scripts/check --only-freestyle
 | `checks/desktop-rust-*.go`                                                | One file per Rust check                                                                                                                                       |
 | `checks/desktop-svelte-*.go`                                              | One file per Svelte/TS check                                                                                                                                  |
 | `checks/website-*.go`, `checks/api-server-*.go`, `checks/scripts-go-*.go` | One file per check                                                                                                                                            |
-| `checks/file-length.go`                                                   | Informational file-length scanner (warn-only, never fails)                                                                                                    |
+| `checks/file-length.go`                                                   | Informational file-length scanner (warn-only, never fails). Supports an allowlist.                                                                            |
+| `checks/file-length-allowlist.json`                                       | Allowlist for file-length check: `{ "files": { "path": lineCount } }`. Files at or below their allowlisted count are suppressed. |
 
 ## Key patterns
 
@@ -125,6 +126,13 @@ full binary path. Used for staticcheck, nilaway, etc.
 result (pass/fail/skip/blocked), and optional counts (total, issues, changes). `CheckResult` has `Total`, `Issues`,
 `Changes` fields (`-1` = N/A, rendered as `N/A` in CSV). Disabled by `--no-log` or `--ci`. Implementation in `stats.go`.
 
+**File-length allowlist:** `checks/file-length-allowlist.json` maps relative paths to accepted line counts. Files at or
+below their allowlisted count are silently suppressed. Files that grow beyond their allowlisted count are reported with
+both the current and allowed line counts. New files not in the allowlist are reported normally. When the allowlist
+suppresses all long files, the check shows "No new long files (N allowlisted)". If the allowlist file is missing, all
+long files are reported (backwards-compatible). To allowlist a file, add `"relative/path": lineCount` to the `files`
+object.
+
 ## Check definition shape
 
 ```go

scripts/check/checks/file-length-allowlist.json

@@ -0,0 +1,36 @@
+{
+  "$comment": "Files listed here are exempt from the file-length warning up to the given line count. If a file grows beyond its allowlisted count, it will be reported. Remove entries as you shrink files.",
+  "files": {
+    "apps/desktop/src-tauri/src/ai/manager.rs": 988,
+    "apps/desktop/src-tauri/src/file_system/volume/friendly_error.rs": 1136,
+    "apps/desktop/src-tauri/src/file_system/volume/mtp.rs": 879,
+    "apps/desktop/src-tauri/src/file_system/volume/smb.rs": 1802,
+    "apps/desktop/src-tauri/src/file_system/write_operations/copy.rs": 825,
+    "apps/desktop/src-tauri/src/file_system/write_operations/volume_copy.rs": 1122,
+    "apps/desktop/src-tauri/src/indexing/aggregator.rs": 873,
+    "apps/desktop/src-tauri/src/indexing/event_loop.rs": 1683,
+    "apps/desktop/src-tauri/src/indexing/mod.rs": 1072,
+    "apps/desktop/src-tauri/src/indexing/reconciler.rs": 2068,
+    "apps/desktop/src-tauri/src/indexing/scanner.rs": 1026,
+    "apps/desktop/src-tauri/src/indexing/store.rs": 2142,
+    "apps/desktop/src-tauri/src/indexing/writer.rs": 2295,
+    "apps/desktop/src-tauri/src/lib.rs": 1069,
+    "apps/desktop/src-tauri/src/mcp/resources.rs": 834,
+    "apps/desktop/src-tauri/src/mcp/tools.rs": 846,
+    "apps/desktop/src-tauri/src/menu/mod.rs": 1000,
+    "apps/desktop/src-tauri/src/mtp/connection/mod.rs": 923,
+    "apps/desktop/src-tauri/src/network/manual_servers.rs": 1054,
+    "apps/desktop/src-tauri/src/search/engine.rs": 1298,
+    "apps/desktop/src-tauri/src/volumes/mod.rs": 986,
+    "apps/desktop/src-tauri/src/volumes_linux/mod.rs": 853,
+    "apps/desktop/src/lib/file-explorer/navigation/VolumeBreadcrumb.svelte": 1087,
+    "apps/desktop/src/lib/file-explorer/pane/DualPaneExplorer.svelte": 2450,
+    "apps/desktop/src/lib/file-explorer/pane/FilePane.svelte": 1965,
+    "apps/desktop/src/lib/file-operations/transfer/TransferProgressDialog.svelte": 1265,
+    "apps/desktop/src/lib/settings/sections/KeyboardShortcutsSection.svelte": 817,
+    "apps/desktop/src/lib/settings/settings-registry.ts": 911,
+    "apps/desktop/src/routes/viewer/+page.svelte": 968,
+    "apps/desktop/test/e2e-playwright/mtp.spec.ts": 976,
+    "scripts/check/checks/desktop-rust-cfg-gate_test.go": 976
+  }
+}

scripts/check/checks/file-length.go

@@ -2,6 +2,7 @@ package checks
 
 import (
 	"bufio"
+	"encoding/json"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -44,10 +45,31 @@ type longFile struct {
 	sizeBytes int64
 }
 
+// loadFileLengthAllowlist reads the allowlist JSON from the checks directory.
+// Returns a map of relative path → allowed line count.
+func loadFileLengthAllowlist(rootDir string) map[string]int {
+	// The allowlist lives next to the check source files
+	allowlistPath := filepath.Join(rootDir, "scripts", "check", "checks", "file-length-allowlist.json")
+	data, err := os.ReadFile(allowlistPath)
+	if err != nil {
+		return nil
+	}
+	var raw struct {
+		Files map[string]int `json:"files"`
+	}
+	if err := json.Unmarshal(data, &raw); err != nil {
+		return nil
+	}
+	return raw.Files
+}
+
 // RunFileLength scans the repo for source files exceeding the line count threshold.
+// Files in the allowlist are suppressed if at or below their allowlisted line count.
 // Always succeeds — reports long files as a warning, never fails.
 func RunFileLength(ctx *CheckContext) (CheckResult, error) {
+	allowlist := loadFileLengthAllowlist(ctx.RootDir)
 	var longFiles []longFile
+	allowlistedCount := 0
 
 	err := filepath.WalkDir(ctx.RootDir, func(path string, d os.DirEntry, err error) error {
 		if err != nil {
@@ -72,11 +94,18 @@ func RunFileLength(ctx *CheckContext) (CheckResult, error) {
 		}
 
 		if lineCount >= fileLengthWarnLines {
+			relPath, _ := filepath.Rel(ctx.RootDir, path)
+
+			// Check allowlist: suppress if at or below the allowlisted count
+			if allowedLines, ok := allowlist[relPath]; ok && lineCount <= allowedLines {
+				allowlistedCount++
+				return nil
+			}
+
 			info, err := d.Info()
 			if err != nil {
 				return nil
 			}
-			relPath, _ := filepath.Rel(ctx.RootDir, path)
 			longFiles = append(longFiles, longFile{
 				relPath:   relPath,
 				lines:     lineCount,
@@ -91,6 +120,9 @@ func RunFileLength(ctx *CheckContext) (CheckResult, error) {
 	}
 
 	if len(longFiles) == 0 {
+		if allowlistedCount > 0 {
+			return Success(fmt.Sprintf("No new long files (%d allowlisted)", allowlistedCount)), nil
+		}
 		return Success("All files under threshold"), nil
 	}
 
@@ -109,13 +141,23 @@ func RunFileLength(ctx *CheckContext) (CheckResult, error) {
 			color = ansiRed
 		}
 
+		// Show if this file exceeded its allowlisted count
+		if allowedLines, ok := allowlist[f.relPath]; ok {
+			detail = fmt.Sprintf("(%d lines, allowlist: %d, %d kB, ~%s tokens)", f.lines, allowedLines, sizeKB, tokenStr)
+		}
+
 		sb.WriteString(fmt.Sprintf("  - %s %s%s%s\n", f.relPath, color, detail, ansiReset))
 	}
 
-	msg := fmt.Sprintf("%d %s over %d lines:\n%s",
+	suffix := ""
+	if allowlistedCount > 0 {
+		suffix = fmt.Sprintf(" (%d allowlisted)", allowlistedCount)
+	}
+	msg := fmt.Sprintf("%d new %s over %d lines%s:\n%s",
 		len(longFiles),
 		Pluralize(len(longFiles), "file", "files"),
 		fileLengthWarnLines,
+		suffix,
 		strings.TrimRight(sb.String(), "\n"),
 	)
 

scripts/check/checks/file-length_test.go

@@ -1,6 +1,7 @@
 package checks
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
@@ -227,7 +228,116 @@ func TestRunFileLength_MessageFormat(t *testing.T) {
 	if !strings.Contains(result.Message, "~1k tokens") {
 		t.Errorf("expected '~1k tokens' in message, got: %s", result.Message)
 	}
-	if !strings.Contains(result.Message, "1 file over 800 lines") {
-		t.Errorf("expected '1 file over 800 lines' in summary, got: %s", result.Message)
+	if !strings.Contains(result.Message, "1 new file over 800 lines") {
+		t.Errorf("expected '1 new file over 800 lines' in summary, got: %s", result.Message)
+	}
+}
+
+func writeAllowlist(t *testing.T, dir string, files map[string]int) {
+	t.Helper()
+	checksDir := filepath.Join(dir, "scripts", "check", "checks")
+	if err := os.MkdirAll(checksDir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	// Build JSON manually to keep it simple
+	var sb strings.Builder
+	sb.WriteString(`{"files":{`)
+	first := true
+	for path, lines := range files {
+		if !first {
+			sb.WriteString(",")
+		}
+		sb.WriteString(fmt.Sprintf(`"%s":%d`, path, lines))
+		first = false
+	}
+	sb.WriteString("}}")
+	if err := os.WriteFile(filepath.Join(checksDir, "file-length-allowlist.json"), []byte(sb.String()), 0644); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestRunFileLength_AllowlistSuppresses(t *testing.T) {
+	tmp := t.TempDir()
+
+	// Create a long file
+	path := filepath.Join(tmp, "big.go")
+	if err := os.WriteFile(path, []byte(strings.Repeat("line\n", 900)), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	// Allowlist it at 900 lines
+	writeAllowlist(t, tmp, map[string]int{"big.go": 900})
+
+	ctx := &CheckContext{RootDir: tmp}
+	result, err := RunFileLength(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Code != ResultSuccess {
+		t.Errorf("expected success (file is allowlisted), got code %d: %s", result.Code, result.Message)
+	}
+	if !strings.Contains(result.Message, "1 allowlisted") {
+		t.Errorf("expected '1 allowlisted' in message, got: %s", result.Message)
+	}
+}
+
+func TestRunFileLength_AllowlistExceeded(t *testing.T) {
+	tmp := t.TempDir()
+
+	// Create a file that exceeds its allowlist
+	path := filepath.Join(tmp, "grew.go")
+	if err := os.WriteFile(path, []byte(strings.Repeat("line\n", 950)), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	// Allowlist it at 900 (but it's 950 now)
+	writeAllowlist(t, tmp, map[string]int{"grew.go": 900})
+
+	ctx := &CheckContext{RootDir: tmp}
+	result, err := RunFileLength(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Code != ResultWarning {
+		t.Errorf("expected warning (file exceeded allowlist), got code %d", result.Code)
+	}
+	if !strings.Contains(result.Message, "grew.go") {
+		t.Errorf("expected 'grew.go' in message, got: %s", result.Message)
+	}
+	if !strings.Contains(result.Message, "allowlist: 900") {
+		t.Errorf("expected 'allowlist: 900' in message, got: %s", result.Message)
+	}
+}
+
+func TestRunFileLength_NewFileNotInAllowlist(t *testing.T) {
+	tmp := t.TempDir()
+
+	// Create a long file NOT in the allowlist
+	path := filepath.Join(tmp, "new.go")
+	if err := os.WriteFile(path, []byte(strings.Repeat("line\n", 850)), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	// Empty allowlist
+	writeAllowlist(t, tmp, map[string]int{})
+
+	ctx := &CheckContext{RootDir: tmp}
+	result, err := RunFileLength(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Code != ResultWarning {
+		t.Errorf("expected warning (new file not allowlisted), got code %d", result.Code)
+	}
+	if !strings.Contains(result.Message, "new.go") {
+		t.Errorf("expected 'new.go' in message, got: %s", result.Message)
+	}
+}
+
+func TestLoadFileLengthAllowlist_Missing(t *testing.T) {
+	tmp := t.TempDir()
+	result := loadFileLengthAllowlist(tmp)
+	if result != nil {
+		t.Errorf("expected nil for missing allowlist, got %v", result)
 	}
 }