diff --git a/pubspec.yaml b/pubspec.yaml
index 8ba1d188..5d005f1a 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -18,7 +18,7 @@ repository: https://github.com/postmeridiem/clide
 
 # Pre-push line-coverage floor. Ratchets up only — see D-66.
 # Reading: `awk -F: '/^coverage_floor:/ {gsub(/ /,"",$2); print $2}' pubspec.yaml`.
-coverage_floor: 77
+coverage_floor: 79
 
 # Project metadata (was project.yaml, folded in per D-056).
 # version: above is the single source of truth. The Makefile reads
diff --git a/test/daemon/editor_commands_test.dart b/test/daemon/editor_commands_test.dart
index f3660ced..73d593de 100644
--- a/test/daemon/editor_commands_test.dart
+++ b/test/daemon/editor_commands_test.dart
@@ -107,4 +107,100 @@ void main() {
     expect(r.ok, isFalse);
     expect(r.error!.code, IpcExitCode.notFound);
   });
+
+  test('editor.open returns toolError for an unreadable path', () async {
+    // Create a file then chmod 000 so reading fails with a FileSystemException.
+    final unreadable = File('${sandbox.path}/locked.md');
+    await unreadable.writeAsString('x');
+    await Process.run('chmod', ['000', unreadable.path]);
+    addTearDown(() async {
+      await Process.run('chmod', ['644', unreadable.path]);
+    });
+    final r = await call('editor.open', {'path': 'locked.md'});
+    expect(r.ok, isFalse);
+    // Either errno-mapped or toolError — either is acceptable.
+    expect(r.error!.code, isNot(IpcExitCode.notFound));
+  });
+
+  test('editor.active returns null when no buffer is open', () async {
+    final r = await call('editor.active');
+    expect(r.ok, isTrue);
+    expect(r.data['active'], isNull);
+  });
+
+  test('editor.activate requires id and validates it', () async {
+    final missing = await call('editor.activate');
+    expect(missing.ok, isFalse);
+    expect(missing.error!.kind, 'user_error');
+    final unknown = await call('editor.activate', {'id': 'b_404'});
+    expect(unknown.ok, isFalse);
+    expect(unknown.error!.kind, 'not_found');
+  });
+
+  test('editor.activate flips the active buffer to the requested one', () async {
+    await File('${sandbox.path}/a.md').writeAsString('a');
+    await File('${sandbox.path}/b.md').writeAsString('b');
+    final a = await call('editor.open', {'path': 'a.md'});
+    await call('editor.open', {'path': 'b.md'});
+    final r = await call('editor.activate', {'id': a.data['id']});
+    expect(r.ok, isTrue);
+    expect(r.data['active'], a.data['id']);
+  });
+
+  test('editor.read with no active buffer and no id returns not-found', () async {
+    final r = await call('editor.read');
+    expect(r.ok, isFalse);
+    expect(r.error!.kind, 'not_found');
+  });
+
+  test('editor.read with an unknown id returns not-found', () async {
+    final r = await call('editor.read', {'id': 'b_404'});
+    expect(r.ok, isFalse);
+    expect(r.error!.kind, 'not_found');
+  });
+
+  test('editor.set-selection clamps and applies', () async {
+    await call('editor.open', {'path': 'doc.md'});
+    final r = await call('editor.set-selection', {
+      'selection': {'start': 0, 'end': 3}
+    });
+    expect(r.ok, isTrue);
+  });
+
+  test('editor.set-selection without an id or active buffer returns not-found', () async {
+    final r = await call('editor.set-selection', {
+      'selection': {'start': 0, 'end': 1}
+    });
+    expect(r.ok, isFalse);
+    expect(r.error!.kind, 'not_found');
+  });
+
+  test('editor.set-content overwrites the buffer (with and without selection)', () async {
+    await call('editor.open', {'path': 'doc.md'});
+    final r1 = await call('editor.set-content', {'text': 'replaced'});
+    expect(r1.ok, isTrue);
+    expect(r1.data['length'], 'replaced'.length);
+    final read1 = await call('editor.read');
+    expect(read1.data['content'], 'replaced');
+    final r2 = await call('editor.set-content', {
+      'text': 'short',
+      'selection': {'start': 1, 'end': 99}
+    });
+    expect(r2.ok, isTrue);
+  });
+
+  test('editor.save with no active buffer returns not-found', () async {
+    final r = await call('editor.save');
+    expect(r.ok, isFalse);
+    expect(r.error!.kind, 'not_found');
+  });
+
+  test('editor.close requires id and validates it', () async {
+    final missing = await call('editor.close');
+    expect(missing.ok, isFalse);
+    expect(missing.error!.kind, 'user_error');
+    final unknown = await call('editor.close', {'id': 'b_404'});
+    expect(unknown.ok, isFalse);
+    expect(unknown.error!.kind, 'not_found');
+  });
 }
diff --git a/test/daemon/files_commands_test.dart b/test/daemon/files_commands_test.dart
index 9edc068c..75865a48 100644
--- a/test/daemon/files_commands_test.dart
+++ b/test/daemon/files_commands_test.dart
@@ -78,4 +78,54 @@ void main() {
     expect(r.ok, isTrue);
     expect(r.data['subscribed'], isTrue);
   });
