lazy backend boot and rename workspace to project

Backend isolate now boots in two phases: resolve toolchain on spawn
(binary availability only), initialize services on project.open. The
dispatcher stays empty until a project activates — IPC requests before
that return "No project active".

Scheduler ticker only runs while a project is open. Fires an immediate
first cycle on ProjectOpened so sidebar panels refresh without waiting
for the next interval. Stops on ProjectClosed.

Renamed workspace → project throughout backend messages
(project.validate, project.open, project.ready), callbacks
(onProjectOpen, onValidateProject), and methods
(openProject, validateProject, resolveProject).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

lib/kernel/src/backend.dart

@@ -1,8 +1,8 @@
 /// Manages the backend isolate lifecycle.
 ///
-/// Call [spawn] to start the backend, which resolves the toolchain and
-/// boots all daemon services in a separate isolate. Returns when the
-/// backend is ready to accept requests.
+/// Two-phase boot:
+///   1. [spawn] — starts the isolate, resolves toolchain (binary checks only).
+///   2. [openWorkspace] — initializes services for a specific project root.
 library;
 
 import 'dart:async';
@@ -16,36 +16,44 @@ class Backend {
   Backend._({
     required this.client,
     required this.toolchain,
+    required SendPort backendRequestPort,
     required Isolate isolate,
     required ReceivePort receivePort,
-  })  : _isolate = isolate,
+  })  : _backendRequestPort = backendRequestPort,
+        _isolate = isolate,
         _receivePort = receivePort;
 
   final IsolateClient client;
   final Toolchain toolchain;
+  final SendPort _backendRequestPort;
   final Isolate _isolate;
   final ReceivePort _receivePort;
 
