fix(ego-lint): reduce init-time safety false positives

Two changes to check-init.py:

1. Skip arrow function definitions at module scope — the body after =>
   is lazy (not executed at load time), so Shell globals in arrow fn
   bodies are not init-time violations.

2. Restrict constructor checks to extension.js only — helper file
   constructors are runtime-only (instantiated from enable()), matching
   the existing GObject constructor restriction.

Closes #15

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: ZviBaratz

CLAUDE.md

@@ -56,7 +56,7 @@ bash skills/ego-lint/scripts/ego-lint.sh tests/fixtures/<fixture-name>
 - `apply-patterns.py` — Tier 1 pattern engine (inline YAML parser, no PyYAML dependency). Supports `guard-pattern` + `guard-window` (sliding `deque` lookback) + `guard-window-forward` (forward peeking), `replacement-pattern`, `exclude-dirs`, version-gating, `fix-min-version` (suppresses fix text when extension min shell-version is below threshold), `skip-comments` (skips matches inside `//` and `/* */` comments)
 - `check-quality.py` — Tier 2 heuristic AI slop detection (try-catch density, impossible states, pendulum patterns, empty catches, _destroyed density, mock detection, constructor resources, run_dispose comment, clipboard disclosure, network disclosure, excessive null checks, repeated getSettings, obfuscated names, mixed indentation, excessive logging, code provenance)
 - `check-metadata.py` — JSON validity, required fields, UUID format/match, shell-version (with VALID_GNOME_VERSIONS allowlist), session-modes, settings-schema, version-name, donations, gettext-domain consistency
-- `check-init.py` — Init-time Shell modification, GObject constructor detection (extension.js only; all GI namespaces, GObject.registerClass exempt, GLib value types exempt), Gio._promisify placement
+- `check-init.py` — Init-time Shell modification (module-scope + extension.js constructors only; arrow function definitions exempt), GObject constructor detection (extension.js only; all GI namespaces, GObject.registerClass exempt, GLib value types exempt), Gio._promisify placement
 - `check-lifecycle.py` — enable/disable symmetry, signal cleanup (connectSmart/SignalTracker-aware), timeout removal verification, InjectionManager, lock screen signals, selective disable detection, unlock-dialog comment, clipboard+keybinding cross-ref, prototype override detection, pkexec target validation, Soup.Session abort, D-Bus export/unexport, bus name own/unown lifecycle, timeout reassignment, subprocess cancellation, clipboard+network cross-ref, widget lifecycle, settings cleanup
 - `check-prefs.py` — Preferences file validation (ExtensionPreferences base class, GTK4/Adwaita patterns, memory leak detection, supports `src/` layout)
 - `check-gobject.py` — GObject.registerClass patterns and GTypeName validation

skills/ego-lint/scripts/check-init.py

@@ -61,6 +61,15 @@ def is_skip_line(line):
     return False
 
 
