diff --git a/benchmark/profile/audit_workloads.dart b/benchmark/profile/audit_workloads.dart
index 4015264..baec8b5 100644
--- a/benchmark/profile/audit_workloads.dart
+++ b/benchmark/profile/audit_workloads.dart
@@ -152,6 +152,7 @@ Future<AuditScenarioResult> runA11cScenario(
     }
 
     ProfileCounters.reset();
+    await db.resetWriterProfileCounters();
     final sw = Stopwatch()..start();
     for (var w = 0; w < a11cWriteCount; w++) {
       await db.execute(updateSql, [valueFor(w), w % a11cRowCount]);
@@ -159,7 +160,7 @@ Future<AuditScenarioResult> runA11cScenario(
       await Future<void>.delayed(Duration.zero);
     }
     sw.stop();
-    final counters = ProfileCounters.snapshot();
+    final counters = await _mergedCountersSnapshot(db);
 
     // Drain emissions without inflating wall_us.
     await Future<void>.delayed(const Duration(milliseconds: 50));
@@ -236,6 +237,7 @@ Future<AuditScenarioResult> runKeyedPkScenario() async {
       final prng = math.Random(keyedPkPrngSeed);
 
       ProfileCounters.reset();
+      await db.resetWriterProfileCounters();
       final sw = Stopwatch()..start();
       for (var w = 0; w < keyedPkWriteCount; w++) {
         final pk = prng.nextInt(keyedPkRowCount) + 1;
@@ -246,7 +248,7 @@ Future<AuditScenarioResult> runKeyedPkScenario() async {
         );
       }
       sw.stop();
-      final counters = ProfileCounters.snapshot();
+      final counters = await _mergedCountersSnapshot(db);
 
       // Drain trailing emissions on a quiet-window pattern AFTER the
       // stopwatch stops so wall_us is purely write-loop wall.
@@ -331,6 +333,13 @@ Future<AuditScenarioResult> runDirectReadControl() async {
         'intersection_entries': 0,
         'rows_decoded': 0,
         'cells_decoded': 0,
+        // Direct-read workload exercises the reader pool exclusively;
+        // the writer-isolate counters from EXP-135 stay at zero by
+        // construction, but the keys must be present so downstream
+        // consumers can read them uniformly across scenarios.
+        'writer_handler_us': 0,
+        'writer_sqlite_us': 0,
+        'writer_handler_count': 0,
       },
     );
   } finally {
@@ -363,6 +372,22 @@ int _median(List<int> values) {
   return sorted[sorted.length ~/ 2];
 }
 
+/// Snapshot the main-isolate `ProfileCounters` and merge in the
+/// writer-isolate counters obtained over the snapshot RPC. The
+/// `writer_*` keys are populated only inside the writer isolate
+/// ([EXP-135](../../experiments/135-writer-step-wall-audit.md)) and
+/// would otherwise stay at zero in the main snapshot.
+Future<Map<String, int>> _mergedCountersSnapshot(Database db) async {
+  final main = ProfileCounters.snapshot();
+  final writer = await db.snapshotWriterProfileCounters();
+  return {
+    ...main,
+    'writer_handler_us': writer['writer_handler_us'] ?? 0,
+    'writer_sqlite_us': writer['writer_sqlite_us'] ?? 0,
+    'writer_handler_count': writer['writer_handler_count'] ?? 0,
+  };
+}
+
 /// Reader pool size as configured in `ReaderPool`. Useful for the
 /// audit reports' header text.
 int readerPoolSize() => (Platform.numberOfProcessors - 1).clamp(2, 4);
diff --git a/benchmark/profile/results/exp-135-writer-step-wall-aggregate.md b/benchmark/profile/results/exp-135-writer-step-wall-aggregate.md
new file mode 100644
index 0000000..20bc946
--- /dev/null
+++ b/benchmark/profile/results/exp-135-writer-step-wall-aggregate.md
@@ -0,0 +1,43 @@
+# Experiment 135 - Writer Step Wall vs Dispatch Wall Audit
+
+Profile-mode harness: `benchmark/profile/writer_step_wall_audit.dart`
+
+Reader pool size: 4 (`(Platform.numberOfProcessors - 1).clamp(2, 4)`)
+
+Wall-clock convention: `wall_us` is writer-side burst wall — the stopwatch stops on the last write (matches exp 119 / exp 121). Writer counters are snapshotted from the writer isolate via `Database.snapshotWriterProfileCounters()`.
+
+Command:
+
+```text
+dart run -DRESQLITE_PROFILE=true benchmark/profile/writer_step_wall_audit.dart --markdown
+```
+
+## Counters
+
+| workload | shape | wall_ms | handler_us | sqlite_us | dispatch_us | handler_count | parked_total | max_parked | emissions |
+|---|---|---:|---:|---:|---:|---:|---:|---:|---:|
+| A11c baseline | 0 streams x 500 writes | 34.35 | 17609 | 12073 | 5536 | 500 | 0 | 0 | 0 |
+| A11c disjoint | 50 streams x 500 writes | 37.18 | 13029 | 8107 | 4922 | 500 | 0 | 0 | 0 |
+| A11c overlap | 50 streams x 500 writes | 84.57 | 20765 | 11418 | 9347 | 500 | 0 | 0 | 22 |
+| keyed PK subscriptions | 50 streams x 200 random writes | 18.41 | 5747 | 4012 | 1735 | 200 | 0 | 0 | 3 |
+
+## Derived fractions
+
+| workload | handler_us / wall_us | sqlite_us / wall_us | dispatch_us / wall_us | sqlite_us / handler_us | us per handler | sqlite_us per handler | dispatch_us per handler |
+|---|---:|---:|---:|---:|---:|---:|---:|
+| A11c baseline | 51.26% | 35.14% | 16.11% | 68.56% | 35.22 | 24.15 | 11.07 |
+| A11c disjoint | 35.04% | 21.80% | 13.24% | 62.22% | 26.06 | 16.21 | 9.84 |
+| A11c overlap | 24.55% | 13.50% | 11.05% | 54.99% | 41.53 | 22.84 | 18.69 |
+| keyed PK subscriptions | 31.21% | 21.79% | 9.42% | 69.81% | 28.73 | 20.06 | 8.68 |
+
+## Reading the table
+
+- `handler_us` is the cumulative wall the writer isolate spent between request receipt and `replyPort.send`, summed over every handled message during the workload. It includes Dart-side dispatch (param allocation, dirty-table marshalling) and the FFI calls themselves.
+- `sqlite_us` is the cumulative wall spent specifically inside the FFI calls that drive SQLite — `resqliteExecute`, `resqliteRunBatch`, `resqliteRunBatchNested`, the transaction-control stmts, and the prepare+step portion of transaction reads.
+- `dispatch_us = handler_us - sqlite_us` is the writer-side Dart dispatch wall: param packing, `getDirtyTableDependencies`, message send, and any Dart-only bookkeeping inside the handler.
+- `sqlite_us / handler_us` is the share of writer-isolate handler wall actually spent in SQLite. A high share means writer-side dispatch optimization has little room; a low share means the inverse.
+- `parked_total` and `max_parked` should both stay at zero post-exp-120, reproducing exp 120's acceptance signal as a sanity check on top of the new counters.
+
+## Interpretation
+
+See `experiments/135-writer-step-wall-audit.md` for the decision and follow-up notes attached to these numbers.
diff --git a/benchmark/profile/writer_step_wall_audit.dart b/benchmark/profile/writer_step_wall_audit.dart
new file mode 100644
index 0000000..04f6279
--- /dev/null
+++ b/benchmark/profile/writer_step_wall_audit.dart
@@ -0,0 +1,277 @@
+// ignore_for_file: avoid_print
+//
+// Writer-isolate dispatch wall vs SQLite step wall audit — exp 135.
+//
+// Exp 120 closed the over-dispatch path inside `StreamEngine._flushQueue`
+// and dropped reader-pool dispatcher counters to zero on every measured
+// stream workload. Exp 121 then read the existing invalidation counters
+// against the corrected wall convention and ruled invalidation
+// traversal off the candidate list as a wall-time target.
+//
+// Both follow-up dispatch ideas in exp 120's future-notes are blocked
+// on writer-isolate measurement infrastructure that exp 121 explicitly
+// flagged in `signals.json`:
+//
+//   - completion-side microtask scheduling cost counter
+//   - writer dispatch wall counter (dart wall - SQLite step wall)
+//
+// This experiment ships the second one: profile-mode counters inside
+// the writer isolate that record per-handler wall time and the wall
+// time spent inside the FFI calls that drive SQLite (`resqliteExecute`,
+// `resqliteRunBatch`, `resqliteRunBatchNested`, the transaction-control
+// stmts, and the step+decode part of `_handleTxQuery`). The harness
+// reads them through `Database.snapshotWriterProfileCounters()`.
+//
+// One question:
+//
+//   What fraction of the writer-isolate handler wall is SQLite step
+//   work versus Dart-side dispatch on A11c overlap and keyed-PK
+//   subscriptions?
+//
+// If the SQLite-step share is high (≥ ~70%), writer-side dispatch is
+// not the next dispatch experiment target on the currently-measured
+// workloads. If it is low (≤ ~50%), there is real Dart-dispatch
+// headroom and the next dispatch experiment in `stream-rerun-dispatch`
+// can target it directly.
+//
+// Workload shapes mirror exp 119/121 via `audit_workloads.dart` so
+// fractions reported here line up structurally with the prior audits.
+//
+// Usage:
+//   dart run -DRESQLITE_PROFILE=true \
+//     benchmark/profile/writer_step_wall_audit.dart --markdown
+
+import 'dart:io';
+
+import 'package:resqlite/src/profile_mode.dart';
+
+import 'audit_workloads.dart';
+
+final class _AuditRow {
+  _AuditRow({
+    required this.workload,
+    required this.shape,
+    required this.wallUs,
+    required this.handlerUs,
+    required this.sqliteUs,
+    required this.handlerCount,
+    required this.parkedTotal,
+    required this.maxParked,
+    required this.emissions,
+  });
+
+  factory _AuditRow.fromScenario(AuditScenarioResult r) => _AuditRow(
+    workload: r.workload,
+    shape: r.shape,
+    wallUs: r.wallUs,
+    handlerUs: r.counters['writer_handler_us'] ?? 0,
+    sqliteUs: r.counters['writer_sqlite_us'] ?? 0,
+    handlerCount: r.counters['writer_handler_count'] ?? 0,
+    parkedTotal: r.counters['dispatcher_parked_total'] ?? 0,
+    maxParked: r.counters['dispatcher_max_parked_concurrent'] ?? 0,
+    emissions: r.emissions,
+  );
+
+  final String workload;
+  final String shape;
+  final int wallUs;
+  final int handlerUs;
+  final int sqliteUs;
+  final int handlerCount;
+  final int parkedTotal;
+  final int maxParked;
+  final int emissions;
+
+  // `handlerUs` and `sqliteUs` come from independently-running
+  // stopwatches inside the writer isolate, so a marginal handler that
+  // happens to nest entirely inside its `_measureSqlite` call could
+  // briefly produce `sqliteUs > handlerUs` from clock-resolution
+  // rounding. Clamp at zero so the derived fractions and the rendered
+  // markdown never report a negative dispatch share — a value < 0 would
+  // be a measurement artifact rather than a real signal.
+  int get dispatchUs => handlerUs > sqliteUs ? handlerUs - sqliteUs : 0;
+  double get wallMs => wallUs / 1000.0;
+  double get handlerFractionPct =>
+      wallUs == 0 ? 0.0 : (handlerUs / wallUs) * 100.0;
+  double get sqliteFractionPct =>
+      wallUs == 0 ? 0.0 : (sqliteUs / wallUs) * 100.0;
+  double get dispatchFractionPct =>
+      wallUs == 0 ? 0.0 : (dispatchUs / wallUs) * 100.0;
+  double get sqliteFractionOfHandlerPct =>
+      handlerUs == 0 ? 0.0 : (sqliteUs / handlerUs) * 100.0;
+  double get usPerHandler =>
+      handlerCount == 0 ? 0.0 : handlerUs / handlerCount;
+  double get sqliteUsPerHandler =>
+      handlerCount == 0 ? 0.0 : sqliteUs / handlerCount;
+  double get dispatchUsPerHandler =>
+      handlerCount == 0 ? 0.0 : dispatchUs / handlerCount;
+}
+
+Future<void> main(List<String> args) async {
+  if (!kProfileMode) {
+    stderr.writeln(
+      'WARNING: kProfileMode=false; writer-isolate dispatch counters '
+      'will stay zero. Rerun with -DRESQLITE_PROFILE=true.',
+    );
+  }
+
+  final writeMarkdown = args.contains('--markdown');
+
+  final rows = <_AuditRow>[];
+  rows.addAll((await _runA11cAudit()).map(_AuditRow.fromScenario));
+  rows.add(_AuditRow.fromScenario(await runKeyedPkScenario()));
+
+  final markdown = _renderMarkdown(rows);
+  print(markdown);
+
+  if (writeMarkdown) {
+    final outFile = File(
+      'benchmark/profile/results/exp-135-writer-step-wall-aggregate.md',
+    );
+    await outFile.writeAsString(markdown);
+    print('Wrote ${outFile.path}');
+  }
+}
+
+Future<List<AuditScenarioResult>> _runA11cAudit() async {
+  final setup = await setupA11cDb(prefix: 'writer_step_audit_a11c_');
+  try {
+    return [
+      await runA11cScenario(
+        setup.db,
+        name: 'A11c baseline',
+        streamCount: 0,
+        updateSql: 'UPDATE wide SET c = ? WHERE id = ?',
+        valueFor: (writeIndex) => 'b$writeIndex',
+      ),
+      await runA11cScenario(
+        setup.db,
+        name: 'A11c disjoint',
+        streamCount: a11cStreamCount,
+        updateSql: 'UPDATE wide SET c = ? WHERE id = ?',
+        valueFor: (writeIndex) => 'd$writeIndex',
+      ),
+      await runA11cScenario(
+        setup.db,
+        name: 'A11c overlap',
+        streamCount: a11cStreamCount,
+        updateSql: 'UPDATE wide SET a = ? WHERE id = ?',
+        valueFor: (writeIndex) => 'o$writeIndex',
+      ),
+    ];
+  } finally {
+    await setup.db.close();
+    await setup.tempDir.delete(recursive: true);
+  }
+}
+
+String _renderMarkdown(List<_AuditRow> rows) {
+  final readerCount = readerPoolSize();
+  final buf = StringBuffer();
+  buf.writeln('# Experiment 135 - Writer Step Wall vs Dispatch Wall Audit');
+  buf.writeln();
+  buf.writeln(
+    'Profile-mode harness: '
+    '`benchmark/profile/writer_step_wall_audit.dart`',
+  );
+  buf.writeln();
+  buf.writeln(
+    'Reader pool size: $readerCount '
+    '(`(Platform.numberOfProcessors - 1).clamp(2, 4)`)',
+  );
+  buf.writeln();
+  buf.writeln(
+    'Wall-clock convention: `wall_us` is writer-side burst wall — the '
+    'stopwatch stops on the last write (matches exp 119 / exp 121). '
+    'Writer counters are snapshotted from the writer isolate via '
+    '`Database.snapshotWriterProfileCounters()`.',
+  );
+  buf.writeln();
+  buf.writeln('Command:');
+  buf.writeln();
+  buf.writeln('```text');
+  buf.writeln(
+    'dart run -DRESQLITE_PROFILE=true '
+    'benchmark/profile/writer_step_wall_audit.dart --markdown',
+  );
+  buf.writeln('```');
+  buf.writeln();
+  buf.writeln('## Counters');
+  buf.writeln();
+  buf.writeln(
+    '| workload | shape | wall_ms | handler_us | sqlite_us | dispatch_us | '
+    'handler_count | parked_total | max_parked | emissions |',
+  );
+  buf.writeln(
+    '|---|---|---:|---:|---:|---:|---:|---:|---:|---:|',
+  );
+  for (final row in rows) {
+    buf.writeln(
+      '| ${row.workload} | ${row.shape} | ${row.wallMs.toStringAsFixed(2)} | '
+      '${row.handlerUs} | ${row.sqliteUs} | ${row.dispatchUs} | '
+      '${row.handlerCount} | ${row.parkedTotal} | ${row.maxParked} | '
+      '${row.emissions} |',
+    );
+  }
+  buf.writeln();
+  buf.writeln('## Derived fractions');
+  buf.writeln();
+  buf.writeln(
+    '| workload | handler_us / wall_us | sqlite_us / wall_us | '
+    'dispatch_us / wall_us | sqlite_us / handler_us | us per handler | '
+    'sqlite_us per handler | dispatch_us per handler |',
+  );
+  buf.writeln('|---|---:|---:|---:|---:|---:|---:|---:|');
+  for (final row in rows) {
+    buf.writeln(
+      '| ${row.workload} | '
+      '${row.handlerFractionPct.toStringAsFixed(2)}% | '
+      '${row.sqliteFractionPct.toStringAsFixed(2)}% | '
+      '${row.dispatchFractionPct.toStringAsFixed(2)}% | '
+      '${row.sqliteFractionOfHandlerPct.toStringAsFixed(2)}% | '
+      '${row.usPerHandler.toStringAsFixed(2)} | '
+      '${row.sqliteUsPerHandler.toStringAsFixed(2)} | '
+      '${row.dispatchUsPerHandler.toStringAsFixed(2)} |',
+    );
+  }
+  buf.writeln();
+  buf.writeln('## Reading the table');
+  buf.writeln();
+  buf.writeln(
+    '- `handler_us` is the cumulative wall the writer isolate spent '
+    'between request receipt and `replyPort.send`, summed over every '
+    'handled message during the workload. It includes Dart-side '
+    'dispatch (param allocation, dirty-table marshalling) and the FFI '
+    'calls themselves.',
+  );
+  buf.writeln(
+    '- `sqlite_us` is the cumulative wall spent specifically inside '
+    'the FFI calls that drive SQLite — `resqliteExecute`, '
+    '`resqliteRunBatch`, `resqliteRunBatchNested`, the transaction-control '
+    'stmts, and the prepare+step portion of transaction reads.',
+  );
+  buf.writeln(
+    '- `dispatch_us = handler_us - sqlite_us` is the writer-side Dart '
+    'dispatch wall: param packing, `getDirtyTableDependencies`, message '
+    'send, and any Dart-only bookkeeping inside the handler.',
+  );
+  buf.writeln(
+    '- `sqlite_us / handler_us` is the share of writer-isolate handler '
+    'wall actually spent in SQLite. A high share means writer-side '
+    'dispatch optimization has little room; a low share means the '
+    'inverse.',
+  );
+  buf.writeln(
+    '- `parked_total` and `max_parked` should both stay at zero post-'
+    'exp-120, reproducing exp 120\'s acceptance signal as a sanity '
+    'check on top of the new counters.',
+  );
+  buf.writeln();
+  buf.writeln('## Interpretation');
+  buf.writeln();
+  buf.writeln(
+    'See `experiments/135-writer-step-wall-audit.md` for the decision '
+    'and follow-up notes attached to these numbers.',
+  );
+  return buf.toString();
+}
diff --git a/docs/experiments/history.json b/docs/experiments/history.json
index 366057f..1a70090 100644
--- a/docs/experiments/history.json
+++ b/docs/experiments/history.json
@@ -1,5 +1,5 @@
 {
-  "generated": "2026-05-09T15:12:01.705071",
+  "generated": "2026-05-10T07:30:23.001847",
   "runs": [
     {
       "id": "baseline-before-authorizer-hooks",
@@ -18452,6 +18452,19 @@
       "approach": "The archived implementation accumulates dirty `(table, rowid)` pairs in a\nbounded native set. It borrows the already-stable dirty-table name storage, so\nsingle-row writes do not allocate another table string for rowid precision.\nOverflow or allocation uncertainty returns zero rowid details and keeps the\nexisting table/column invalidation path.\n\nDart bindings decode those rowids into `TableRowDependency`. Row precision is\nan optimization layer: when both stream and write sides have rowids, a\nnon-overlap skips immediately; when either side lacks rowids, the existing\ncolumn/table logic decides.\n\n`StreamEngine` attaches read-side rowids only for narrow SQL it can prove:\n\n- one positional parameter;\n- a simple `FROM table WHERE id = ?` or intrinsic `rowid = ?` shape;\n- exactly one tracked de...",
       "results": "Focused profile:\n[`benchmark/profile/results/exp-134-keyed-pk-dirty-elision.md`](../benchmark/profile/results/exp-134-keyed-pk-dirty-elision.md)\n\n| workload | baseline wall_ms | candidate wall_ms | delta | baseline intersection_entries | candidate intersection_entries |\n|---|---:|---:|---:|---:|---:|\n| keyed PK subscriptions | 25.54 | 12.45 | -51.3% | 10000 | 3 |\n\nRelease guardrails:\n\n| workload | baseline | candidate | delta |\n|---|---:|---:|---:|\n| many-streams disjoint | 23,946 w/s | 24,618 w/s | +2.8% |\n| many-streams overlap | 9,297 w/s | 8,763 w/s | -5.7% |\n| public keyed-PK wall | 223.32 ms | 217.75 ms | -2.5% |\n\nThe public keyed-PK suite includes a quiet-window drain, so its 200 ms floor\nhides most of the writer-burst improvement. The profile harness uses the exp\n121 wall conven...",
       "reasoning": "**Rejected, but recorded as future evidence.**\n\nThis is a real keyed-PK miss-path optimization: 10,000 per-stream\nintersection probes collapse to the 3 actual watched-row hits. The result is\nstrong enough to keep as evidence that row-level invalidation can matter for\nkeyed subscriptions.\n\nThe implementation shape is the problem. Making this an internal optimization\nrequires `StreamEngine` to recognize and prove more SQL text shapes over time.\nThat is too fragile for the value captured here, especially because aliases,\njoins, composite keys, non-`id` aliases, views, and `WITHOUT ROWID` tables all\nneed conservative escape hatches. The production implementation has been\nremoved from the PR; the implementation commit is preserved by the archive tag\nfor future reference."
+    },
+    {
+      "id": "135",
+      "title": "Writer-isolate dispatch wall vs SQLite step wall audit",
+      "date": "2026-05-10",
+      "status": "in_review",
+      "summary": "Measurement-only: profile-mode counters split writer-handler wall into SQLite step (`writerSqliteUs`) and Dart dispatch (`writerHandlerUs - writerSqliteUs`), exposed cross-isolate via `Database.snapshotWriterProfileCounters()`. On A11c overlap the writer handler is only ~22-25% of burst wall (rest is main-isolate microtask scheduling); within the writer, SQLite is ~55-58% and Dart dispatch is ~42-45% — structural ceiling for \"remove all writer dispatch on overlap\" is ~9-11% of wall, at the per-benchmark decision threshold edge. Closes the `writer-isolate wall vs SQLite wall split` candidate in `signals.json#stream-rerun-dispatch.blockedOnMeasurement`; only completion-side scheduling counter remains",
+      "commit": null,
+      "problem": "[Exp 120](120-flush-admit-bound.md) closed the over-dispatch path inside\n`StreamEngine._flushQueue` and dropped reader-pool dispatcher counters\nto zero on every measured stream workload.\n[Exp 121](121-invalidation-traversal-audit.md) then audited\ninvalidation traversal as a fraction of A11c overlap wall and found it\nsits at the per-benchmark decision threshold edge (10–15% of wall, 80–\n200 ns per probe).\n\nExp 121's future-notes called out the next two dispatch-area\ncandidates from exp 120's list:\n\n- completion-side microtask scheduling cost counter\n- writer dispatch wall counter (Dart-side wall − SQLite step wall)\n\nBoth were listed in `signals.json#stream-rerun-dispatch.blockedOnMeasurement`\nwith no infrastructure to evaluate them. `signals.json` is explicit\nabout the gate this places o...",
+      "hypothesis": "After exp 120 / exp 121, the writer-isolate handler wall on stream\nworkloads is mostly SQLite step time, with Dart-side dispatch (param\nallocation, dirty-table marshalling, message build/send) at a small,\noptimization-sensitive but per-benchmark-sub-threshold share. If this\nis true, writer-side dispatch should not be the next implementation\ntarget on currently-measured workloads, and the structural ceiling for\n\"remove all writer-side Dart dispatch\" should be close to exp 121's\ninvalidation-traversal ceiling (10–15% of A11c overlap wall).\n\nAccept this as a measurement experiment if:\n\n- `parked_total` and `wake_retry_total` stay at zero on every measured\n  workload, reproducing exp 120 / exp 122 as a sanity check on top of\n  the new counters;\n- the audit produces stable `writer_handler_us...",
+      "approach": "Three-part change.\n\n**Profile counters.** `ProfileCounters` gains three writer-isolate\nfields: `writerHandlerUs`, `writerSqliteUs`, `writerHandlerCount`. The\nexisting main-isolate snapshot/reset/diff plumbing works unchanged on\nthe new keys. Dart isolates do not share top-level state, so the\ncounters live in the writer's own copy of the file globals — invisible\nto the main snapshot.\n\n**Snapshot RPC.** The writer protocol gains two new request types,\n`WriterCountersSnapshotRequest` and `WriterCountersResetRequest`,\nserved from inside the writer isolate. Both are gated out of the\nper-message handler stopwatch so snapshot/reset bookkeeping does not\ncontaminate the measured wall. `Database.snapshotWriterProfileCounters()`\nand `Database.resetWriterProfileCounters()` expose the round-trip to\n...",
+      "results": "Reader pool size: 4 (`(Platform.numberOfProcessors - 1).clamp(2, 4)`).\n\nCommand:\n\n```text\ndart run -DRESQLITE_PROFILE=true \\\n  benchmark/profile/writer_step_wall_audit.dart --markdown\n```\n\nThree repeated passes (a/b/c) of the A11c scenarios:\n\n| workload | wall_ms (a/b/c) | sqlite_us / handler_us | dispatch_us / wall_us | dispatch_us per handler |\n|---|---:|---:|---:|---:|\n| A11c baseline (0 streams x 500) | 34.4 / 33.0 / 33.7 | 69 / 66 / 68 % | 16.1 / 17.1 / 16.7 % | 11.1 / 11.3 / 11.2 µs |\n| A11c disjoint (50 streams x 500) | 37.2 / 37.7 / 37.6 | 62 / 63 / 63 % | 13.2 / 12.7 / 13.0 % | 9.8 / 9.6 / 9.8 µs |\n| A11c overlap (50 streams x 500) | 84.6 / 90.9 / 86.9 | 55 / 56 / 58 % | 11.0 / 10.7 / 9.2 % | 18.7 / 19.5 / 16.1 µs |\n| keyed PK subs (50 streams x 200) | 18.4 / 19.8 / 45.5 | 70 /...",
+      "reasoning": "**Accept for review — measurement.**\n\nExp 135 ships the writer-isolate dispatch counters and answers the\n`writer-isolate wall vs SQLite wall split` open candidate.\n`signals.json#stream-rerun-dispatch.blockedOnMeasurement` can drop\nthis entry; only the completion-side microtask scheduling counter\nremains.\n\nThe audit's headline reading is that **writer-side Dart dispatch is\nnot the next dispatch-area implementation target** on the\ncurrently-measured workloads. The structural ceiling for \"remove all\nwriter-side Dart dispatch on A11c overlap\" is ~9–11% of wall — at the\nsame per-benchmark decision threshold edge as exp 121's invalidation\ntraversal ceiling (10–15%). Combined, even fully eliminating both\nwriter dispatch *and* invalidation traversal saves ~20–25% of overlap\nwall, with the remai..."
     }
   ],
   "tracked": [
diff --git a/experiments/135-writer-step-wall-audit.md b/experiments/135-writer-step-wall-audit.md
new file mode 100644
index 0000000..8926545
--- /dev/null
+++ b/experiments/135-writer-step-wall-audit.md
@@ -0,0 +1,209 @@
+# Experiment 135: Writer-isolate dispatch wall vs SQLite step wall audit
+
+**Date:** 2026-05-10
+**Status:** In Review
+**Direction:** `stream-rerun-dispatch`, `measurement-system`
+
+## Problem
+
+[Exp 120](120-flush-admit-bound.md) closed the over-dispatch path inside
+`StreamEngine._flushQueue` and dropped reader-pool dispatcher counters
+to zero on every measured stream workload.
+[Exp 121](121-invalidation-traversal-audit.md) then audited
+invalidation traversal as a fraction of A11c overlap wall and found it
+sits at the per-benchmark decision threshold edge (10–15% of wall, 80–
+200 ns per probe).
+
+Exp 121's future-notes called out the next two dispatch-area
+candidates from exp 120's list:
+
+- completion-side microtask scheduling cost counter
+- writer dispatch wall counter (Dart-side wall − SQLite step wall)
+
+Both were listed in `signals.json#stream-rerun-dispatch.blockedOnMeasurement`
+with no infrastructure to evaluate them. `signals.json` is explicit
+about the gate this places on dispatch-area implementation work:
+
+> "A new dispatch experiment now needs a counter for completion-side
+> scheduling cost or writer-side dispatch wall showing nonzero
+> headroom on the workload before the change is worth trying."
+
+This experiment ships the second of those measurements.
+
+## Hypothesis
+
+After exp 120 / exp 121, the writer-isolate handler wall on stream
+workloads is mostly SQLite step time, with Dart-side dispatch (param
+allocation, dirty-table marshalling, message build/send) at a small,
+optimization-sensitive but per-benchmark-sub-threshold share. If this
+is true, writer-side dispatch should not be the next implementation
+target on currently-measured workloads, and the structural ceiling for
+"remove all writer-side Dart dispatch" should be close to exp 121's
+invalidation-traversal ceiling (10–15% of A11c overlap wall).
+
+Accept this as a measurement experiment if:
+
+- `parked_total` and `wake_retry_total` stay at zero on every measured
+  workload, reproducing exp 120 / exp 122 as a sanity check on top of
+  the new counters;
+- the audit produces stable `writer_handler_us / wall_us`,
+  `writer_sqlite_us / writer_handler_us`, and `dispatch_us / wall_us`
+  bands across repeated passes for A11c baseline / disjoint / overlap
+  and keyed-PK subscriptions;
+- the result resolves the `writer-isolate wall vs SQLite wall split`
+  open candidate one way or the other, and updates
+  `blockedOnMeasurement` accordingly.
+
+## Approach
+
+Three-part change.
+
+**Profile counters.** `ProfileCounters` gains three writer-isolate
+fields: `writerHandlerUs`, `writerSqliteUs`, `writerHandlerCount`. The
+existing main-isolate snapshot/reset/diff plumbing works unchanged on
+the new keys. Dart isolates do not share top-level state, so the
+counters live in the writer's own copy of the file globals — invisible
+to the main snapshot.
+
+**Snapshot RPC.** The writer protocol gains two new request types,
+`WriterCountersSnapshotRequest` and `WriterCountersResetRequest`,
+served from inside the writer isolate. Both are gated out of the
+per-message handler stopwatch so snapshot/reset bookkeeping does not
+contaminate the measured wall. `Database.snapshotWriterProfileCounters()`
+and `Database.resetWriterProfileCounters()` expose the round-trip to
+audit harnesses; release builds do the round-trip too, but the
+returned counters are zero because the increments themselves are
+gated behind `kProfileMode`.
+
+**Handler instrumentation.** Each writer handler is wrapped in two
+profile-mode-only stopwatches: one for the full handler body
+(handler_us), one inside an `_measureSqlite` helper that brackets the
+FFI calls that drive SQLite (`resqliteExecute`, `resqliteRunBatch`,
+`resqliteRunBatchNested`, the cached transaction-control stmts
+`resqliteTxBeginImmediate` / `resqliteTxCommit` / `resqliteTxRollback`,
+the `SAVEPOINT/RELEASE/ROLLBACK TO` `resqliteExec` calls, and the
+prepare+step pass inside `_handleTxQuery`). `dispatch_us = handler_us
+− sqlite_us` is the writer-side Dart dispatch wall.
+
+The audit harness extends `audit_workloads.dart` to reset and snapshot
+the writer counters around the existing A11c and keyed-PK scenarios,
+merging the writer-isolate keys into the same counter map exp 119 /
+exp 121 already consume. A new harness file
+`benchmark/profile/writer_step_wall_audit.dart` formats the
+A11c-baseline / A11c-disjoint / A11c-overlap / keyed-PK report.
+
+## Results
+
+Reader pool size: 4 (`(Platform.numberOfProcessors - 1).clamp(2, 4)`).
+
+Command:
+
+```text
+dart run -DRESQLITE_PROFILE=true \
+  benchmark/profile/writer_step_wall_audit.dart --markdown
+```
+
+Three repeated passes (a/b/c) of the A11c scenarios:
+
+| workload | wall_ms (a/b/c) | sqlite_us / handler_us | dispatch_us / wall_us | dispatch_us per handler |
+|---|---:|---:|---:|---:|
+| A11c baseline (0 streams x 500) | 34.4 / 33.0 / 33.7 | 69 / 66 / 68 % | 16.1 / 17.1 / 16.7 % | 11.1 / 11.3 / 11.2 µs |
+| A11c disjoint (50 streams x 500) | 37.2 / 37.7 / 37.6 | 62 / 63 / 63 % | 13.2 / 12.7 / 13.0 % | 9.8 / 9.6 / 9.8 µs |
+| A11c overlap (50 streams x 500) | 84.6 / 90.9 / 86.9 | 55 / 56 / 58 % | 11.0 / 10.7 / 9.2 % | 18.7 / 19.5 / 16.1 µs |
+| keyed PK subs (50 streams x 200) | 18.4 / 19.8 / 45.5 | 70 / 69 / 93 % | 9.4 / 4.7 / 4.7 % | 8.7 / 10.8 / 10.8 µs |
+
+Sanity: `dispatcher_parked_total = 0`, `dispatcher_wake_retry_total =
+0`, and `dispatcher_max_parked_concurrent = 0` on every workload —
+exp 120 / exp 122 still hold post-instrumentation.
+
+Aggregate readings (full counter table per pass available in
+`benchmark/profile/results/exp-135-writer-step-wall-aggregate.md`):
+
+- **A11c overlap.** The writer-isolate handler accounts for only
+  ~22–25% of the burst wall; the remaining ~75% is on the main
+  isolate, in stream emission delivery, dirty-table propagation, and
+  microtask scheduling. Within the writer handler, dispatch is
+  ~42–45% (the rest is SQLite). The structural ceiling for "remove
+  all writer-side Dart dispatch on overlap" is therefore ~9–11% of
+  overlap wall.
+- **A11c baseline (no streams).** The writer handler is ~50% of the
+  wall — main-isolate work shrinks when there are no stream emissions.
+  SQLite is ~68% of writer handler; dispatch is ~16% of total wall.
+  Per-handler dispatch is ~11 µs, ~3× the noop floor delta from the
+  main isolate (~9 µs writer floor in release-mode `run_profile.dart`).
+- **A11c disjoint.** Column-level elision keeps emissions at zero; the
+  writer-handler share is ~35% of wall, SQLite is ~63% of writer
+  handler, dispatch is ~13% of total wall. Per-handler dispatch ~10
+  µs.
+- **Keyed-PK subscriptions.** Two of three runs land at the same
+  pattern (~30–35% writer-handler share, ~10 µs/handler dispatch). The
+  third run shows variance — `sqlite_us` jumped to 30 ms vs 4–5 ms,
+  almost certainly a WAL checkpoint hit since these are random PK
+  writes against a 10k-row table. Dispatch per handler stays stable
+  at ~10 µs across all three runs, so the variance is in the SQLite
+  share, not the dispatch share.
+
+The dispatch-per-handler microsecond figures are the most stable
+signal: ~11 µs (baseline), ~10 µs (disjoint), ~16–19 µs (overlap),
+~9–11 µs (keyed-PK). Overlap is the only workload where per-handler
+dispatch is materially higher — driven by `getDirtyTableDependencies`
+returning a populated set instead of an empty one (vs disjoint, which
+column-elides before the dirty harvest matters; vs baseline, which
+has no streams to dirty for).
+
+## Decision
+
+**Accept for review — measurement.**
+
+Exp 135 ships the writer-isolate dispatch counters and answers the
+`writer-isolate wall vs SQLite wall split` open candidate.
+`signals.json#stream-rerun-dispatch.blockedOnMeasurement` can drop
+this entry; only the completion-side microtask scheduling counter
+remains.
+
+The audit's headline reading is that **writer-side Dart dispatch is
+not the next dispatch-area implementation target** on the
+currently-measured workloads. The structural ceiling for "remove all
+writer-side Dart dispatch on A11c overlap" is ~9–11% of wall — at the
+same per-benchmark decision threshold edge as exp 121's invalidation
+traversal ceiling (10–15%). Combined, even fully eliminating both
+writer dispatch *and* invalidation traversal saves ~20–25% of overlap
+wall, with the remaining ~75% sitting on the main isolate.
+
+The remaining writer-side dispatch headroom is concentrated in the
+overlap workload — disjoint and keyed-PK both sit below 11% of wall.
+Within overlap the per-handler dispatch jumps from ~10 µs (disjoint)
+to ~17 µs (overlap), and the most plausible explanation for the
+delta is that `getDirtyTableDependencies` returns a populated set
+instead of an empty one. That is a small, bounded native-marshalling
+change — but bounded by the same 9–11% ceiling, so a hypothetical
+implementation needs to carry its own decision threshold case.
+
+The bigger remaining wall-time source on stream workloads is the
+~75% of overlap wall that lives on the main isolate. The
+`completion-side microtask scheduling cost counter` open candidate
+in `signals.json` is therefore unchanged in priority — it is the
+*remaining* gating measurement for the next dispatch-area
+implementation experiment.
+
+## Future Notes
+
+This audit closes one of the two `blockedOnMeasurement` entries on
+`stream-rerun-dispatch`; future runners should check whether the
+remaining `completion-side microtask scheduling cost counter` has
+landed before another dispatch implementation pass. If a future
+candidate targets writer-side dispatch (e.g. dirty-set marshalling
+fast-path on overlap workloads), accept only if it reduces
+`writer_handler_us` per handler on A11c overlap *and* is reproducible
+on the current 5-run release suite — the structural 9–11% ceiling
+makes the per-benchmark decision threshold tight.
+
+The instrumentation is small enough that it can stay live in the
+`audit_workloads.dart` shared scenarios going forward — every future
+dispatch audit picks up the writer-handler share for free, the same
+way exp 121's audit re-uses exp 119's scenarios.
+
+The variance in the keyed-PK SQLite share (likely WAL-checkpoint
+driven) is a workload property, not an instrumentation issue — the
+dispatch-per-handler signal stays stable across that variance, which
+is the whole point of separating the writer counters from total wall.
diff --git a/experiments/JOURNAL.md b/experiments/JOURNAL.md
index 2acdef0..8c629a1 100644
--- a/experiments/JOURNAL.md
+++ b/experiments/JOURNAL.md
@@ -117,6 +117,28 @@ main before claiming acceptance — and ask, before opening, whether the
 contention path the change targets is still reachable on current main
 or whether some recently-accepted experiment now elides it.*
 
+### Cross-isolate counters need a snapshot RPC, but it's a one-time cost
+
+`ProfileCounters` started as main-isolate-only by design — Dart isolates
+don't share top-level state, so a writer-isolate counter increment is
+invisible to the main snapshot. [Exp 135](135-writer-step-wall-audit.md)
+needed writer-side dispatch wall counters and added the missing piece:
+two new request types (`WriterCountersSnapshotRequest`,
+`WriterCountersResetRequest`) on the writer protocol and a
+`Database.snapshotWriterProfileCounters()` accessor. The snapshot RPC
+itself is excluded from the per-handler stopwatch so it doesn't
+contaminate the measured wall.
+
+Once the snapshot path exists, additional writer-side counters cost
+only their own field. The same pattern can extend to reader-pool
+isolates if a future experiment needs reader-internal counters
+(e.g., per-reader cache hit rate, time inside `decodeQuery`).
+
+*Reapplies whenever a measurement experiment wants per-isolate state
+visible from the main audit harness. Adding the snapshot-RPC scaffolding
+is a one-time protocol addition; subsequent counters in that isolate
+get exported for free.*
+
 ### Admission loops need concrete resources before checking capacity
 
 [Exp 122](122-concrete-reader-pool-stream-admission.md) found a subtle async admission
diff --git a/experiments/README.md b/experiments/README.md
index d170ae4..1c6b129 100644
--- a/experiments/README.md
+++ b/experiments/README.md
@@ -73,6 +73,7 @@ moved them.
 | [122](122-concrete-reader-pool-stream-admission.md) | Concrete reader-pool stream admission | Initializes `StreamEngine` with a concrete `ReaderPool` so `_flushQueue` stays synchronous and bounded by `availableWorkerCount`; tests now use diagnostics for stream registry size, and post-rebase profile counters stay at zero parks/retries/max-parked on A11c overlap and keyed-PK workloads |  |
 | [125](125-wide-ascii-batch-params.md) | Wide ASCII batch parameter encoding | Direct ASCII payload packing skips temporary per-string UTF-8 lists in large wide batches; focused 10k x20 improves 17.199 → 12.760 ms and release Wide Batch Insert improves 18.201 → 13.031 ms |  |
 | [126](126-wide-utf8-batch-packing.md) | Wide UTF-8 batch parameter packing | Direct UTF-8 payload packing extends exp 125's allocation win to guarded non-ASCII wide batches; focused Unicode 10k x20 improves 21.945 → 18.988 ms and emoji 10k x20 improves 24.187 → 17.458 ms while release write-suite guardrails remain neutral |  |
+| [135](135-writer-step-wall-audit.md) | Writer-isolate dispatch wall vs SQLite step wall audit | Measurement-only: profile-mode counters split writer-handler wall into SQLite step (`writerSqliteUs`) and Dart dispatch (`writerHandlerUs - writerSqliteUs`), exposed cross-isolate via `Database.snapshotWriterProfileCounters()`. On A11c overlap the writer handler is only ~22-25% of burst wall (rest is main-isolate microtask scheduling); within the writer, SQLite is ~55-58% and Dart dispatch is ~42-45% — structural ceiling for "remove all writer dispatch on overlap" is ~9-11% of wall, at the per-benchmark decision threshold edge. Closes the `writer-isolate wall vs SQLite wall split` candidate in `signals.json#stream-rerun-dispatch.blockedOnMeasurement`; only completion-side scheduling counter remains |  |
 
 ## Rejected
 
diff --git a/experiments/signals.json b/experiments/signals.json
index 36a3064..b9ee01e 100644
--- a/experiments/signals.json
+++ b/experiments/signals.json
@@ -24,9 +24,9 @@
       "id": "stream-rerun-dispatch",
       "status": "active",
       "subsystems": ["streaming", "dispatch", "reader-pool", "invalidation"],
-      "currentRead": "Stream fan-out performance is shaped by rerun scheduling, reader-pool admission, completion-side churn, and dependency precision. Queue changes have produced both strong wins and sharp regressions. Exp 106 polish (column-level dependency tracking) absorbed most of the parked-dispatcher contention by eliding stream re-queries on the writer side, before they reach the reader pool. Exp 115 then made the parked-dispatcher path directly observable; exp 118 used that counter gate to remove wake retries; exp 119 measured the surviving parking signal; exp 120 closed the upstream over-dispatch in StreamEngine._flushQueue (parked_total drops 3,590 → 0 on A11c overlap and 1,198 → 0 on keyed-PK; max_parked 46 → 0). Exp 121 then audited the third candidate from exp 120's future notes — invalidation traversal — under a writer-side burst wall convention (stopwatch stops on the last write) and found it accounts for 10–15% of A11c overlap wall (column intersection 2.5–5.7%), 13–14% of keyed-PK wall, and 22–23% of disjoint wall (the latter only because column elision shrinks the reader-pool denominator). At ~16–27 µs per write absolute cost, removing the entire path saves ~8–14 ms on a 100 ms overlap burst — at the per-benchmark decision threshold edge. Exp 122 removes the remaining stream-admission async boundary by constructing StreamEngine with a concrete ReaderPool, so _flushQueue stays synchronous and bounded without a separate single-flight guard. Exp 134 proved a rowid precision layer can halve keyed-PK writer-burst wall for verified simple `WHERE id = ?` INTEGER PRIMARY KEY streams (25.54 → 12.45 ms, intersection probes 10,000 → 3), but it is rejected as a production implementation because the merge path depends on fragile internal SQL text recognition. The implementation is preserved at `archive/exp-134`; revisit the signal only through an explicit row observer API, trace metadata, or another stronger dependency model. Future reader-pool dispatch work should look at completion-side churn or write-side dispatch; the admission path, invalidation traversal, and SQL-recognizer-based keyed-PK miss path are not active implementation targets on currently-measured workloads.",
-      "keyPriors": ["106", "119", "120", "121", "122", "134"],
-      "archive": ["045", "075", "083", "084", "085", "100", "105", "114", "115", "118"],
+      "currentRead": "Stream fan-out performance is shaped by rerun scheduling, reader-pool admission, completion-side churn, and dependency precision. Queue changes have produced both strong wins and sharp regressions. Exp 106 polish (column-level dependency tracking) absorbed most of the parked-dispatcher contention by eliding stream re-queries on the writer side, before they reach the reader pool. Exp 115 then made the parked-dispatcher path directly observable; exp 118 used that counter gate to remove wake retries; exp 119 measured the surviving parking signal; exp 120 closed the upstream over-dispatch in StreamEngine._flushQueue (parked_total drops 3,590 → 0 on A11c overlap and 1,198 → 0 on keyed-PK; max_parked 46 → 0). Exp 121 audited the third candidate from exp 120's future notes — invalidation traversal — under a writer-side burst wall convention (stopwatch stops on the last write) and found it accounts for 10–15% of A11c overlap wall (column intersection 2.5–5.7%), 13–14% of keyed-PK wall, and 22–23% of disjoint wall. Exp 122 removes the remaining stream-admission async boundary by constructing StreamEngine with a concrete ReaderPool, so _flushQueue stays synchronous and bounded without a separate single-flight guard. Exp 134 proved a rowid precision layer can halve keyed-PK writer-burst wall for verified simple `WHERE id = ?` INTEGER PRIMARY KEY streams (25.54 → 12.45 ms, intersection probes 10,000 → 3), but it is rejected as a production implementation because the merge path depends on fragile internal SQL text recognition. Exp 135 ships the writer-isolate dispatch wall counter the direction's `blockedOnMeasurement` listed: on A11c overlap the writer handler is only ~22-25% of burst wall (rest is main-isolate microtask scheduling), and within the writer, SQLite step is ~55-58% with Dart dispatch ~42-45%. The structural ceiling for removing all writer-side Dart dispatch on overlap is ~9-11% of wall — same per-benchmark decision threshold edge as exp 121's invalidation traversal ceiling. Future reader-pool dispatch work should target completion-side scheduling on the main isolate (still gated on its own counter); writer-side dispatch, admission, invalidation traversal, and SQL-recognizer-based keyed-PK miss paths are not active implementation targets on currently-measured workloads.",
+      "keyPriors": ["106", "120", "121", "122", "134", "135"],
+      "archive": ["045", "075", "083", "084", "085", "100", "105", "114", "115", "118", "119"],
       "interestingIf": [
         "a change reduces duplicate reruns before reader-pool admission",
         "a workload shows row-level precision is worth explicit API or metadata design outside a SQL text recognizer",
@@ -45,12 +45,6 @@
           "addedAfter": "120",
           "blockedOn": "no current counter for completion-side scheduling cost"
         },
-        {
-          "idea": "writer-isolate wall vs SQLite wall split on overlap workloads",
-          "addedDate": "2026-05-02",
-          "addedAfter": "120",
-          "blockedOn": "no profile-mode split between writer dispatch and SQLite step time"
-        },
         {
           "idea": "long-running concurrent-reads workload that sustains parked dispatchers past pool size",
           "addedDate": "2026-04-30",
@@ -66,10 +60,9 @@
         }
       ],
       "blockedOnMeasurement": [
-        "completion-side microtask scheduling cost counter",
-        "writer-isolate wall vs SQLite wall split for overlap workloads"
+        "completion-side microtask scheduling cost counter"
       ],
-      "notesForExperimenters": "This is a good area for measurement-first work. Avoid assuming a larger reader pool helps; exp 105 found the opposite under A11c fan-out. Use exp 115/119 counters before changing dispatch. After exp 118 + exp 120, `dispatcherParkedTotal` and `dispatcherWakeRetryTotal` stay at zero on every measured stream workload — the parked-dispatcher signal is not the active target. Exp 121 took invalidation traversal off the candidate list (10–15% of overlap wall, 2.5–5.7% intersection, 80–200 ns per probe); the structural ceiling means an experiment that fully eliminated `onDependencyChanges` would shave 8–14 ms off a 100 ms overlap burst — at the per-benchmark decision threshold edge — and column intersection is already O(1) bitset. Exp 122 keeps admission simple by giving StreamEngine a concrete ReaderPool and moving stream registry checks to diagnostics. Exp 134 is proof that row-level precision can win, but its SQL-recognizer implementation is rejected; revive it only with explicit API/design or real workload evidence. A new dispatch experiment now needs a counter for completion-side scheduling cost or writer-side dispatch wall showing nonzero headroom on the workload before the change is worth trying."
+      "notesForExperimenters": "This is a good area for measurement-first work. Avoid assuming a larger reader pool helps; exp 105 found the opposite under A11c fan-out. Use exp 115/119/135 counters before changing dispatch. After exp 118 + exp 120, `dispatcherParkedTotal` and `dispatcherWakeRetryTotal` stay at zero on every measured stream workload — the parked-dispatcher signal is not the active target. Exp 121 took invalidation traversal off the candidate list (10–15% of overlap wall, 2.5–5.7% intersection, 80–200 ns per probe). Exp 135 then took writer-side Dart dispatch off the candidate list: on A11c overlap the writer handler is only ~22-25% of burst wall, and Dart dispatch is ~42-45% of writer handler — structural ceiling for removing all writer-side Dart dispatch is ~9-11% of overlap wall, the same per-benchmark decision threshold edge as exp 121. Exp 122 keeps admission simple by giving StreamEngine a concrete ReaderPool and moving stream registry checks to diagnostics. Exp 134 is proof that row-level precision can win, but its SQL-recognizer implementation is rejected; revive it only with explicit API/design or real workload evidence. The remaining open dispatch-area target is the ~75% of A11c overlap wall that lives on the main isolate; a new dispatch experiment needs the completion-side scheduling counter showing nonzero headroom on the workload before the change is worth trying."
     },
     {
       "id": "parameter-encoding-and-binding",
@@ -222,9 +215,9 @@
       "id": "measurement-system",
       "status": "active",
       "subsystems": ["benchmarking", "profiling", "methodology"],
-      "currentRead": "Several plausible optimizations failed because the benchmark did not stress the target path or because run noise hid small effects. Measurement work can be the highest-signal experiment. Exp 119/121 are the latest examples: exp 119 located surviving dispatch pressure in stream admission, and exp 121 then ruled out invalidation traversal as a wall-time target by reading existing counters as a fraction of overlap wall (~7%, intersection ~1.6–1.9%).",
-      "keyPriors": ["099", "110", "111", "115", "119", "121"],
-      "archive": ["055", "088", "102", "108", "113", "116"],
+      "currentRead": "Several plausible optimizations failed because the benchmark did not stress the target path or because run noise hid small effects. Measurement work can be the highest-signal experiment. Exp 119/121/135 are the recent examples: exp 119 located surviving dispatch pressure in stream admission, exp 121 ruled out invalidation traversal as a wall-time target (10–15% of overlap wall), and exp 135 ruled out writer-side Dart dispatch (~9-11% structural ceiling on overlap wall) by adding cross-isolate writer-handler / SQLite-step counters and reading them on the same A11c / keyed-PK scenarios.",
+      "keyPriors": ["099", "110", "111", "115", "121", "135"],
+      "archive": ["055", "088", "102", "108", "113", "116", "119"],
       "interestingIf": [
         "a profiler or focused benchmark exposes a cost hidden by the release suite",
         "a control metric can identify noisy runs before results are trusted",
@@ -243,11 +236,6 @@
           "idea": "completion-side scheduling cost counter (microtasks / event loop)",
           "addedDate": "2026-05-02",
           "addedAfter": "120"
-        },
-        {
-          "idea": "writer dispatch wall counter (dart wall - SQLite step wall)",
-          "addedDate": "2026-05-02",
-          "addedAfter": "120"
         }
       ],
       "blockedOnMeasurement": [],
@@ -542,6 +530,21 @@
         "watch release-suite Wide Batch Insert and narrow Batch Insert together because the public suite is still ASCII-heavy",
         "only pursue blob-heavy or broader embedded-NUL work with a workload that crosses the same large/wide guard"
       ]
