add Dart core package — IPC envelopes, daemon, ping round-trip

First real content for the `clide` Dart package at the repo root.
One AOT-compiled binary (ADR 0005) with two modes:

  * `clide --daemon`  long-running unix-socket server; listens on
    `$XDG_RUNTIME_DIR/clide-$USER.sock` with stale-socket
    reclaim, accepts JSON-lines request/response traffic, clean
    SIGTERM shutdown unlinks the socket file.
  * `clide <subcommand>`  one-shot; opens the socket, sends a
    request, writes the response JSON to stdout, exits with the
    dispatcher's error code per ADR 0006 (0/1/2/3/4). Unknown
    subcommands forward to the daemon so extensions can register
    their own without CLI changes.

Tier 0 handlers: `ping` (returns pong + version + UTC ts) and
`version`. Both are covered by `test/ipc/` + `test/daemon/`; the
subprocess test builds `bin/clide`, starts it, pings it, SIGTERMs
it, and asserts the socket file disappears.

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

test/daemon/in_process_test.dart

@@ -0,0 +1,123 @@
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:clide/clide.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('DaemonServer (in-process)', () {
+    late DaemonServer server;
+    late DaemonDispatcher dispatcher;
+    late String socketPath;
+
+    setUp(() async {
+      final tmp = await Directory.systemTemp.createTemp('clide_daemon_');
+      socketPath = '${tmp.path}/daemon.sock';
+      dispatcher = DaemonDispatcher();
+      server = DaemonServer(
+        socketPath: socketPath,
+        dispatch: dispatcher.dispatch,
+      );
+      await server.start();
+    });
+
+    tearDown(() async {
+      await server.stop();
+    });
+
+    test('ping round-trips with pong=true', () async {
+      final resp = await _send(
+        socketPath,
+        IpcRequest(id: '1', cmd: 'ping').encode(),
+      );
+      final parsed = IpcMessage.decode(resp) as IpcResponse;
+      expect(parsed.ok, true);
+      expect(parsed.id, '1');
+      expect(parsed.data['pong'], true);
+      expect(parsed.data['ts'], isA<String>());
+      expect(parsed.data['version'], isA<String>());
+    });
+
+    test('version returns current clideVersion', () async {
+      final resp = await _send(
+        socketPath,
+        IpcRequest(id: 'v', cmd: 'version').encode(),
+      );
+      final parsed = IpcMessage.decode(resp) as IpcResponse;
+      expect(parsed.ok, true);
+      expect(parsed.data['version'], clideVersion);
+    });
+
+    test('unknown command returns NotFound (exit code 3)', () async {
+      final resp = await _send(
+        socketPath,
+        IpcRequest(id: 'x', cmd: 'this.does.not.exist').encode(),
+      );
+      final parsed = IpcMessage.decode(resp) as IpcResponse;
+      expect(parsed.ok, false);
+      expect(parsed.error!.code, IpcExitCode.notFound);
+      expect(parsed.error!.kind, IpcErrorKind.notFound);
+      expect(parsed.error!.message, contains('this.does.not.exist'));
+    });
+
+    test('multiple concurrent requests on one connection', () async {
+      final socket = await Socket.connect(
+        InternetAddress(socketPath, type: InternetAddressType.unix),
+        0,
+      );
+      for (var i = 0; i < 5; i++) {
+        socket.writeln(IpcRequest(id: '$i', cmd: 'ping').encode());
+      }
+      final lines = <String>[];
+      final done = Completer<void>();
+      final sub = socket
+          .cast<List<int>>()
+          .transform(utf8.decoder)
+          .transform(const LineSplitter())
+          .listen((line) {
+        lines.add(line);
+        if (lines.length == 5) done.complete();
+      });
+      await done.future.timeout(const Duration(seconds: 2));
+      await sub.cancel();
+      await socket.close();
+      final ids =
+          lines.map((l) => (IpcMessage.decode(l) as IpcResponse).id).toSet();
+      expect(ids, {'0', '1', '2', '3', '4'});
+    });
+
+    test('custom handler plugs into dispatcher', () async {
+      dispatcher.register('test.custom', (req) async {
+        return IpcResponse.ok(id: req.id, data: {'echo': req.args});
+      });
+      final resp = await _send(
+        socketPath,
+        IpcRequest(
+          id: 'c',
+          cmd: 'test.custom',
+          args: const {'x': 1},
+        ).encode(),
+      );
+      final parsed = IpcMessage.decode(resp) as IpcResponse;
+      expect(parsed.ok, true);
+      expect(parsed.data['echo'], {'x': 1});
+    });
+  });
+}
+
+Future<String> _send(String socketPath, String line) async {
+  final socket = await Socket.connect(
+    InternetAddress(socketPath, type: InternetAddressType.unix),
+    0,
+  );
+  socket.writeln(line);
+  final resp = await socket
+      .cast<List<int>>()
+      .transform(utf8.decoder)
+      .transform(const LineSplitter())
+      .first
+      .timeout(const Duration(seconds: 2));
+  await socket.close();
+  return resp;
+}

