fix: refresh repos after adding a project on iOS home

The repo-centric home screen watches reposProvider, but project.add only
guaranteed a projects.snapshot update while repos.snapshot was fired
asynchronously on the server. After a fresh start, users could add a repo
successfully yet remain stuck on the empty state.

- Await repos.snapshot broadcast before acking project.add/remove on server
- Call refreshRepos after addProject/removeProject on the client
- Auto-trigger repo.refresh when projects grow but repos lag behind
- Teach FakeServer project.browse/project.add for the dev loop
- Add store controller tests for the refresh behaviour
- Allowlist cursoragent in CLA workflow for Cursor Cloud Agent commits

Co-authored-by: Milan Le <leduckhc@users.noreply.github.com>

Author: leduckhc

.github/workflows/cla.yml

@@ -30,7 +30,8 @@ jobs:
           # Bots don't need to sign. The solo repo owner is exempt too — the
           # project owner needn't sign their own CLA, and it avoids the action
           # trying to commit a signature file to the protected `main` branch.
-          allowlist: leduckhc,dependabot[bot],github-actions[bot],*bot
+          # `cursoragent` is the Cursor Cloud Agent committer identity.
+          allowlist: leduckhc,cursoragent,dependabot[bot],github-actions[bot],*bot
 
           # Text shown to contributors.
           custom-notsigned-prcomment: "Thank you for your contribution! Before we can merge it, please read our [Contributor License Agreement](https://github.com/leduckhc/makit/blob/main/CLA.md) and sign it by posting the comment below."

app/lib/store/fake_server.dart

@@ -18,6 +18,7 @@ class FakeServer {
   Stream<Envelope> get outgoing => _outCtrl.stream;
 
   final Map<String, _FakeSession> _sessions = {};
+  final Map<String, String> _addedProjects = {};
   Timer? _seedTimer;
 
   void start() {
@@ -108,6 +109,18 @@ class FakeServer {
         },
       );
     }