+    },
+    "135": {
+      "directions": ["stream-rerun-dispatch", "measurement-system"],
+      "outcomeClass": "in_review_measurement",
+      "changedBeliefs": [
+        "On A11c overlap the writer-isolate handler accounts for only ~22-25% of writer-side burst wall — the remaining ~75% lives on the main isolate (microtask scheduling, stream emission delivery)",
+        "Within the writer handler, SQLite step is ~55-58% on overlap and ~62-69% on baseline / disjoint / keyed-PK; Dart-side dispatch is ~42-45% on overlap and ~30-38% on the others",
+        "The structural ceiling for removing all writer-side Dart dispatch on A11c overlap is ~9-11% of total wall — same per-benchmark decision threshold edge as exp 121's invalidation traversal ceiling. Removing both writer dispatch and invalidation traversal entirely saves ~20-25% of overlap wall, with the remaining ~75% sitting on the main isolate.",
+        "Per-handler dispatch is stable across runs: ~11 µs (baseline), ~10 µs (disjoint), ~16-19 µs (overlap), ~9-11 µs (keyed-PK). The overlap delta is consistent with `getDirtyTableDependencies` returning a populated set instead of an empty one"
+      ],
+      "nextSignals": [
+        "future writer-side dispatch experiments need to clear the ~9-11% overlap wall ceiling reproducibly on a 5-run release suite, given the per-benchmark decision threshold edge",
+        "the remaining `completion-side microtask scheduling cost counter` open candidate is the next gating measurement for stream-rerun-dispatch implementation work",
+        "cross-isolate counter pattern (snapshot RPC + Database.snapshotWriterProfileCounters) lets future experiments add other writer-isolate counters cheaply"
+      ]
     }
   }
 }