+
+  test('files.read returns the file content', () async {
+    final r = await call('files.read', const {'path': 'README.md'});
+    expect(r.ok, isTrue);
+    expect(r.data['content'], 'hi');
+    expect(r.data['path'], 'README.md');
+  });
+
+  test('files.read without a path returns toolError', () async {
+    final r = await call('files.read', const {});
+    expect(r.ok, isFalse);
+    expect(r.error!.kind, IpcErrorKind.toolError);
+    expect(r.error!.message, contains('path'));
+  });
+
+  test('files.read with an empty string path returns toolError', () async {
+    final r = await call('files.read', const {'path': ''});
+    expect(r.ok, isFalse);
+  });
+
+  test('files.read with a path outside the root is rejected', () async {
+    final r = await call('files.read', const {'path': '../escape.txt'});
+    expect(r.ok, isFalse);
+    expect(r.error!.message, contains('outside workspace'));
+  });
+
+  test('files.read returns toolError for a missing file', () async {
+    final r = await call('files.read', const {'path': 'does-not-exist.md'});
+    expect(r.ok, isFalse);
+    expect(r.error!.message, contains('not found'));
+  });
+
+  test('files.ls with a path outside the root is rejected', () async {
+    final r = await call('files.ls', const {'path': '../escape'});
+    expect(r.ok, isFalse);
+    expect(r.error!.message, contains('outside workspace'));
+  });
+
+  test('files.watch is idempotent: a second call still acks subscription', () async {
+    final r1 = await call('files.watch', const {});
+    final r2 = await call('files.watch', const {});
+    expect(r1.ok, isTrue);
+    expect(r2.ok, isTrue);
+  });
+
+  test('FilesService.atCwd resolves a workspace root', () {
+    final svc = FilesService.atCwd(events: RecordingEventSink());
+    expect(svc.root.existsSync(), isTrue);
+    addTearDown(svc.shutdown);
+  });
 }
diff --git a/test/daemon/pane_commands_test.dart b/test/daemon/pane_commands_test.dart
index f7275906..a13b223f 100644
--- a/test/daemon/pane_commands_test.dart
+++ b/test/daemon/pane_commands_test.dart
@@ -111,5 +111,86 @@ void main() {
       expect(r.ok, isTrue);
       expect(r.data['subscribed'], isTrue);
     });
+
+    test('pane.spawn rejects non-string argv entries', () async {
+      final r = await call('pane.spawn', const {
+        'argv': ['/bin/sh', 42]
+      });
+      expect(r.ok, isFalse);
+      expect(r.error!.message, contains('strings'));
+    });
+
+    test('pane.spawn rejects an unknown kind', () async {
+      final r = await call('pane.spawn', const {
+        'argv': ['/bin/cat'],
+        'kind': 'no-such-kind',
+      });
+      expect(r.ok, isFalse);
+      expect(r.error!.kind, 'user_error');
+    });
+
+    test('pane.spawn passes env through as strings', () async {
+      final r = await call('pane.spawn', {
+        'argv': const ['/bin/sh', '-c', 'env'],
+        'env': const {'FOO': 'bar'},
+      });
+      expect(r.ok, isTrue, reason: r.error?.message);
+    });
+
+    test('pane.close requires id and validates it', () async {
+      final missing = await call('pane.close', const {});
+      expect(missing.ok, isFalse);
+      expect(missing.error!.kind, 'user_error');
+      final unknown = await call('pane.close', const {'id': 'p_404'});
+      expect(unknown.ok, isFalse);
+      expect(unknown.error!.kind, 'not_found');
+    });
+
+    test('pane.write requires id and validates it', () async {
+      final missing = await call('pane.write', const {'text': 'x'});
+      expect(missing.ok, isFalse);
+      expect(missing.error!.kind, 'user_error');
+    });
+
+    test('pane.write requires bytes_b64 or text', () async {
+      final spawn = await call('pane.spawn', {
+        'argv': const ['/bin/cat'],
+      });
+      final id = spawn.data['id']! as String;
+      final r = await call('pane.write', {'id': id});
+      expect(r.ok, isFalse);
+      expect(r.error!.message, contains('bytes_b64 or text'));
+    });
+
+    test('pane.write rejects malformed base64', () async {
+      final spawn = await call('pane.spawn', {
+        'argv': const ['/bin/cat'],
+      });
+      final id = spawn.data['id']! as String;
+      final r = await call('pane.write', {'id': id, 'bytes_b64': 'not-base64!!!'});
+      expect(r.ok, isFalse);
+      expect(r.error!.message, contains('base64'));
+    });
+
+    test('pane.resize requires all three of id / cols / rows', () async {
+      final r = await call('pane.resize', const {'id': 'p_1'});
+      expect(r.ok, isFalse);
+      expect(r.error!.kind, 'user_error');
+    });
+
+    test('pane.resize on unknown id is not-found', () async {
+      final r = await call('pane.resize', const {'id': 'p_404', 'cols': 80, 'rows': 24});
+      expect(r.ok, isFalse);
+      expect(r.error!.code, IpcExitCode.notFound);
+    });
+
+    test('pane.focus requires id and validates it', () async {
+      final missing = await call('pane.focus', const {});
+      expect(missing.ok, isFalse);
+      expect(missing.error!.kind, 'user_error');
+      final unknown = await call('pane.focus', const {'id': 'p_404'});
+      expect(unknown.ok, isFalse);
+      expect(unknown.error!.kind, 'not_found');
+    });
   });
 }