-  /// Spawn the backend isolate and wait for it to be ready.
+  Completer<void>? _projectCompleter;
+  final Map<String, Completer<String?>> _validateCompleters = {};
+  int _validateId = 0;
+
+  /// Spawn the backend isolate. Returns when the toolchain is resolved.
+  /// No services are active yet — call [openWorkspace] to activate.
   static Future<Backend> spawn({
-    required String workspaceRoot,
     required IsolateClient Function(SendPort backendPort) clientFactory,
+    String? hintRoot,
   }) async {
     final receivePort = ReceivePort();
     final completer = Completer<Backend>();
 
     late final IsolateClient client;
     late final Isolate isolate;
+    late final SendPort backendRequestPort;
+    late final Backend backend;
 
     receivePort.listen((message) {
       if (message is Map<String, Object?>) {
         final type = message['type'] as String?;
         if (type == 'ready') {
-          // Backend is booted — extract its request port and toolchain state.
-          final requestPort = message['requestPort'] as SendPort;
-          client = clientFactory(requestPort);
+          backendRequestPort = message['requestPort'] as SendPort;
+          client = clientFactory(backendRequestPort);
 
-          // Apply toolchain state from the backend.
           final tcData = message['toolchain'] as Map<String, Object?>;
           final toolchain = Toolchain();
           toolchain.applyResolved(ResolvedPaths(
@@ -57,14 +65,33 @@ class Backend {
             gitEnv: (tcData['gitEnv'] as Map?)?.cast<String, String>(),
           ));
 
-          if (!completer.isCompleted) {
-            completer.complete(Backend._(
-              client: client,
-              toolchain: toolchain,
-              isolate: isolate,
-              receivePort: receivePort,
-            ));
-          }
+          backend = Backend._(
+            client: client,
+            toolchain: toolchain,
+            backendRequestPort: backendRequestPort,
+            isolate: isolate,
+            receivePort: receivePort,
+          );
+
+          if (!completer.isCompleted) completer.complete(backend);
+        } else if (type == 'project.validated') {
+          final id = message['id'] as String;
+          final root = message['root'] as String?;
+          final c = backend._validateCompleters.remove(id);
+          if (c != null && !c.isCompleted) c.complete(root);
+        } else if (type == 'project.ready') {
+          // Update toolchain with project-specific paths.
+          final tcData = message['toolchain'] as Map<String, Object?>;
+          backend.toolchain.applyResolved(ResolvedPaths(
+            git: tcData['git'] as String?,
+            pql: tcData['pql'] as String?,
+            tmux: tcData['tmux'] as String?,
+            ptyc: tcData['ptyc'] as String?,
+            shell: tcData['shell'] as String?,
+            gitEnv: (tcData['gitEnv'] as Map?)?.cast<String, String>(),
+          ));
+          backend._projectCompleter?.complete();
+          backend._projectCompleter = null;
         } else {
           // Response or event — forward to the client.
           client.handleMessage(message);
@@ -74,15 +101,37 @@ class Backend {
 
     isolate = await Isolate.spawn(
       backendEntry,
-      BackendBootMessage(
-        frontendPort: receivePort.sendPort,
-        workspaceRoot: workspaceRoot,
-      ),
+      BackendBootMessage(frontendPort: receivePort.sendPort, hintRoot: hintRoot),
     );
 
     return completer.future;
   }
 
+  /// Validate a path as a git repo. Returns the repo root or null.
+  /// Runs git rev-parse in the backend isolate (no main-thread I/O).
+  Future<String?> validateProject(String path) {
+    final id = '${_validateId++}';
+    final c = Completer<String?>();
+    _validateCompleters[id] = c;
+    _backendRequestPort.send({
+      'type': 'project.validate',
+      'path': path,
+      'id': id,
+    });
+    return c.future;
+  }
+
+  /// Activate a project. The backend (re)initializes all services
+  /// for the given root directory. Returns when services are ready.
+  Future<void> openProject(String path) {
+    _projectCompleter = Completer<void>();
+    _backendRequestPort.send({
+      'type': 'project.open',
+      'path': path,
+    });
+    return _projectCompleter!.future;
+  }
+
   /// Shut down the backend isolate.
   void dispose() {
     _isolate.kill(priority: Isolate.beforeNextEvent);

lib/kernel/src/backend_entry.dart

@@ -1,8 +1,11 @@
 /// Backend isolate entry point.
 ///
-/// Boots the daemon dispatcher, toolchain, and all subprocess services.
-/// Communicates with the main isolate via SendPort (responses + events)
-/// and ReceivePort (incoming requests).
+/// Two-phase boot:
+///   1. Resolve toolchain (find binaries) → report ready.
+///   2. On `project.open` message → initialize services for the project.
+///
+/// The dispatcher only registers command handlers after a project is
+/// activated. IPC requests arriving before that get an error response.
 library;
 
 import 'dart:io';
@@ -16,80 +19,131 @@ import 'package:clide/src/daemon/git_commands.dart';
 import 'package:clide/src/daemon/pane_commands.dart';
 import 'package:clide/src/daemon/pql_commands.dart';
 import 'package:clide/src/editor/registry.dart' show EditorRegistry;
-import 'package:clide/src/daemon/files_commands.dart' show FilesService;
 import 'package:clide/src/git/client.dart';
 import 'package:clide/src/ipc/envelope.dart';
+import 'package:clide/src/ipc/schema_v1.dart';
 import 'package:clide/src/panes/event_sink.dart';
 import 'package:clide/src/panes/registry.dart';
 import 'package:clide/src/pql/client.dart';
 
 /// Message sent from main isolate to bootstrap the backend.
 class BackendBootMessage {
-  const BackendBootMessage({
-    required this.frontendPort,
-    required this.workspaceRoot,
-  });
+  const BackendBootMessage({required this.frontendPort, this.hintRoot});
   final SendPort frontendPort;
-  final String workspaceRoot;
+  /// Optional path hint for initial toolchain resolution (e.g. CLIDE_WORKSPACE).
+  /// Used to find project-local binaries like dugite before a project opens.
+  final String? hintRoot;
 }
 
 /// Top-level entry point for the backend isolate.
 void backendEntry(BackendBootMessage boot) {
   final frontendPort = boot.frontendPort;
-  final workspaceRoot = boot.workspaceRoot;
-
-  // Set up the receive port for incoming requests from the frontend.
   final requestPort = ReceivePort();
-
-  // Resolve toolchain (file I/O — safe here, not on UI thread).
-  final toolchain = Toolchain();
-  toolchain.applyResolved(resolveToolchainPaths(workspaceRoot));
-
-  // Boot the dispatcher and all services.
-  final dispatcher = DaemonDispatcher();
   final eventSink = _IsolateEventSink(frontendPort);
-  final workDir = Directory(workspaceRoot);
+  final dispatcher = DaemonDispatcher();
+  late Toolchain toolchain;
 
-  final filesService = FilesService(root: workDir, events: eventSink);
-  registerFilesCommands(dispatcher, filesService);
+  // Phase 1: resolve toolchain — just find binaries, don't init services.
+  // We need a project root for ptyc/dugite paths. Use a sensible
+  // default; the real project comes from project.open.
+  final resolveRoot = boot.hintRoot ?? Platform.environment['HOME'] ?? '/tmp';
+  toolchain = Toolchain();
+  toolchain.applyResolved(resolveToolchainPaths(resolveRoot));
 
-  final editorRegistry = EditorRegistry(events: eventSink, workspaceRoot: workDir);
-  registerEditorCommands(dispatcher, editorRegistry);
-
-  final gitClient = GitClient(toolchain: toolchain, workDir: workDir);
-  registerGitCommands(dispatcher, gitClient, eventSink);
-
-  final pql = PqlClient(workDir: workDir, toolchain: toolchain);
-  registerPqlCommands(dispatcher, pql);
-
-  final paneRegistry = PaneRegistry(events: eventSink);
-  registerPaneCommands(dispatcher, paneRegistry, toolchain: toolchain);
-
-  // Listen for requests from the frontend.
+  // Listen for messages from the frontend.
   requestPort.listen((message) async {
-    if (message is Map<String, Object?>) {
+    if (message is! Map<String, Object?>) return;
+    final type = message['type'] as String?;
+
+    if (type == 'project.validate') {
+      // Validate a path as a git repo. Runs git rev-parse in the backend
+      // isolate (safe from the merged thread). Returns the repo root or null.
+      final path = message['path'] as String;
+      final id = message['id'] as String;
+      try {
+        final r = await Process.run(toolchain.git, ['rev-parse', '--show-toplevel'],
+            workingDirectory: path, environment: toolchain.gitEnv);
+        if (r.exitCode == 0) {
+          final root = (r.stdout as String).trim();
+          frontendPort.send({'type': 'project.validated', 'id': id, 'root': root});
+        } else {
+          frontendPort.send({'type': 'project.validated', 'id': id, 'root': null});
+        }
+      } catch (_) {
+        frontendPort.send({'type': 'project.validated', 'id': id, 'root': null});
+      }
+    } else if (type == 'project.open') {
+      // Phase 2: (re)initialize services for the given project.
+      final projectPath = message['path'] as String;
+      final workDir = Directory(projectPath);
+
+      // Re-resolve toolchain with the actual project root (finds
+      // dugite in native/dugite/, ptyc in ptyc/bin/, etc.)
+      toolchain = Toolchain();
+      toolchain.applyResolved(resolveToolchainPaths(projectPath));
+
+      // Clear existing handlers and re-register with new project.
+      dispatcher.clear();
+
+      final filesService = FilesService(root: workDir, events: eventSink);
+      registerFilesCommands(dispatcher, filesService);
+
+      final editorRegistry = EditorRegistry(events: eventSink, workspaceRoot: workDir);
+      registerEditorCommands(dispatcher, editorRegistry);
+
+      final gitClient = GitClient(toolchain: toolchain, workDir: workDir);
+      registerGitCommands(dispatcher, gitClient, eventSink);
+
+      final pql = PqlClient(workDir: workDir, toolchain: toolchain);
+      registerPqlCommands(dispatcher, pql);
+
+      final paneRegistry = PaneRegistry(events: eventSink);
+      registerPaneCommands(dispatcher, paneRegistry, toolchain: toolchain);
+
+      // Tell the frontend the project is active.
+      frontendPort.send({
+        'type': 'project.ready',
+        'path': projectPath,
+        'toolchain': _serializeToolchain(toolchain),
+      });
+    } else {
+      // IPC request — dispatch if we have handlers.
       final req = IpcRequest.fromJson(message);
-      final resp = await dispatcher.dispatch(req);
-      frontendPort.send(resp.toJson());
+      if (dispatcher.isEmpty) {
+        frontendPort.send(IpcResponse.err(
+          id: req.id,
+          error: IpcError(
+            code: IpcExitCode.toolError,
+            kind: IpcErrorKind.toolError,
+            message: 'No project active',
+            hint: 'Open a project first',
+          ),
+        ).toJson());
+      } else {
+        final resp = await dispatcher.dispatch(req);
+        frontendPort.send(resp.toJson());
+      }
     }
   });
 
-  // Tell the frontend we're ready, and give it our request port.
+  // Send ready with toolchain state and request port.
   frontendPort.send({
     'type': 'ready',
     'requestPort': requestPort.sendPort,
-    'toolchain': {
-      'git': toolchain.git,
-      'pql': toolchain.pql,
-      'tmux': toolchain.tmux,
-      'ptyc': toolchain.ptyc,
-      'shell': toolchain.shell,
-      'gitEnv': toolchain.gitEnv,
-      'missing': toolchain.missing,
-    },
+    'toolchain': _serializeToolchain(toolchain),
   });
 }
 
+Map<String, Object?> _serializeToolchain(Toolchain tc) => {
+      'git': tc.git,
+      'pql': tc.pql,
+      'tmux': tc.tmux,
+      'ptyc': tc.ptyc,
+      'shell': tc.shell,
+      'gitEnv': tc.gitEnv,
+      'missing': tc.missing,
+    };
+
 /// Sends IPC events to the frontend via SendPort.
 class _IsolateEventSink implements DaemonEventSink {
   _IsolateEventSink(this._port);

lib/kernel/src/facade.dart

@@ -105,6 +105,8 @@ class KernelServices {
     DaemonClient? isolateClient,
     bool autoStartDaemonClient = true,
     Toolchain? toolchain,
+    Future<void> Function(String path)? onProjectOpen,
+    Future<String?> Function(String path)? onValidateProject,
   }) async {
     final log = Logger();
     final events = DaemonBus();
@@ -148,6 +150,8 @@ class KernelServices {
       events: events,
       settings: settings,
       toolchain: tc,
+      onProjectOpen: onProjectOpen,
+      onValidateProject: onValidateProject,
     );
     final ipc = isolateClient
         ?? (daemonClientFactory != null

lib/kernel/src/project.dart

@@ -49,15 +49,21 @@ class ProjectManager extends ChangeNotifier {
     required DaemonBus events,
     required SettingsStore settings,
     required Toolchain toolchain,
+    Future<void> Function(String path)? onProjectOpen,
+    Future<String?> Function(String path)? onValidateProject,
   })  : _log = log,
         _events = events,
         _settings = settings,
-        _toolchain = toolchain;
+        _toolchain = toolchain,
+        _onProjectOpen = onProjectOpen,
+        _onValidateProject = onValidateProject;
 
   final Logger _log;
   final DaemonBus _events;
   final SettingsStore _settings;
   final Toolchain _toolchain;
+  final Future<void> Function(String path)? _onProjectOpen;
+  final Future<String?> Function(String path)? _onValidateProject;
 
   Directory? _current;
   Directory? get current => _current;
@@ -81,12 +87,18 @@ class ProjectManager extends ChangeNotifier {
   }
 
   Future<bool> open(String path) async {
-    final root = await resolveWorkspace(path);
+    final root = await resolveProject(path);
     if (root == null) {
       _log.warn('project', 'not a git repo: $path');
       return false;
     }
     _current = Directory(root);
+
+    // Tell the backend isolate to (re)initialize services for this workspace.
+    if (_onProjectOpen != null) {
+      await _onProjectOpen!(root);
+    }
+
     await _settings.setProjectDir(_current);
     await _settings.set<String>('app.lastProject', root);
 
@@ -118,7 +130,13 @@ class ProjectManager extends ChangeNotifier {
     notifyListeners();
   }
 
-  Future<String?> resolveWorkspace(String path) async {
+  Future<String?> resolveProject(String path) async {
+    // Prefer backend validation (runs in the backend isolate, safe from
+    // the merged UI thread). Falls back to direct Process.run for tests
+    // and the CLI binary.
+    if (_onValidateProject != null) {
+      return _onValidateProject!(path);
+    }
     try {
       final r = await Process.run(_toolchain.git, ['rev-parse', '--show-toplevel'], workingDirectory: path, environment: _toolchain.gitEnv);
       if (r.exitCode != 0) return null;

lib/kernel/src/scheduler.dart

@@ -36,9 +36,27 @@ class SchedulerService {
   Isolate? _isolate;
   ReceivePort? _port;
   StreamSubscription<dynamic>? _sub;
+  StreamSubscription<dynamic>? _projectSub;
 
+  /// Listen for project lifecycle events. The periodic ticker only runs
+  /// while a project is open — no wasted cycles on the welcome screen.
   void start() {
-    if (_isolate != null) return;
+    _projectSub = _events.on<ProjectOpened>().listen((_) => _startTicker());
+    _events.on<ProjectClosed>().listen((_) => _stopTicker());
+  }
+
+  /// Start the periodic ticker and fire an immediate first cycle so
+  /// all panels refresh without waiting for the first interval.
+  void _startTicker() {
+    _stopTicker();
+
+    // Immediate first tick for all tiers.
+    for (final tier in SchedulerTier.values) {
+      if (tier == SchedulerTier.midnight) continue;
+      _events.emit(SchedulerTick(tier: tier));
+    }
+
+    // Then start the periodic isolate.
     _port = ReceivePort();
     _sub = _port!.listen((msg) {
       if (msg is String) {
@@ -49,6 +67,15 @@ class SchedulerService {
     Isolate.spawn(_isolateEntry, _port!.sendPort).then((iso) => _isolate = iso);
   }
 
+  void _stopTicker() {
+    _sub?.cancel();
+    _port?.close();
+    _isolate?.kill(priority: Isolate.immediate);
+    _isolate = null;
+    _port = null;
+    _sub = null;
+  }
+
   static void _isolateEntry(SendPort send) {
     int lastDay = DateTime.now().day;
     for (final tier in SchedulerTier.values) {
@@ -67,11 +94,7 @@ class SchedulerService {
   }
 
   void dispose() {
-    _sub?.cancel();
-    _port?.close();
-    _isolate?.kill(priority: Isolate.immediate);
-    _isolate = null;
-    _port = null;
-    _sub = null;
+    _projectSub?.cancel();
+    _stopTicker();
   }
 }