diff --git a/lib/src/database.dart b/lib/src/database.dart
index 1845b53..a7e7f57 100644
--- a/lib/src/database.dart
+++ b/lib/src/database.dart
@@ -497,6 +497,42 @@ final class Database {
       streamLength: streamEngine.length,
     );
   }
+
+  /// Snapshot the writer-isolate's `ProfileCounters` map. Profile-mode
+  /// only meaningful — release builds tree-shake the increments and
+  /// always return zero values for the writer-isolate counters.
+  ///
+  /// Provided so cross-isolate audit harnesses can read writer-side
+  /// dispatch counters that would otherwise be invisible: Dart isolates
+  /// do not share top-level state, so the main isolate's
+  /// `ProfileCounters` snapshot would only ever return its own copy.
+  /// See [EXP-135](../../experiments/135-writer-step-wall-audit.md).
+  ///
+  /// Acquires the writer mutex for the duration of the snapshot RPC so
+  /// the read sits at a well-defined point in writer history — the same
+  /// "no interleaving with other writer traffic" guarantee that
+  /// `execute()` / `transaction()` rely on. Without the mutex a
+  /// snapshot could land between the `BEGIN` and `COMMIT` messages of
+  /// an in-flight `transaction()`, sampling partial-transaction state.
+  Future<Map<String, int>> snapshotWriterProfileCounters() async {
+    _ensureOpen();
+    final _DatabaseRuntime(:writer) = await _runtime;
+    return writer.locked(() => writer.snapshotWriterCounters());
+  }
+
+  /// Reset the writer-isolate's `ProfileCounters` to zero. Profile-mode
+  /// audit harnesses bracket measured workloads with this so the
+  /// snapshot reflects only the bracketed work
+  /// ([EXP-135](../../experiments/135-writer-step-wall-audit.md)).
+  ///
+  /// Like [snapshotWriterProfileCounters], runs under the writer mutex
+  /// so the reset point is well-defined relative to other writer
+  /// traffic.
+  Future<void> resetWriterProfileCounters() async {
+    _ensureOpen();
+    final _DatabaseRuntime(:writer) = await _runtime;
+    await writer.locked(() => writer.resetWriterCounters());
+  }
 }
 
 typedef _DatabaseRuntime = ({
diff --git a/lib/src/profile_counters.dart b/lib/src/profile_counters.dart
index f8d5028..7fb9677 100644
--- a/lib/src/profile_counters.dart
+++ b/lib/src/profile_counters.dart
@@ -110,6 +110,32 @@ class ProfileCounters {
   /// isolate (where `ReaderPool._dispatch` runs).
   static int dispatcherCurrentParked = 0;
 
+  /// Cumulative wall-clock microseconds the writer-isolate spent
+  /// handling each request, measured from receipt of the message to the
+  /// `replyPort.send` call. Includes Dart-side dispatch (param
+  /// allocation, dirty-table marshalling, message decode/build) and the
+  /// FFI calls that actually drive SQLite. Populated only inside the
+  /// writer isolate; reachable from main via
+  /// `Database.snapshotWriterProfileCounters` (which routes through
+  /// `Writer.snapshotWriterCounters`).
+  ///
+  /// Added by [EXP-135](../../experiments/135-writer-step-wall-audit.md)
+  /// to provide the writer-side wall counter named in
+  /// `signals.json#stream-rerun-dispatch.blockedOnMeasurement`.
+  static int writerHandlerUs = 0;
+
+  /// Cumulative wall-clock microseconds the writer-isolate spent inside
+  /// SQLite-driving FFI calls (`resqliteExecute`, `resqliteRunBatch`,
+  /// `resqliteRunBatchNested`, transaction-control calls, and the
+  /// step+decode portion of transaction reads). Subtracting this from
+  /// [writerHandlerUs] yields the writer-side Dart dispatch wall.
+  static int writerSqliteUs = 0;
+
+  /// Number of writer-isolate requests counted. One increment per
+  /// handled message. Lets the audit harness compute per-request
+  /// averages without tracking type-specific counts.
+  static int writerHandlerCount = 0;
+
   /// Take a named snapshot of all counter values.
   static Map<String, int> snapshot() => {
     'rows_decoded': rowsDecoded,
@@ -121,6 +147,9 @@ class ProfileCounters {
     'dispatcher_parked_total': dispatcherParkedTotal,
     'dispatcher_wake_retry_total': dispatcherWakeRetryTotal,
     'dispatcher_max_parked_concurrent': dispatcherMaxParkedConcurrent,
+    'writer_handler_us': writerHandlerUs,
+    'writer_sqlite_us': writerSqliteUs,
+    'writer_handler_count': writerHandlerCount,
   };
 
   /// Compute `after - before` for every key present in both snapshots.
@@ -149,5 +178,8 @@ class ProfileCounters {
     dispatcherWakeRetryTotal = 0;
     dispatcherMaxParkedConcurrent = 0;
     dispatcherCurrentParked = 0;
+    writerHandlerUs = 0;
+    writerSqliteUs = 0;
+    writerHandlerCount = 0;
   }
 }
diff --git a/lib/src/writer/write_worker.dart b/lib/src/writer/write_worker.dart
index ae34ddc..34352c3 100644
--- a/lib/src/writer/write_worker.dart
+++ b/lib/src/writer/write_worker.dart
@@ -17,6 +17,7 @@ import '../dependency_tracking.dart';
 import '../exceptions.dart';
 import '../native/request_cache.dart';
 import '../native/resqlite_bindings.dart';
+import '../profile_counters.dart';
 import '../profile_mode.dart';
 import '../query_decoder.dart';
 import '../row.dart';
@@ -72,6 +73,24 @@ final class CloseRequest extends WriterRequest {
   CloseRequest(super.replyPort);
 }
 
+/// Snapshot the writer-isolate's `ProfileCounters` and return them to
+/// main. Used by profile-mode audit harnesses to read writer-side
+/// counters that live in the writer isolate's per-isolate top-level
+/// state ([EXP-135](../../experiments/135-writer-step-wall-audit.md)).
+/// Replies with a [WriterCountersSnapshotResponse]. Cheap regardless
+/// of build mode — it just builds a small map.
+final class WriterCountersSnapshotRequest extends WriterRequest {
+  WriterCountersSnapshotRequest(super.replyPort);
+}
+
+/// Reset the writer-isolate's `ProfileCounters` to zero. Used by
+/// profile-mode audit harnesses to bracket a workload measurement
+/// without dragging in counter values from setup or warmup.
+/// Replies with `true` once the reset has executed.
+final class WriterCountersResetRequest extends WriterRequest {
+  WriterCountersResetRequest(super.replyPort);
+}
+
 // ---------------------------------------------------------------------------
 // Response types
 // ---------------------------------------------------------------------------
@@ -98,6 +117,14 @@ final class BatchResponse {
   final TableDependencies modifications;
 }
 
+/// Response to [WriterCountersSnapshotRequest]. Carries the
+/// writer-isolate's `ProfileCounters.snapshot()` map back to main. The
+/// map is value-typed so the SendPort deep-copy is cheap.
+final class WriterCountersSnapshotResponse {
+  const WriterCountersSnapshotResponse(this.counters);
+  final Map<String, int> counters;
+}
+
 // ---------------------------------------------------------------------------
 // Writer-specific FFI binding
 // ---------------------------------------------------------------------------
@@ -167,6 +194,17 @@ void writerEntrypoint(List<Object> args) {
     // tree-shakes away entirely at AOT. Build with
     // `-DRESQLITE_PROFILE=true` to enable (see lib/src/profile_mode.dart
     // and experiments/080-dispatch-budget.md).
+    //
+    // Per-message handler stopwatch covers the work between message
+    // receipt and `replyPort.send`. Snapshot-style requests are
+    // bookkeeping only and do not contribute to the writer wall;
+    // exclude them from the counter ([EXP-135]) so the audit fraction
+    // reflects the SQL-driving handlers exclusively.
+    final Stopwatch? handlerSw =
+        kProfileMode && message is! WriterCountersSnapshotRequest &&
+                message is! WriterCountersResetRequest
+            ? (Stopwatch()..start())
+            : null;
     if (kProfileMode) {
       Timeline.startSync('writer.handle.${message.runtimeType}');
     }
@@ -184,6 +222,13 @@ void writerEntrypoint(List<Object> args) {
           _handleCommit(state, message);
         case RollbackRequest():
           _handleRollback(state, message);
+        case WriterCountersSnapshotRequest():
+          message.replyPort.send(
+            WriterCountersSnapshotResponse(ProfileCounters.snapshot()),
+          );
+        case WriterCountersResetRequest():
+          ProfileCounters.reset();
+          message.replyPort.send(true);
         case CloseRequest():
           receivePort.close();
           message.replyPort.send(true);
@@ -206,6 +251,11 @@ void writerEntrypoint(List<Object> args) {
     } finally {
       if (kProfileMode) {
         Timeline.finishSync();
+        if (handlerSw != null) {
+          handlerSw.stop();
+          ProfileCounters.writerHandlerUs += handlerSw.elapsedMicroseconds;
+          ProfileCounters.writerHandlerCount++;
+        }
       }
     }
   };
@@ -215,8 +265,26 @@ void writerEntrypoint(List<Object> args) {
 // Per-request handlers
 // ---------------------------------------------------------------------------
 
+/// Run [body] under a profile-mode stopwatch and accumulate the
+/// elapsed time into [ProfileCounters.writerSqliteUs]. The wrapper is
+/// only meaningful inside the writer isolate; release builds skip it
+/// entirely via the `kProfileMode` const-false branch
+/// ([EXP-135](../../experiments/135-writer-step-wall-audit.md)).
+@pragma('vm:prefer-inline')
+T _measureSqlite<T>(T Function() body) {
+  if (!kProfileMode) return body();
+  final sw = Stopwatch()..start();
+  try {
+    return body();
+  } finally {
+    sw.stop();
+    ProfileCounters.writerSqliteUs += sw.elapsedMicroseconds;
+  }
+}
+
 void _handleExecute(_WriterState state, ExecuteRequest msg) {
-  final result = executeWrite(state.dbHandle, msg.sql, msg.params);
+  final result =
+      _measureSqlite(() => executeWrite(state.dbHandle, msg.sql, msg.params));
   // Dirty tables and columns are only collected outside transactions.
   // Inside a transaction they accumulate in the C-level dirty sets until
   // the outermost transaction completes.
@@ -230,10 +298,14 @@ void _handleBatch(_WriterState state, BatchRequest msg) {
   if (state.txDepth > 0) {
     // Inside an open transaction: skip the batch's own BEGIN/COMMIT and
     // let the dirty set accumulate until the outermost commit.
-    executeNestedBatchWrite(state.dbHandle, msg.sql, msg.paramSets);
+    _measureSqlite(
+      () => executeNestedBatchWrite(state.dbHandle, msg.sql, msg.paramSets),
+    );
     msg.replyPort.send(const BatchResponse(TableDependencies.none));
   } else {
-    executeBatchWrite(state.dbHandle, msg.sql, msg.paramSets);
+    _measureSqlite(
+      () => executeBatchWrite(state.dbHandle, msg.sql, msg.paramSets),
+    );
     msg.replyPort.send(
       BatchResponse(getDirtyTableDependencies(state.dbHandle)),
     );
@@ -246,20 +318,22 @@ void _handleTxQuery(_WriterState state, QueryRequest msg) {
   final sqlNative = cachedSqlUtf8(msg.sql);
   final paramsNative = allocateParams(msg.params);
   try {
-    final stmt = _resqliteStmtAcquireWriter(
-      state.dbHandle,
-      sqlNative.cast(),
-      paramsNative,
-      msg.params.length,
-    );
-    if (stmt == ffi.nullptr) {
-      throw ResqliteQueryException(
-        resqliteErrmsg(state.dbHandle).toDartString(),
-        sql: msg.sql,
-        parameters: msg.params,
+    final raw = _measureSqlite(() {
+      final stmt = _resqliteStmtAcquireWriter(
+        state.dbHandle,
+        sqlNative.cast(),
+        paramsNative,
+        msg.params.length,
       );
-    }
-    final raw = decodeQuery(stmt, msg.sql);
+      if (stmt == ffi.nullptr) {
+        throw ResqliteQueryException(
+          resqliteErrmsg(state.dbHandle).toDartString(),
+          sql: msg.sql,
+          parameters: msg.params,
+        );
+      }
+      return decodeQuery(stmt, msg.sql);
+    });
     msg.replyPort.send(
       QueryResponse(ResultSet(raw.values, raw.schema, raw.rowCount)),
     );
@@ -278,7 +352,7 @@ void _handleBegin(_WriterState state, BeginRequest msg) {
   // propagates — _runTransaction on the main isolate will never have
   // entered its body, so there is nothing to roll back.
   if (state.txDepth == 0) {
-    final rc = resqliteTxBeginImmediate(state.dbHandle);
+    final rc = _measureSqlite(() => resqliteTxBeginImmediate(state.dbHandle));
     if (rc != 0) {
       throw ResqliteTransactionException(
         resqliteErrmsg(state.dbHandle).toDartString(),
@@ -289,7 +363,7 @@ void _handleBegin(_WriterState state, BeginRequest msg) {
   } else {
     final sp = 'SAVEPOINT s${state.txDepth}'.toNativeUtf8();
     try {
-      final rc = resqliteExec(state.dbHandle, sp);
+      final rc = _measureSqlite(() => resqliteExec(state.dbHandle, sp));
       if (rc != 0) {
         throw ResqliteTransactionException(
           resqliteErrmsg(state.dbHandle).toDartString(),
@@ -311,7 +385,7 @@ void _handleCommit(_WriterState state, CommitRequest msg) {
   // longer active. The next request sees a predictable state.
   final newDepth = state.txDepth - 1;
   if (newDepth == 0) {
-    final rc = resqliteTxCommit(state.dbHandle);
+    final rc = _measureSqlite(() => resqliteTxCommit(state.dbHandle));
     if (rc != 0) {
       // Capture the error message BEFORE any further sqlite calls — the
       // errmsg pointer is only stable until the next call.
@@ -320,7 +394,7 @@ void _handleCommit(_WriterState state, CommitRequest msg) {
       // back, but behavior depends on the error (deferred FK, I/O, etc.).
       // Issue a best-effort ROLLBACK and ignore its return — it may
       // legitimately fail with "no transaction active".
-      resqliteTxRollback(state.dbHandle);
+      _measureSqlite(() => resqliteTxRollback(state.dbHandle));
       // Drop any tables/columns dirtied by the aborted transaction.
       discardDirtyTableDependencies(state.dbHandle);
       state.txDepth = newDepth;
@@ -336,7 +410,7 @@ void _handleCommit(_WriterState state, CommitRequest msg) {
     );
   } else {
     final sp = 'RELEASE s$newDepth'.toNativeUtf8();
-    final rc = resqliteExec(state.dbHandle, sp);
+    final rc = _measureSqlite(() => resqliteExec(state.dbHandle, sp));
     calloc.free(sp);
     if (rc != 0) {
       final errMsg = resqliteErrmsg(state.dbHandle).toDartString();
@@ -358,8 +432,8 @@ void _handleCommit(_WriterState state, CommitRequest msg) {
       // returning an error and cannot surface two.
       final rollbackSp = 'ROLLBACK TO s$newDepth'.toNativeUtf8();
       final releaseSp = 'RELEASE s$newDepth'.toNativeUtf8();
-      resqliteExec(state.dbHandle, rollbackSp);
-      resqliteExec(state.dbHandle, releaseSp);
+      _measureSqlite(() => resqliteExec(state.dbHandle, rollbackSp));
+      _measureSqlite(() => resqliteExec(state.dbHandle, releaseSp));
       calloc.free(rollbackSp);
       calloc.free(releaseSp);
       state.txDepth = newDepth;
@@ -383,7 +457,7 @@ void _handleRollback(_WriterState state, RollbackRequest msg) {
   // SQLite reports a rollback failure.
   final newDepth = state.txDepth - 1;
   if (newDepth == 0) {
-    final rc = resqliteTxRollback(state.dbHandle);
+    final rc = _measureSqlite(() => resqliteTxRollback(state.dbHandle));
     // Clear the dirty sets — rolled-back changes don't count for stream
     // invalidation, even if SQLite reported a rollback error.
     discardDirtyTableDependencies(state.dbHandle);
@@ -400,8 +474,8 @@ void _handleRollback(_WriterState state, RollbackRequest msg) {
     // removes the savepoint from SQLite's stack.
     final rollbackSp = 'ROLLBACK TO s$newDepth'.toNativeUtf8();
     final releaseSp = 'RELEASE s$newDepth'.toNativeUtf8();
-    final rc1 = resqliteExec(state.dbHandle, rollbackSp);
-    final rc2 = resqliteExec(state.dbHandle, releaseSp);
+    final rc1 = _measureSqlite(() => resqliteExec(state.dbHandle, rollbackSp));
+    final rc2 = _measureSqlite(() => resqliteExec(state.dbHandle, releaseSp));
     calloc.free(rollbackSp);
     calloc.free(releaseSp);
     state.txDepth = newDepth;
diff --git a/lib/src/writer/writer.dart b/lib/src/writer/writer.dart
index 9ef12db..c4affad 100644
--- a/lib/src/writer/writer.dart
+++ b/lib/src/writer/writer.dart
@@ -168,6 +168,27 @@ final class Writer {
     return result;
   }
 
+  /// Snapshot the writer-isolate's `ProfileCounters` map. Profile-mode
+  /// only meaningful — release builds tree-shake the increments and
+  /// always return the zero-initialized snapshot. Used by audit
+  /// harnesses to read writer-side dispatch counters
+  /// ([EXP-135](../../experiments/135-writer-step-wall-audit.md)).
+  Future<Map<String, int>> snapshotWriterCounters() async {
+    final response = await _request<WriterCountersSnapshotResponse>(
+      (replyPort) => WriterCountersSnapshotRequest(replyPort),
+    );
+    return response.counters;
+  }
+
+  /// Reset the writer-isolate's `ProfileCounters` to zero. Profile-mode
+  /// audit harnesses call this between setup and the measured workload
+  /// so the snapshot reflects only the bracketed work.
+  Future<void> resetWriterCounters() async {
+    await _request<bool>(
+      (replyPort) => WriterCountersResetRequest(replyPort),
+    );
+  }
+
   Future<void> close() async {
     _closed = true;
 
diff --git a/test/database_test.dart b/test/database_test.dart
index 8ba9f6b..6315730 100644
--- a/test/database_test.dart
+++ b/test/database_test.dart
@@ -988,5 +988,36 @@ void main() {
 
       await closedDir.delete(recursive: true);
     });
+
+    // ----- Writer profile counter exposure -----
+
+    // EXP-135 added cross-isolate access to writer-side ProfileCounters.
+    // These tests guard the request/response wiring: even in non-profile
+    // builds the snapshot must round-trip the counter keys (with zero
+    // values, since the increments are gated behind kProfileMode).
+    test(
+      'snapshotWriterProfileCounters returns the EXP-135 keys',
+      () async {
+        final snap = await db.snapshotWriterProfileCounters();
+        expect(snap, contains('writer_handler_us'));
+        expect(snap, contains('writer_sqlite_us'));
+        expect(snap, contains('writer_handler_count'));
+      },
+    );
+
+    test(
+      'resetWriterProfileCounters round-trips and follows snapshot',
+      () async {
+        await db.resetWriterProfileCounters();
+        final after = await db.snapshotWriterProfileCounters();
+        // Increments are gated behind kProfileMode (compile-time const).
+        // In a default test build that flag is off, so reset+snapshot
+        // returns zero for the new keys; we still assert the wiring did
+        // not throw and the keys are populated.
+        expect(after['writer_handler_us'], isNonNegative);
+        expect(after['writer_sqlite_us'], isNonNegative);
+        expect(after['writer_handler_count'], isNonNegative);
+      },
+    );
   });
 }
diff --git a/test/profile_counters_test.dart b/test/profile_counters_test.dart
index 011af0d..effb6eb 100644
--- a/test/profile_counters_test.dart
+++ b/test/profile_counters_test.dart
@@ -23,6 +23,9 @@ void main() {
       'dispatcher_parked_total': 0,
       'dispatcher_wake_retry_total': 0,
       'dispatcher_max_parked_concurrent': 0,
+      'writer_handler_us': 0,
+      'writer_sqlite_us': 0,
+      'writer_handler_count': 0,
     });
 
     ProfileCounters.reset();
@@ -37,6 +40,9 @@ void main() {
       'dispatcher_parked_total': 0,
       'dispatcher_wake_retry_total': 0,
       'dispatcher_max_parked_concurrent': 0,
+      'writer_handler_us': 0,
+      'writer_sqlite_us': 0,
+      'writer_handler_count': 0,
     });
   });
 
@@ -56,4 +62,23 @@ void main() {
     expect(ProfileCounters.dispatcherMaxParkedConcurrent, 0);
     expect(ProfileCounters.dispatcherCurrentParked, 0);
   });
+
+  // Writer-isolate counters added by EXP-135. Snapshot/reset round-trip
+  // is exercised here; cross-isolate population is covered by the
+  // benchmark/profile audit harnesses.
+  test('writer dispatch counters round-trip through snapshot/reset', () {
+    ProfileCounters.writerHandlerUs = 1234;
+    ProfileCounters.writerSqliteUs = 800;
+    ProfileCounters.writerHandlerCount = 50;
+
+    final snap = ProfileCounters.snapshot();
+    expect(snap['writer_handler_us'], 1234);
+    expect(snap['writer_sqlite_us'], 800);
+    expect(snap['writer_handler_count'], 50);
+
+    ProfileCounters.reset();
+    expect(ProfileCounters.writerHandlerUs, 0);
+    expect(ProfileCounters.writerSqliteUs, 0);
+    expect(ProfileCounters.writerHandlerCount, 0);
+  });
 }