+    for (final entry in _addedProjects.entries) {
+      projects.putIfAbsent(
+        entry.key,
+        () => {
+          'id': entry.key,
+          'name': entry.value.split('/').where((s) => s.isNotEmpty).last,
+          'path': entry.value,
+          'pinned': false,
+          'lastActivityAt': DateTime.now().millisecondsSinceEpoch,
+        },
+      );
+    }
     _emit(
       Envelope(
         t: MsgType.event,
@@ -127,10 +140,26 @@ class FakeServer {
     for (final s in _sessions.values) {
       byProject.putIfAbsent(s.projectId, () => []).add(s);
     }
+    for (final entry in _addedProjects.entries) {
+      byProject.putIfAbsent(entry.key, () => []);
+    }
 
     final repos = <Map<String, dynamic>>[];
     byProject.forEach((pid, sess) {
-      final first = sess.first;
+      final first = sess.isNotEmpty
+          ? sess.first
+          : _FakeSession(
+              id: '',
+              projectId: pid,
+              projectName: _addedProjects[pid]!
+                  .split('/')
+                  .where((s) => s.isNotEmpty)
+                  .last,
+              projectPath: _addedProjects[pid]!,
+              agent: 'pi',
+              title: '',
+              preview: '',
+            );
       final repoPath = first.projectPath;
       // Split sessions across two worktrees for a realistic demo.
       final primaryIds = sess
@@ -249,6 +278,12 @@ class FakeServer {
       case 'session.spawn':
         _spawnPending(env);
         return;
+      case 'project.browse':
+        _browse(env);
+        return;
+      case 'project.add':
+        _addProject(env);
+        return;
       case 'repo.refresh':
         _emit(Envelope(t: MsgType.ack, id: env.id));
         _pushRepos();
@@ -287,8 +322,6 @@ class FakeServer {
     }
   }
 
-  /// Create a draft (pending) session in a project, mirroring the real server's
-  /// deferred-worktree flow.
   void _spawnPending(Envelope env) {
     final pid = env.body['projectId'] as String? ?? '';
     final agent = env.body['agent'] as String? ?? 'pi';
@@ -312,6 +345,45 @@ class FakeServer {
     _pushRepos();
   }
 
+  void _browse(Envelope env) {
+    final path = env.body['path'] as String? ?? '/Users/demo';
+    _emit(
+      Envelope(
+        t: MsgType.ack,
+        id: env.id,
+        body: {
+          'path': path,
+          'parent': path == '/'
+              ? null
+              : path.replaceAll(RegExp(r'/[^/]+$'), ''),
+          'entries': [
+            {'name': 'makit', 'path': '$path/makit', 'isRepo': true},
+            {'name': 'notes', 'path': '$path/notes', 'isRepo': false},
+          ],
+        },
+      ),
+    );
+  }
+
+  void _addProject(Envelope env) {
+    final path = env.body['path'] as String? ?? '';
+    if (path.isEmpty) {
+      _emit(
+        Envelope(
+          t: MsgType.err,
+          id: env.id,
+          body: {'message': 'project.add requires a string `path`'},
+        ),
+      );
+      return;
+    }
+    final id = 'proj-added-${_addedProjects.length + 1}';
+    _addedProjects[id] = path;
+    _emit(Envelope(t: MsgType.ack, id: env.id, body: {'projectId': id}));
+    _pushProjects();
+    _pushRepos();
+  }
+
   String _slugify(String text) => text
       .toLowerCase()
       .replaceAll(RegExp(r'[^a-z0-9\s-]'), ' ')

app/lib/store/store.dart

@@ -232,7 +232,18 @@ class StoreController extends StateNotifier<StoreState> {
     if (env.t != MsgType.event) return;
     final decoded = WireCodec.decode(env);
     if (decoded == null) return;
+    final prev = state;
     state = reduce(state, decoded);
+    // The home screen is repo-centric. `project.add` always pushes a fresh
+    // `projects.snapshot`, but `repos.snapshot` is computed asynchronously on
+    // the server and can arrive late or be dropped — leaving the UI stuck on
+    // "No repos yet" after a successful add. Re-fetch when projects grew but
+    // repos haven't caught up yet.
+    if (decoded is ProjectsSnapshot &&
+        state.projects.length > prev.projects.length &&
+        state.projects.length > state.repos.length) {
+      unawaited(refreshRepos());
+    }
   }
 
   /// Currently-subscribed sessionIds. We replay these on every reconnect.
@@ -413,14 +424,15 @@ class StoreController extends StateNotifier<StoreState> {
   }
 
   /// Register a new project rooted at [path]. Resolves with the new project id
-  /// once the server acks; the fresh `projects.snapshot` updates the store.
+  /// once the server acks; the fresh `repos.snapshot` updates the home screen.
   Future<String> addProject(String path) async {
     final ack = await _ref.read(connectionControllerProvider.notifier).request(
       MsgType.cmd,
       {'kind': 'project.add', 'path': path},
     );
     final id = ack['projectId'] as String?;
     if (id == null) throw StateError('server did not return projectId');
+    await refreshRepos();
     return id;
   }
 
@@ -431,6 +443,7 @@ class StoreController extends StateNotifier<StoreState> {
       MsgType.cmd,
       {'kind': 'project.remove', 'projectId': id},
     );
+    await refreshRepos();
   }
 
   /// Ask the server to recompute + rebroadcast the repo snapshot (git/gh

app/test/store_reducer_test.dart

@@ -248,6 +248,109 @@ void main() {
       expect(sub.body['fromSeq'], 0);
     });
   });
+
+  group('StoreController — repo refresh after project add', () {
+    test(
+      'projects snapshot growth triggers repo.refresh when repos lag',
+      () async {
+        final transport = _SnapshotTransport();
+        final container = ProviderContainer(
+          overrides: [
+            connectionControllerProvider.overrideWith(
+              (ref) => ConnectionController(
+                _FakeStorage({
+                  'paired_server': jsonEncode({
+                    'host': '192.168.1.10',
+                    'port': 8443,
+                    'fingerprint': 'f' * 64,
+                    'bearer': 'b',
+                    'label': 'desktop',
+                  }),
+                }),
+                transportFactory: () => transport,
+                browseLan:
+                    ({Duration timeout = const Duration(seconds: 3)}) async =>
+                        const [],
+                rediscoverStall: const Duration(seconds: 30),
+              ),
+            ),
+          ],
+        );
+        addTearDown(container.dispose);
+
+        container.read(storeControllerProvider);
+        await Future<void>.delayed(Duration.zero);
+
+        transport.pushSnapshot(
+          Envelope(
+            t: MsgType.event,
+            id: 'snap-projects',
+            body: {
+              'kind': 'projects.snapshot',
+              'projects': [
+                {
+                  'id': 'p-new',
+                  'name': 'makit',
+                  'path': '/repo/makit',
+                  'pinned': false,
+                  'lastActivityAt': 1,
+                },
+              ],
+            },
+          ),
+        );
+        await Future<void>.delayed(Duration.zero);
+
+        expect(
+          transport.sent.any(
+            (e) => e.t == MsgType.cmd && e.body['kind'] == 'repo.refresh',
+          ),
+          isTrue,
+        );
+      },
+    );
+
+    test('addProject requests repo.refresh after server ack', () async {
+      final transport = _SnapshotTransport();
+      final container = ProviderContainer(
+        overrides: [
+          connectionControllerProvider.overrideWith(
+            (ref) => ConnectionController(
+              _FakeStorage({
+                'paired_server': jsonEncode({
+                  'host': '192.168.1.10',
+                  'port': 8443,
+                  'fingerprint': 'f' * 64,
+                  'bearer': 'b',
+                  'label': 'desktop',
+                }),
+              }),
+              transportFactory: () => transport,
+              browseLan:
+                  ({Duration timeout = const Duration(seconds: 3)}) async =>
+                      const [],
+              rediscoverStall: const Duration(seconds: 30),
+            ),
+          ),
+        ],
+      );
+      addTearDown(container.dispose);
+
+      final store = container.read(storeControllerProvider.notifier);
+      await Future<void>.delayed(Duration.zero);
+
+      final addFuture = store.addProject('/repo/makit');
+      await Future<void>.delayed(Duration.zero);
+      await addFuture;
+
+      expect(
+        transport.sent.where(
+          (e) => e.t == MsgType.cmd && e.body['kind'] == 'repo.refresh',
+        ),
+        isNotEmpty,
+      );
+    });
+  });
 }
 
 /// Transport fake that records outgoing envelopes and lets a test inject
@@ -302,6 +405,48 @@ class _CapturingTransport implements Transport {
   void forceReconnect() {}
 }
 
+/// Transport that auto-acks cmd requests and lets tests inject snapshot events.
+class _SnapshotTransport implements Transport {
+  final sent = <Envelope>[];
+  final _frames = StreamController<Envelope>.broadcast();
+  final _state = StreamController<WsState>.broadcast();
+
+  void pushSnapshot(Envelope env) => _frames.add(env);
+
+  @override
+  Future<void> connect(
+    String url, {
+    Map<String, dynamic> helloBody = const {},
+    String? pinnedFingerprint,
+  }) async {
+    _state.add(WsState.connected);
+  }
+
+  @override
+  Future<void> close() async {}
+
+  @override
+  Stream<Envelope> get frames => _frames.stream;
+
+  @override
+  Stream<WsState> get state => _state.stream;
+
+  @override
+  void sendEnvelope(Envelope env) {
+    sent.add(env);
+    if (env.t == MsgType.cmd) {
+      final kind = env.body['kind'];
+      final body = kind == 'project.add'
+          ? {'projectId': 'p-new'}
+          : <String, dynamic>{};
+      _frames.add(Envelope(t: MsgType.ack, id: env.id, body: body));
+    }
+  }
+
+  @override
+  void forceReconnect() {}
+}
+
 class _FakeStorage extends FlutterSecureStorage {
   _FakeStorage(this.data) : super();
   final Map<String, String> data;

server/src/server.ts

@@ -443,7 +443,7 @@ export function startWsServer(opts: ServerOpts) {
       }
       const project = manager.addProject(full);
       broadcastSnapshots();
-      void broadcastReposSnapshot();
+      await broadcastReposSnapshot();
       ctx.ack({ projectId: project.id });
     });
 
@@ -460,7 +460,7 @@ export function startWsServer(opts: ServerOpts) {
         return;
       }
       broadcastSnapshots();
-      void broadcastReposSnapshot();
+      await broadcastReposSnapshot();
       ctx.ack({});
     });