test/daemon/subprocess_test.dart

@@ -0,0 +1,91 @@
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:clide/clide.dart';
+import 'package:test/test.dart';
+
+/// Subprocess-level daemon smoke. Only runs if `bin/clide` has been
+/// built (the test skips itself otherwise). This is the release-gate
+/// suite — catches signal-handling, socket-unlink, and version-stamp
+/// regressions that the in-process test masks.
+void main() {
+  final binary = File('bin/clide');
+
+  group('bin/clide --daemon (subprocess)', () {
+    setUpAll(() {
+      if (!binary.existsSync()) {
+        markTestSkipped(
+            'bin/clide not built; run `make build` first to enable this suite');
+      }
+    });
+
+    test('starts, responds to ping, exits cleanly on SIGTERM', () async {
+      if (!binary.existsSync()) return;
+
+      // Use a fresh socket under a unique temp path so parallel test
+      // runs don't collide. The daemon resolves its socket path from
+      // XDG_RUNTIME_DIR + USER (see defaultSocketPath()).
+      final tmp = await Directory.systemTemp.createTemp('clide_sub_');
+      final env = Map<String, String>.from(Platform.environment)
+        ..['XDG_RUNTIME_DIR'] = tmp.path
+        ..['USER'] = 'daemon';
+      final socketPath = '${tmp.path}/clide-daemon.sock';
+
+      final process = await Process.start(
+        binary.absolute.path,
+        ['--daemon'],
+        environment: env,
+      );
+
+      // Wait for "listening on ..." on stderr before connecting.
+      final ready = Completer<void>();
+      final stderrLines = <String>[];
+      final sub = process.stderr
+          .transform(utf8.decoder)
+          .transform(const LineSplitter())
+          .listen((line) {
+        stderrLines.add(line);
+        if (line.contains('listening')) ready.complete();
+      });
+
+      try {
+        await ready.future.timeout(const Duration(seconds: 3));
+
+        // Connect and ping
+        final sock = await Socket.connect(
+          InternetAddress(socketPath, type: InternetAddressType.unix),
+          0,
+        ).timeout(const Duration(seconds: 3));
+        sock.writeln(IpcRequest(id: '1', cmd: 'ping').encode());
+        final line = await sock
+            .cast<List<int>>()
+            .transform(utf8.decoder)
+            .transform(const LineSplitter())
+            .first
+            .timeout(const Duration(seconds: 3));
+        await sock.close();
+        final resp = IpcMessage.decode(line) as IpcResponse;
+        expect(resp.ok, true);
+        expect(resp.data['pong'], true);
+
+        // Clean shutdown
+        process.kill(ProcessSignal.sigterm);
+        final exitCode =
+            await process.exitCode.timeout(const Duration(seconds: 3));
+        expect(exitCode, 0);
+
+        // Socket file should be unlinked
+        expect(await File(socketPath).exists(), false);
+      } finally {
+        await sub.cancel();
+        try {
+          process.kill(ProcessSignal.sigkill);
+        } catch (_) {}
+        try {
+          await tmp.delete(recursive: true);
+        } catch (_) {}
+      }
+    }, timeout: const Timeout(Duration(seconds: 15)));
+  });
+}