fix(desktop): ask-user dialog + migrate to pi-ask-user (prune connector, add tests) (#49)

* fix(desktop): show ask-user dialog immediately, notify only as reminder

On macOS the makit window reports itself backgrounded whenever it isn't
frontmost, so SrvRequestHandler diverted every srv.request to a transient
system notification instead of the in-app dialog — the popup flashed and
vanished with no way to answer.

Add a reminderDelay mode: when set (desktop), requests always present the
dialog immediately regardless of window focus, and only fire a system
notification if still unanswered after the delay (2 min). Timers are
cancelled on answer/dispose. Mobile behavior (background→notification) is
unchanged (reminderDelay null).

* refactor(server): drop makit-pi connector + pi-ask filter for pi-ask-user

pi-ask-user degrades to ctx.ui.select/input under rpc, which the PiAdapter
interceptor (Path B) already transports to the app. That makes makit's own
AskUserQuestion connector tool (Path A) redundant, and the @mammothb/pi-ask
exclusion a no-op now that it's uninstalled.

Remove:
- connectors/makit-pi.ts (AskUserQuestion/askUserQuestion shadow tool)
- connectors/makit-piano.ts (piano connector skeleton)
- src/pi-agent-dir.ts + the buildFilteredAgentDir(['@mammothb/pi-ask']) filter
  and PI_CODING_AGENT_DIR wiring

Keep the loopback bridge + extensionPaths (still used by test/e2e-server.ts:
StubAdapter reverse-RPC and the fake-model provider) and the askUser wiring
(Path B). No functional change to the ask_user flow.

* test(server): cover ask_user flow (e2e + integration + regression)

- e2e (test/ask-user-e2e.test.ts): real pi + pi-ask-user through PiAdapter
  with a hermetic keyless fake model; proves ask_user round-trips with no
  connector/bridge. Skips when pi/pi-ask-user are absent (e.g. cloud VM).
- integration (pi.test.ts): select/input/editor/confirm interceptor
  round-trips assert the exact extension_ui_response written to pi stdin.
- regression (pi.test.ts): cancelled→{cancelled}, no-askUser→cancel (pi never
  hangs after connector removal), detection keyed on method not tool name.

* fix: dismiss answered request dialogs

Author: leduckhc

app/lib/desktop/desktop_app.dart

@@ -233,6 +233,9 @@ class _DesktopAppState extends ConsumerState<_DesktopApp> {
       themeMode: ThemeMode.system,
       builder: (context, child) => SrvRequestHandler(
         navigatorKey: _desktopNavKey,
+        // Desktop is the control surface: always show the in-app dialog, and
+        // only fall back to a system notification if it goes unanswered.
+        reminderDelay: const Duration(minutes: 2),
         child: child ?? const SizedBox(),
       ),
       home: DesktopChatShell(onOpenSettings: _openSettings),

app/lib/ui/widgets/srv_request_handler.dart

@@ -20,10 +20,23 @@ import '../../store/store.dart';
 import '../../transport/protocol.dart';
 
 class SrvRequestHandler extends ConsumerStatefulWidget {
-  const SrvRequestHandler({super.key, required this.child, this.navigatorKey});
+  const SrvRequestHandler({
+    super.key,
+    required this.child,
+    this.navigatorKey,
+    this.reminderDelay,
+  });
   final Widget child;
   final GlobalKey<NavigatorState>? navigatorKey;
 
+  /// Desktop mode. When set, requests ALWAYS present the in-app dialog
+  /// immediately (never diverted to a notification based on foreground
+  /// state — the desktop window is the control surface). If the request is
+  /// still unanswered after this delay, a system notification is fired as a
+  /// reminder. When null (mobile), backgrounded requests are diverted to an
+  /// actionable notification instead of the invisible dialog.
+  final Duration? reminderDelay;
+
   @override
   ConsumerState<SrvRequestHandler> createState() => _SrvRequestHandlerState();
 }
@@ -42,6 +55,16 @@ class _SrvRequestHandlerState extends ConsumerState<SrvRequestHandler>
   final Map<String, Envelope> _pendingBackground = {};
   static const _kMaxPendingBackground = 50;
 
+  /// Desktop reminder timers, keyed by request id. Fires a system notification
+  /// when a dialog has been open (unanswered) for [SrvRequestHandler.reminderDelay];
+  /// cancelled when the request is answered or the widget disposes.
+  final Map<String, Timer> _reminderTimers = {};
+
+  /// Dialog contexts keyed by request id, so an answer from a notification can
+  /// remove that request's exact route without disturbing another open dialog.
+  final Map<String, BuildContext> _activeDialogContexts = {};
+  final Map<String, Object> _activeDialogTokens = {};
+
   /// Salted so request-notification ids can't collide with the status
   /// notifications keyed on `sessionId.hashCode`.
   int _notificationId(String requestId) =>
@@ -92,12 +115,86 @@ class _SrvRequestHandlerState extends ConsumerState<SrvRequestHandler>
     final controller = ref.read(connectionControllerProvider.notifier);
     _sub = controller.srvRequests.listen(_dispatch);
     _respondedSub?.cancel();
-    _respondedSub = controller.responded.listen(_pendingBackground.remove);
+    _respondedSub = controller.responded.listen(_onResponded);
+  }
+
+  void _onResponded(String id) {
+    _pendingBackground.remove(id);
+    _reminderTimers.remove(id)?.cancel();
+    _activeDialogTokens.remove(id);
+    final dialogContext = _activeDialogContexts.remove(id);
+    if (dialogContext == null || !dialogContext.mounted) return;
+    final route = ModalRoute.of(dialogContext);
+    if (route != null && route.isActive) {
+      Navigator.of(dialogContext).removeRoute(route);
+    }
+  }
+
+  Future<T?> _showTrackedDialog<T>({
+    required String requestId,
+    required BuildContext context,
+    required WidgetBuilder builder,
+    bool barrierDismissible = true,
+  }) async {
+    final dialogToken = Object();
+    final result = await showDialog<T>(
+      context: context,
+      barrierDismissible: barrierDismissible,
+      builder: (dctx) {
+        _activeDialogContexts[requestId] = dctx;
+        _activeDialogTokens[requestId] = dialogToken;
+        return builder(dctx);
+      },
+    );
+    if (identical(_activeDialogTokens[requestId], dialogToken)) {
+      _activeDialogTokens.remove(requestId);
+      _activeDialogContexts.remove(requestId);
+    }
+    return result;
+  }
+
+  /// Fire a system notification once a still-unanswered request has been
+  /// on-screen for [SrvRequestHandler.reminderDelay] (desktop only).
+  void _scheduleReminder(Envelope env, String kind) {
+    final sessionId = env.body['sessionId'] as String? ?? '';
+    _reminderTimers.remove(env.id)?.cancel();
+    _reminderTimers[env.id] = Timer(widget.reminderDelay!, () async {
+      _reminderTimers.remove(env.id);
+      if (!mounted) return;
+      final notif = notificationForRequest(
+        kind: kind,
+        body: env.body,
+        label: _labelFor(sessionId),
+      );
+      if (notif == null) return;
+      await ref
+          .read(notificationServiceProvider)
+          .show(
+            id: _notificationId(env.id),
+            title: notif.title,
+            body: notif.body,
+            category: notif.category,
+            payload: encodeRequestPayload(
+              sessionId: sessionId,
+              requestId: env.id,
+              kind: kind,
+            ),
+          );
+    });
   }
 
   Future<void> _dispatch(Envelope env) async {
     final kind = env.body['kind'] as String? ?? 'unknown';
 
+    // Desktop: always present the dialog now; if it goes unanswered for
+    // `reminderDelay`, nudge with a system notification (the tap routes back
+    // through respondTo, and the in-app dialog stays answerable meanwhile).
+    if (widget.reminderDelay != null) {
+      _scheduleReminder(env, kind);
+      await _presentDialog(env);
+      return;
+    }
+
     // Backgrounded: if this request kind has an actionable-notification
     // affordance, fire the notification and skip the (invisible) dialog. The
     // user resolves it from the lock screen; the tap routes back through
@@ -207,7 +304,8 @@ class _SrvRequestHandlerState extends ConsumerState<SrvRequestHandler>
     String requestId,
     List<Map<String, dynamic>> questions,
   ) async {
-    final result = await showDialog<Map<String, dynamic>?>(
+    final result = await _showTrackedDialog<Map<String, dynamic>?>(
+      requestId: requestId,
       context: ctx,
       barrierDismissible: false,
       builder: (dctx) => _AskWizard(questions: questions),
@@ -243,7 +341,8 @@ class _SrvRequestHandlerState extends ConsumerState<SrvRequestHandler>
     String requestId,
     Map<String, dynamic> body,
   ) async {
-    final approved = await showDialog<bool>(
+    final approved = await _showTrackedDialog<bool>(
+      requestId: requestId,
       context: ctx,
       barrierDismissible: false,
       builder: (dctx) => AlertDialog(
@@ -298,7 +397,8 @@ class _SrvRequestHandlerState extends ConsumerState<SrvRequestHandler>
       text: body['prefill']?.toString() ?? '',
     );
     final multiline = body['multiline'] == true;
-    final value = await showDialog<String?>(
+    final value = await _showTrackedDialog<String?>(
+      requestId: requestId,
       context: ctx,
       barrierDismissible: false,
       builder: (dctx) => AlertDialog(
@@ -333,7 +433,8 @@ class _SrvRequestHandlerState extends ConsumerState<SrvRequestHandler>
 
   Future<void> _showGeneric(BuildContext ctx, Envelope env) async {
     final controller = TextEditingController();
-    final text = await showDialog<String?>(
+    final text = await _showTrackedDialog<String?>(
+      requestId: env.id,
       context: ctx,
       builder: (dctx) => AlertDialog(
         title: Text(env.body['title']?.toString() ?? 'Server request'),
@@ -395,6 +496,12 @@ class _SrvRequestHandlerState extends ConsumerState<SrvRequestHandler>
     WidgetsBinding.instance.removeObserver(this);
     _sub?.cancel();
     _respondedSub?.cancel();
+    for (final t in _reminderTimers.values) {
+      t.cancel();
+    }
+    _reminderTimers.clear();
+    _activeDialogContexts.clear();
+    _activeDialogTokens.clear();
     super.dispose();
   }
 

app/test/srv_request_handler_notify_test.dart

@@ -104,6 +104,7 @@ void main() {
     WidgetTester tester, {
     _RecordingNotificationService? notifications,
     GlobalKey<NavigatorState>? navigatorKey,
+    Duration? reminderDelay,
   }) async {
     final transport = _EmittingTransport();
     final service = notifications ?? _RecordingNotificationService();
@@ -126,6 +127,7 @@ void main() {
           navigatorKey: key,
           home: SrvRequestHandler(
             navigatorKey: key,
+            reminderDelay: reminderDelay,
             child: const Scaffold(body: SizedBox()),
           ),
         ),
@@ -404,4 +406,112 @@ void main() {
       expect(otherId, isNot(firstId));
     },
   );
+
+  testWidgets(
+    'desktop mode shows the dialog immediately even when backgrounded',
+    (tester) async {
+      final (transport, notifications, _) = await pumpHandler(
+        tester,
+        reminderDelay: const Duration(minutes: 2),
+      );
+      // Not frontmost (as a macOS window often is while the agent runs).
+      tester.binding.handleAppLifecycleStateChanged(AppLifecycleState.paused);
+      await tester.pump();
+
+      transport.emit(
+        Envelope(
+          t: MsgType.srvRequest,
+          id: 'req-desk-q',
+          body: {
+            'kind': 'askUserQuestion',
+            'question': 'Deploy to prod?',
+            'options': [
+              {'label': 'Yes'},
+              {'label': 'No'},
+            ],
+            'sessionId': 's1',
+          },
+        ),
+      );
+      await tester.pump();
+      await tester.pump();
+
+      // No diversion to a notification while backgrounded — the dialog route
+      // is pushed instead. Settle its entrance animation to confirm it shows.
+      expect(notifications.shown, isEmpty);
+      tester.binding.handleAppLifecycleStateChanged(AppLifecycleState.resumed);
+      await tester.pumpAndSettle();
+      expect(find.byType(AlertDialog), findsOneWidget);
+      expect(find.text('Deploy to prod?'), findsOneWidget);
+      expect(notifications.shown, isEmpty);
+    },
+  );
+
+  testWidgets(
+    'desktop mode fires a reminder notification only if left unanswered',
+    (tester) async {
+      final (transport, notifications, _) = await pumpHandler(
+        tester,
+        reminderDelay: const Duration(minutes: 2),
+      );
+
+      transport.emit(
+        Envelope(
+          t: MsgType.srvRequest,
+          id: 'req-remind',
+          body: {
+            'kind': 'confirmAction',
+            'action': 'rm -rf build/',
+            'sessionId': 's1',
+          },
+        ),
+      );
+      await tester.pump();
+      await tester.pump();
+      expect(find.text('Approve'), findsOneWidget);
+      expect(notifications.shown, isEmpty);
+
+      // Past the reminder delay while still unanswered → notification fires.
+      await tester.pump(const Duration(minutes: 2));
+      await tester.pump();
+      expect(notifications.shown, hasLength(1));
+      expect(notifications.shown.single.category, kConfirmCategoryId);
+    },
+  );
+
+  testWidgets('desktop dialog closes and reminder is cancelled once answered', (
+    tester,
+  ) async {
+    final (transport, notifications, controller) = await pumpHandler(
+      tester,
+      reminderDelay: const Duration(minutes: 2),
+    );
+
+    transport.emit(
+      Envelope(
+        t: MsgType.srvRequest,
+        id: 'req-answered-fast',
+        body: {
+          'kind': 'confirmAction',
+          'action': 'rm -rf build/',
+          'sessionId': 's1',
+        },
+      ),
+    );
+    await tester.pump();
+    await tester.pump();
+
+    // Answered before the delay elapses.
+    controller.respondTo('req-answered-fast', {
+      'kind': 'confirmAction',
+      'approved': true,
+    });
+    await tester.pumpAndSettle();
+    expect(find.byType(AlertDialog), findsNothing);
+
+    // No reminder should fire after the delay.
+    await tester.pump(const Duration(minutes: 2));
+    await tester.pump();
+    expect(notifications.shown, isEmpty);
+  });
 }

docs/CONNECTORS.md

@@ -63,8 +63,8 @@ Adding a new variant:
 
 ## Writing a connector
 
-The working example is [`server/connectors/makit-pi.ts`](../server/connectors/makit-pi.ts).
-A drop-in template lives at [`server/connectors/makit-piano.ts`](../server/connectors/makit-piano.ts).
+No built-in connector is currently checked in. Use the minimum example below
+as the starting point for a new `server/connectors/<your-agent>.ts` file.
 
 A connector is a TypeScript file with a `default export` function that
 receives the agent's extension API. The function registers tools that:
@@ -124,7 +124,7 @@ Connectors are **auto-discovered** at server startup. Anything matching
 You'll see this in the server log:
 
 ```
-[makit] loading 2 connector(s): makit-pi.ts, makit-piano.ts
+[makit] loading 1 connector(s): my-agent.ts
 ```
 
 ## Environment contract

docs/NOTIFICATIONS.md

@@ -26,8 +26,8 @@ Requires a paired iPhone with notification permission granted.
 1. Pair the phone with a running `makit` server over Tailscale.
 2. Grant notification permission during onboarding (or Settings → Notifications).
 3. Open a session, then **background** the app (home button / swipe up).
-4. On the desktop, trigger a `confirmAction` (e.g. `piano_confirm` in
-   `server/connectors/makit-piano.ts`, or any agent tool that needs approval).
+4. On the desktop, trigger a `confirmAction` from any installed agent extension
+   or tool that needs approval (for Pi, this is a `ctx.ui.confirm` request).
 5. Within a few seconds the phone shows a notification with **Approve** and
    **Deny**.
 6. Tap **Approve** on the lock screen. The agent continues **without** opening