diff --git a/test/daemon/pql_commands_test.dart b/test/daemon/pql_commands_test.dart
index d06ffba6..7bf448ed 100644
--- a/test/daemon/pql_commands_test.dart
+++ b/test/daemon/pql_commands_test.dart
@@ -120,4 +120,108 @@ void main() {
     expect(r.ok, isFalse);
     expect(r.error!.kind, 'user_error');
   });
+
+  test('pql.files with glob + limit narrows the result', () async {
+    final r = await call('pql.files', {'glob': 'CLAUDE.md', 'limit': 1});
+    expect(r.ok, isTrue);
+    final files = r.data['files'] as List;
+    expect(files.length, lessThanOrEqualTo(1));
+  });
+
+  test('pql.backlinks with a path returns links list', () async {
+    final r = await call('pql.backlinks', {'path': 'CLAUDE.md'});
+    expect(r.ok, isTrue);
+    expect(r.data['links'], isA<List>());
+  });
+
+  test('pql.outlinks without path returns user_error', () async {
+    final r = await call('pql.outlinks');
+    expect(r.ok, isFalse);
+    expect(r.error!.kind, 'user_error');
+  });
+
+  test('pql.tags returns a tag list (with limit)', () async {
+    final r = await call('pql.tags', {'limit': 5});
+    expect(r.ok, isTrue);
+    expect(r.data['tags'], isA<List>());
+  });
+
+  test('pql.query with a DSL string returns results', () async {
+    final r = await call('pql.query', {'query': 'SELECT name', 'limit': 2});
+    expect(r.ok, isTrue);
+    expect(r.data['results'], isA<List>());
+  });
+
+  test('pql.search with terms returns hits; missing terms is user_error', () async {
+    final missing = await call('pql.search');
+    expect(missing.ok, isFalse);
+    expect(missing.error!.kind, 'user_error');
+    final hit = await call('pql.search', {'terms': 'clide', 'limit': 2});
+    expect(hit.ok, isTrue);
+  });
+
+  test('pql.decisions.read requires id; happy path returns the body', () async {
+    final missing = await call('pql.decisions.read');
+    expect(missing.ok, isFalse);
+    expect(missing.error!.kind, 'user_error');
+    final ok = await call('pql.decisions.read', {'id': 'D-1'});
+    expect(ok.ok, isTrue);
+    expect(ok.data['id'], 'D-1');
+  });
+
+  test('pql.decisions.show forwards withRefs / withTickets', () async {
+    final r = await call('pql.decisions.show', {
+      'id': 'D-1',
+      'withRefs': true,
+      'withTickets': true,
+    });
+    expect(r.ok, isTrue);
+    expect(r.data['id'], 'D-1');
+  });
+
+  test('pql.decisions.list with a domain filter narrows', () async {
+    final r = await call('pql.decisions.list', {'domain': 'architecture'});
+    expect(r.ok, isTrue);
+    final decisions = r.data['decisions'] as List;
+    expect(decisions.every((d) => (d as Map)['domain'] == 'architecture'), isTrue);
+  });
+
+  test('pql.tickets.list with filters narrows + shows status', () async {
+    final r = await call('pql.tickets.list', {
+      'status': 'done',
+      'team': 'whatever',
+      'assigned': 'no-one',
+      'decision': 'D-1',
+    });
+    expect(r.ok, isTrue);
+    expect(r.data['tickets'], isA<List>());
+  });
+
+  test('pql.tickets.show requires id; happy path returns the row', () async {
+    final missing = await call('pql.tickets.show');
+    expect(missing.ok, isFalse);
+    expect(missing.error!.kind, 'user_error');
+    final ok = await call('pql.tickets.show', {
+      'id': 'T-1',
+      'withContext': true,
+      'withBlockers': true,
+    });
+    expect(ok.ok, isTrue);
+  });
+
+  test('pql.tickets.status requires ids + status', () async {
+    final missing = await call('pql.tickets.status');
+    expect(missing.ok, isFalse);
+    expect(missing.error!.kind, 'user_error');
+    // Accept both List and String for ids.
+    final justOne = await call('pql.tickets.status', {'ids': 'T-1'});
+    expect(justOne.ok, isFalse); // status still missing
+    expect(justOne.error!.kind, 'user_error');
+  });
+
+  test('pql.tickets.board with team filter', () async {
+    final r = await call('pql.tickets.board', {'team': 'whatever'});
+    expect(r.ok, isTrue);
+    expect(r.data['columns'], isA<List>());
+  });
 }