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>

lib/src/daemon/dispatcher.dart

@@ -0,0 +1,48 @@
+import 'package:clide/clide.dart' show clideVersion;
+import 'package:clide/src/ipc/envelope.dart';
+import 'package:clide/src/ipc/schema_v1.dart';
+
+typedef CommandHandler = Future<IpcResponse> Function(IpcRequest req);
+
+class DaemonDispatcher {
+  DaemonDispatcher() {
+    register('ping', _ping);
+    register('version', _version);
+  }
+
+  final Map<String, CommandHandler> _handlers = {};
+
+  void register(String cmd, CommandHandler handler) {
+    _handlers[cmd] = handler;
+  }
+
+  Future<IpcResponse> dispatch(IpcRequest req) async {
+    final h = _handlers[req.cmd];
+    if (h == null) {
+      return IpcResponse.err(
+        id: req.id,
+        error: IpcError(
+          code: IpcExitCode.notFound,
+          kind: IpcErrorKind.notFound,
+          message: 'unknown command: ${req.cmd}',
+          hint: 'run `clide --help` for the surface.',
+        ),
+      );
+    }
+    return h(req);
+  }
+
+  Future<IpcResponse> _ping(IpcRequest req) async => IpcResponse.ok(
+        id: req.id,
+        data: {
+          'pong': true,
+          'ts': DateTime.now().toUtc().toIso8601String(),
+          'version': clideVersion,
+        },
+      );
+
+  Future<IpcResponse> _version(IpcRequest req) async => IpcResponse.ok(
+        id: req.id,
+        data: {'version': clideVersion},
+      );
+}

lib/src/ipc/envelope.dart

@@ -0,0 +1,157 @@
+import 'dart:convert';
+
+import 'package:clide/src/ipc/schema_v1.dart';
+
+sealed class IpcMessage {
+  Map<String, Object?> toJson();
+
+  String encode() => jsonEncode(toJson());
+
+  static IpcMessage decode(String line) {
+    final obj = jsonDecode(line);
+    if (obj is! Map<String, Object?>) {
+      throw const FormatException('IPC message is not a JSON object');
+    }
+    final type = obj['type'];
+    switch (type) {
+      case 'request':
+        return IpcRequest.fromJson(obj);
+      case 'response':
+        return IpcResponse.fromJson(obj);
+      case 'event':
+        return IpcEvent.fromJson(obj);
+      default:
+        throw FormatException('Unknown IPC message type: $type');
+    }
+  }
+}
+
+class IpcRequest extends IpcMessage {
+  IpcRequest({
+    required this.id,
+    required this.cmd,
+    this.args = const {},
+  });
+
+  final String id;
+  final String cmd;
+  final Map<String, Object?> args;
+
+  @override
+  Map<String, Object?> toJson() => {
+        'type': 'request',
+        'v': ipcSchemaVersion,
+        'id': id,
+        'cmd': cmd,
+        'args': args,
+      };
+
+  factory IpcRequest.fromJson(Map<String, Object?> j) => IpcRequest(
+        id: j['id']! as String,
+        cmd: j['cmd']! as String,
+        args: (j['args'] as Map?)?.cast<String, Object?>() ?? const {},
+      );
+}
+
+class IpcResponse extends IpcMessage {
+  IpcResponse.ok({required this.id, this.data = const {}})
+      : ok = true,
+        error = null;
+
+  IpcResponse.err({required this.id, required IpcError this.error})
+      : ok = false,
+        data = const {};
+
+  IpcResponse._({
+    required this.id,
+    required this.ok,
+    required this.data,
+    required this.error,
+  });
+
+  final String id;
+  final bool ok;
+  final Map<String, Object?> data;
+  final IpcError? error;
+
+  @override
+  Map<String, Object?> toJson() => {
+        'type': 'response',
+        'v': ipcSchemaVersion,
+        'id': id,
+        'ok': ok,
+        if (ok) 'data': data,
+        if (!ok && error != null) 'error': error!.toJson(),
+      };
+
+  factory IpcResponse.fromJson(Map<String, Object?> j) {
+    final ok = j['ok'] as bool? ?? false;
+    return IpcResponse._(
+      id: j['id']! as String,
+      ok: ok,
+      data: (j['data'] as Map?)?.cast<String, Object?>() ?? const {},
+      error: ok
+          ? null
+          : IpcError.fromJson((j['error'] as Map).cast<String, Object?>()),
+    );
+  }
+}
+
+class IpcError {
+  IpcError({
+    required this.code,
+    required this.kind,
+    required this.message,
+    this.hint,
+  });
+
+  final int code;
+  final String kind;
+  final String message;
+  final String? hint;
+
+  Map<String, Object?> toJson() => {
+        'code': code,
+        'kind': kind,
+        'message': message,
+        if (hint != null) 'hint': hint,
+      };
+
+  factory IpcError.fromJson(Map<String, Object?> j) => IpcError(
+        code: (j['code'] as num).toInt(),
+        kind: j['kind']! as String,
+        message: j['message']! as String,
+        hint: j['hint'] as String?,
+      );
+}
+
+class IpcEvent extends IpcMessage {
+  IpcEvent({
+    required this.subsystem,
+    required this.kind,
+    required this.timestamp,
+    this.data = const {},
+  });
+
+  final String subsystem;
+  final String kind;
+  final DateTime timestamp;
+  final Map<String, Object?> data;
+
+  @override
+  Map<String, Object?> toJson() => {
+        'type': 'event',
+        'v': ipcSchemaVersion,
+        'subsystem': subsystem,
+        'kind': kind,
+        'ts': timestamp.toIso8601String(),
+        'data': data,
+      };
+
+  factory IpcEvent.fromJson(Map<String, Object?> j) => IpcEvent(
+        subsystem: j['subsystem']! as String,
+        kind: j['kind']! as String,
+        timestamp: DateTime.parse(j['ts']! as String),
+        data: (j['data'] as Map?)?.cast<String, Object?>() ?? const {},
+      );
+}

