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/ipc/envelope_test.dart

@@ -0,0 +1,124 @@
+import 'package:clide/clide.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('IpcRequest', () {
+    test('encodes and decodes round-trip', () {
+      final req = IpcRequest(
+        id: '42',
+        cmd: 'git.status',
+        args: const {'path': '.'},
+      );
+      final line = req.encode();
+      final decoded = IpcMessage.decode(line);
+      expect(decoded, isA<IpcRequest>());
+      final r = decoded as IpcRequest;
+      expect(r.id, '42');
+      expect(r.cmd, 'git.status');
+      expect(r.args, {'path': '.'});
+    });
+
+    test('schema version is stamped', () {
+      final encoded = IpcRequest(id: '1', cmd: 'ping').toJson();
+      expect(encoded['v'], ipcSchemaVersion);
+      expect(encoded['type'], 'request');
+    });
+  });
+
+  group('IpcResponse.ok', () {
+    test('encodes with data, no error', () {
+      final r = IpcResponse.ok(id: '7', data: const {'pong': true});
+      final json = r.toJson();
+      expect(json['type'], 'response');
+      expect(json['ok'], true);
+      expect(json['data'], {'pong': true});
+      expect(json.containsKey('error'), isFalse);
+    });
+
+    test('decode round-trips', () {
+      final original = IpcResponse.ok(id: '7', data: const {'n': 42});
+      final roundtripped = IpcMessage.decode(original.encode()) as IpcResponse;
+      expect(roundtripped.ok, true);
+      expect(roundtripped.id, '7');
+      expect(roundtripped.data, {'n': 42});
+      expect(roundtripped.error, isNull);
+    });
+  });
+
+  group('IpcResponse.err', () {
+    test('encodes with error payload, no data', () {
+      final r = IpcResponse.err(
+        id: '9',
+        error: IpcError(
+          code: IpcExitCode.notFound,
+          kind: IpcErrorKind.notFound,
+          message: 'missing',
+          hint: 'try --help',
+        ),
+      );
+      final json = r.toJson();
+      expect(json['ok'], false);
+      expect(json['error'], {
+        'code': 3,
+        'kind': 'not_found',
+        'message': 'missing',
+        'hint': 'try --help',
+      });
+      expect(json.containsKey('data'), isFalse);
+    });
+
+    test('decode preserves error fields', () {
+      final original = IpcResponse.err(
+        id: '9',
+        error: IpcError(
+          code: IpcExitCode.conflict,
+          kind: IpcErrorKind.conflict,
+          message: 'race',
+        ),
+      );
+      final r = IpcMessage.decode(original.encode()) as IpcResponse;
+      expect(r.ok, false);
+      expect(r.error, isNotNull);
+      expect(r.error!.code, IpcExitCode.conflict);
+      expect(r.error!.kind, IpcErrorKind.conflict);
+      expect(r.error!.message, 'race');
+      expect(r.error!.hint, isNull);
+    });
+  });
+
+  group('IpcEvent', () {
+    test('serializes subsystem + kind + ts + data', () {
+      final ts = DateTime.utc(2026, 4, 21, 12, 0, 0);
+      final e = IpcEvent(
+        subsystem: 'git',
+        kind: 'status-changed',
+        timestamp: ts,
+        data: const {'staged': 3},
+      );
+      final json = e.toJson();
+      expect(json['type'], 'event');
+      expect(json['subsystem'], 'git');
+      expect(json['kind'], 'status-changed');
+      expect(json['ts'], '2026-04-21T12:00:00.000Z');
+      expect(json['data'], {'staged': 3});
+    });
+  });
+
+  group('IpcMessage.decode errors', () {
+    test('throws on non-object line', () {
+      expect(() => IpcMessage.decode('[]'), throwsA(isA<FormatException>()));
+    });
+
+    test('throws on unknown type', () {
+      expect(
+        () => IpcMessage.decode('{"type":"bogus","id":"1"}'),
+        throwsA(isA<FormatException>()),
+      );
+    });
+
+    test('throws on malformed JSON', () {
+      expect(() => IpcMessage.decode('{this is not json'),
+          throwsA(isA<FormatException>()));
+    });
+  });
+}

test/ipc/paths_test.dart

@@ -0,0 +1,28 @@
+import 'dart:io';
+
+import 'package:clide/clide.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('defaultSocketPath', () {
+    final originalXdg = Platform.environment['XDG_RUNTIME_DIR'];
+    final originalUser = Platform.environment['USER'];
+
+    test('uses XDG_RUNTIME_DIR when set', () {
+      // We can't mutate Platform.environment from dart:io, so this test
+      // just asserts the path shape for the current env. CI and dev
+      // boxes both have meaningful USER values.
+      final path = defaultSocketPath();
+      expect(path, endsWith('.sock'));
+      expect(path, contains('clide-'));
+      if (originalXdg != null && originalXdg.isNotEmpty) {
+        expect(path, startsWith(originalXdg));
+      } else {
+        expect(path, startsWith('/tmp'));
+      }
+      if (originalUser != null && originalUser.isNotEmpty) {
+        expect(path, contains('clide-$originalUser'));
+      }
+    });
+  });
+}

test/ipc/schema_v1_test.dart

@@ -0,0 +1,28 @@
+import 'package:clide/clide.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('schema_v1', () {
+    test('schema version is 1', () {
+      expect(ipcSchemaVersion, 1);
+    });
+
+    test('exit codes match ADR 0006', () {
+      expect(IpcExitCode.ok, 0);
+      expect(IpcExitCode.userError, 1);
+      expect(IpcExitCode.toolError, 2);
+      expect(IpcExitCode.notFound, 3);
+      expect(IpcExitCode.conflict, 4);
+    });
+
+    test('error kinds are unique strings', () {
+      final kinds = <String>{
+        IpcErrorKind.userError,
+        IpcErrorKind.toolError,
+        IpcErrorKind.notFound,
+        IpcErrorKind.conflict,
+      };
+      expect(kinds.length, 4);
+    });
+  });
+}