+# Arrow function definitions: the body after => is lazy (not executed at
+# module scope).  Detect `const fn = (...) => expr` patterns.
+ARROW_FN_DEF = re.compile(
+    r'(?:const|let|var)\s+\w+\s*='   # variable assignment
+    r'(?:\([^)]*\)|\w+)'                 # parameter list or single param
+    r'\s*=>'                              # arrow
+)
+
+
 # Shell globals that should only be accessed inside enable()/disable()
 SHELL_GLOBALS = re.compile(
     r'\bMain\.(panel|overview|layoutManager|sessionMode|messageTray|wm|'
@@ -183,6 +192,10 @@ def check_init_modifications(ext_dir):
             if is_skip_line(line):
                 continue
             if SHELL_GLOBALS.search(line):
+                # Arrow function definitions are lazy — the body after =>
+                # is not executed at module scope
+                if ARROW_FN_DEF.search(line):
+                    continue
                 violations.append(f"{rel}:{lineno}")
             elif GOBJECT_CONSTRUCTORS.search(line):
                 # GObject.registerClass() returns a class, not an instance
@@ -191,17 +204,18 @@ def check_init_modifications(ext_dir):
                     violations.append(f"{rel}:{lineno}")
 
         # Check constructor() lines
-        # GObject constructors in helper file constructors are runtime-only
-        # (only run when instantiated from enable()), so only flag in extension.js
+        # Helper file constructors are runtime-only (only run when
+        # instantiated from enable()), so only flag in extension.js
         is_extension_js = os.path.basename(filepath) == 'extension.js'
-        ctor_lines = extract_constructor_lines(lines)
-        for lineno, line in ctor_lines:
-            if is_skip_line(line):
-                continue
-            if SHELL_GLOBALS.search(line):
-                violations.append(f"{rel}:{lineno}")
-            elif is_extension_js and GOBJECT_CONSTRUCTORS.search(line):
-                violations.append(f"{rel}:{lineno}")
+        if is_extension_js:
+            ctor_lines = extract_constructor_lines(lines)
+            for lineno, line in ctor_lines:
+                if is_skip_line(line):
+                    continue
+                if SHELL_GLOBALS.search(line):
+                    violations.append(f"{rel}:{lineno}")
+                elif GOBJECT_CONSTRUCTORS.search(line):
+                    violations.append(f"{rel}:{lineno}")
 
     if violations:
         for loc in violations:

tests/fixtures/init-time-safety@test/LICENSE

@@ -0,0 +1 @@
+SPDX-License-Identifier: GPL-2.0-or-later

tests/fixtures/init-time-safety@test/extension.js

@@ -0,0 +1,20 @@
+import {Extension} from 'resource:///org/gnome/shell/extensions/extension.js';
+import * as Main from 'resource:///org/gnome/shell/ui/main.js';
+
+// TRUE VIOLATION: module-scope Shell global access
+const primaryIdx = Main.layoutManager.primaryIndex;
+
+// OK: arrow function definition is lazy (body not executed at module scope)
+const getMonitors = () => Main.layoutManager.monitors;
+
+export default class InitTimeTest extends Extension {
+    enable() {
+        // OK: Shell globals inside enable()
+        Main.panel.addToStatusArea('test', this);
+        this._monitors = getMonitors();
+    }
+
+    disable() {
+        this._monitors = null;
+    }
+}

tests/fixtures/init-time-safety@test/helper.js

@@ -0,0 +1,15 @@
+import * as Main from 'resource:///org/gnome/shell/ui/main.js';
+
+// Helper class — constructor only runs when instantiated from enable()
+export class TilingManager {
+    constructor(monitorIndex) {
+        // Shell globals in helper constructor: OK (only called from enable())
+        this._workArea = Main.layoutManager.getWorkAreaForMonitor(monitorIndex);
+        this._monitors = Main.layoutManager.monitors;
+    }
+
+    destroy() {
+        this._workArea = null;
+        this._monitors = null;
+    }
+}

tests/fixtures/init-time-safety@test/metadata.json

@@ -0,0 +1,7 @@
+{
+    "uuid": "init-time-safety@test",
+    "name": "Init Time Safety Test",
+    "description": "Tests init-time Shell modification detection",
+    "shell-version": ["48"],
+    "url": "https://example.com"
+}

tests/run-tests.sh

@@ -191,6 +191,15 @@ assert_exit_code "exits with 1 (has failures)" 1
 assert_output_contains "fails on minified JS" "\[FAIL\].*minified-js"
 echo ""
 
+# --- init-time-safety ---
+echo "=== init-time-safety ==="
+run_lint "init-time-safety@test"
+assert_exit_code "exits with 1 (has module-scope violation)" 1
+assert_output_contains "fails on module-scope Main access" "\[FAIL\].*init/shell-modification"
+assert_output_not_contains "no FP on arrow function definition" "init/shell-modification.*helper.js"
+assert_output_not_contains "no FP on helper constructor" "init/shell-modification.*getMonitors"
+echo ""
+
 # --- lifecycle-imbalance ---
 echo "=== lifecycle-imbalance ==="
 run_lint "lifecycle-imbalance@test"