lib/src/ipc/paths.dart

@@ -0,0 +1,8 @@
+import 'dart:io';
+
+String defaultSocketPath() {
+  final xdg = Platform.environment['XDG_RUNTIME_DIR'];
+  final user = Platform.environment['USER'] ?? 'anon';
+  final base = (xdg != null && xdg.isNotEmpty) ? xdg : '/tmp';
+  return '$base/clide-$user.sock';
+}

lib/src/ipc/schema_v1.dart

@@ -0,0 +1,21 @@
+/// IPC wire schema version.
+///
+/// Bumped when the envelope shape changes in a non-backwards-compatible
+/// way. The daemon and app both carry this constant and reject messages
+/// whose `v:` doesn't match.
+const int ipcSchemaVersion = 1;
+
+abstract class IpcExitCode {
+  static const int ok = 0;
+  static const int userError = 1;
+  static const int toolError = 2;
+  static const int notFound = 3;
+  static const int conflict = 4;
+}
+
+abstract class IpcErrorKind {
+  static const String userError = 'user_error';
+  static const String toolError = 'tool_error';
+  static const String notFound = 'not_found';
+  static const String conflict = 'conflict';
+}

lib/src/ipc/server.dart

@@ -0,0 +1,97 @@
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:clide/src/ipc/envelope.dart';
+
+typedef RequestDispatcher = Future<IpcResponse> Function(IpcRequest request);
+
+/// Unix-socket JSON-lines server. Each connection is an independent
+/// bidirectional line-framed stream: client writes requests, daemon
+/// writes responses (and events, later). Tier 0 handles request→response
+/// only; event broadcasting lands with the first feature that emits.
+class DaemonServer {
+  DaemonServer({
+    required this.socketPath,
+    required this.dispatch,
+  });
+
+  final String socketPath;
+  final RequestDispatcher dispatch;
+
+  ServerSocket? _server;
+  final Set<Socket> _clients = {};
+
+  Future<void> start() async {
+    final addr = InternetAddress(socketPath, type: InternetAddressType.unix);
+    try {
+      _server = await ServerSocket.bind(addr, 0);
+    } on SocketException {
+      // stale socket from a prior crash — unlink and retry once
+      try {
+        await File(socketPath).delete();
+      } catch (_) {}
+      _server = await ServerSocket.bind(addr, 0);
+    }
+    stderr.writeln('clide daemon listening on $socketPath');
+    _server!.listen(_handleClient, onError: (e) {
+      stderr.writeln('clide daemon accept error: $e');
+    });
+  }
+
+  Future<void> stop() async {
+    for (final c in List<Socket>.from(_clients)) {
+      await c.close();
+    }
+    _clients.clear();
+    await _server?.close();
+    _server = null;
+    try {
+      await File(socketPath).delete();
+    } catch (_) {}
+  }
+
+  void _handleClient(Socket client) {
+    _clients.add(client);
+    client
+        .cast<List<int>>()
+        .transform(utf8.decoder)
+        .transform(const LineSplitter())
+        .listen(
+          (line) => _handleLine(client, line),
+          onDone: () => _clients.remove(client),
+          onError: (Object e) {
+            stderr.writeln('clide daemon client error: $e');
+            _clients.remove(client);
+          },
+          cancelOnError: true,
+        );
+  }
+
+  Future<void> _handleLine(Socket client, String line) async {
+    if (line.isEmpty) return;
+    IpcMessage? msg;
+    try {
+      msg = IpcMessage.decode(line);
+    } on FormatException catch (e) {
+      stderr.writeln('clide daemon: bad line from client: $e');
+      return;
+    }
+    if (msg is! IpcRequest) return;
+    IpcResponse resp;
+    try {
+      resp = await dispatch(msg);
+    } catch (e, st) {
+      stderr.writeln('clide daemon: dispatch error for ${msg.cmd}: $e\n$st');
+      resp = IpcResponse.err(
+        id: msg.id,
+        error: IpcError(
+          code: 2,
+          kind: 'tool_error',
+          message: 'dispatch failed: $e',
+        ),
+      );
+    }
+    client.writeln(resp.encode());
+  }
+}