diff --git a/.claude/skills/resqlite-experiment/SKILL.md b/.claude/skills/resqlite-experiment/SKILL.md
index 6efe18c8..333e7db2 100644
--- a/.claude/skills/resqlite-experiment/SKILL.md
+++ b/.claude/skills/resqlite-experiment/SKILL.md
@@ -21,8 +21,9 @@ and those files feed the live charts on the GitHub Pages site
 
 1. **The code change** — `native/`, `lib/`, `hook/`, or `test/` as appropriate
 2. **The experiment doc** — `experiments/NNN-short-name.md` with
-   `**Date:** YYYY-MM-DD` frontmatter and a row in `experiments/README.md`
-   (under Accepted or Rejected)
+   `**Date:** YYYY-MM-DD` frontmatter and an `experiments/index/NNN.json` row
+   fragment (`{file, title, impact, status, link}`). `experiments/README.md` is
+   *generated* from those fragments — never hand-edit the README table.
 3. **At least one benchmark result file** — `benchmark/results/<ISO-timestamp>-<label>.md`
    whose **filename timestamp's date** matches the experiment doc's `**Date:**`
 
@@ -112,7 +113,9 @@ Run this mental (or literal) checklist:
 
 - [ ] `git status --short benchmark/results/` — is there an untracked result file?
 - [ ] Does that file's filename timestamp match `grep "^**Date:**" experiments/NNN-*.md`?
-- [ ] Is the experiment listed in `experiments/README.md` (Accepted or Rejected section)?
+- [ ] Is the experiment's README row in its own file,
+      `experiments/index/NNN.json` (`{file, title, impact, status, link}`)?
+      `README.md` is generated from these — don't hand-edit the table.
 - [ ] Is the signal entry in its own file, `experiments/signals/entries/NNN.json`
       (not hand-edited into the generated `signals.json`)?
 - [ ] Does the experiment doc have the headings the parser expects?
@@ -120,8 +123,9 @@ Run this mental (or literal) checklist:
       `Decision` or `Why Accepted` / `Why Rejected`)
 - [ ] Did `finalize_experiment.dart` pass? It only *validates* sources — it does
       not write the generated aggregates, and you must not commit
-      `docs/experiments/history.json`, `docs/benchmarks/devices.json`, or
-      `experiments/signals.json` (the bot regenerates them on `main`).
+      `docs/experiments/history.json`, `docs/benchmarks/devices.json`,
+      `experiments/signals.json`, or `experiments/README.md` (the bot
+      regenerates them on `main`).
 
 The generator's section extraction tolerates a few heading variants; see
 `_extractSection` in `generate_history.dart` for the full list.
@@ -309,16 +313,17 @@ git fetch origin
 
 Experiment PRs used to collide on shared generated files; that is now designed
 out. The generated aggregates — `docs/experiments/history.json`,
-`docs/benchmarks/devices.json`, and `experiments/signals.json` — are
-**bot-owned on `main` and never committed on a branch** (CI's
-`guard-generated-docs` job blocks them, and `check_generated_data.dart` only
-checks that the *sources* build). Each experiment's signal data lives in its
-own file, `experiments/signals/entries/NNN.json`, so two experiments never
-touch the same one. The only files a normal run still shares are
-`experiments/README.md` (rows append) and `experiments/signals/base.json` (the
-per-direction synthesis). You must still claim your number — concurrent runs
-that grab the same number, or ship the same follow-up, still collide (exp 168
-was claimed by three PRs; exp 175 by two runs shipping the *same* follow-up).
+`docs/benchmarks/devices.json`, `experiments/signals.json`, and
+`experiments/README.md` — are **bot-owned on `main` and never committed on a
+branch** (CI's `guard-generated-docs` job blocks them, and
+`check_generated_data.dart` only checks that the *sources* build). Each
+experiment's signal entry and README row each live in their own file —
+`experiments/signals/entries/NNN.json` and `experiments/index/NNN.json` — so
+two experiments never touch the same one. The only file a normal run still
+shares is `experiments/signals/base.json` (the per-direction synthesis). You
+must still claim your number — concurrent runs that grab the same number, or
+ship the same follow-up, still collide (exp 168 was claimed by three PRs; exp
+175 by two runs shipping the *same* follow-up).
 
 **1. Claim the number atomically.** A plain "check open PRs, then pick the next
 free" *races*: two runs check, both see N free, both take N. That is exactly
@@ -371,16 +376,17 @@ which case expect to regenerate `history.json` on the later one.
 ## Resolving a stale derived-file conflict
 
 Generated aggregates no longer conflict: `docs/experiments/history.json`,
-`docs/benchmarks/devices.json`, and `experiments/signals.json` are bot-owned
-and never committed on a branch, so a stale branch just takes `main`'s copy
-with a one-sided auto-merge. If a PR falls behind `main`, the only files that
-can really conflict are hand-edited *sources*:
-
-- `experiments/README.md` — rows append; usually auto-merges. If two
-  experiments inserted at the same spot, fix the row order by hand.
-- `experiments/signals/entries/NNN.json` — one file per experiment, so a true
-  collision only happens when two runs claimed the same number `N`. That's a
-  numbering bug: renumber, never overwrite a prior experiment's entry.
+`docs/benchmarks/devices.json`, `experiments/signals.json`, and
+`experiments/README.md` are bot-owned and never committed on a branch, so a
+stale branch just takes `main`'s copy with a one-sided auto-merge. If a PR
+falls behind `main`, the only files that can really conflict are hand-edited
+*sources*, and each is per-experiment:
+
+- `experiments/index/NNN.json` (the README row) and
+  `experiments/signals/entries/NNN.json` (the signal entry) — one file per
+  experiment, so a true collision only happens when two runs claimed the same
+  number `N`. That's a numbering bug: renumber, never overwrite a prior
+  experiment's file.
 - `experiments/signals/base.json` — two experiments editing the same
   direction's `currentRead` / `notesForExperimenters` narrative is a real
   weave; keep both contributions.
diff --git a/.github/workflows/update-experiments.yml b/.github/workflows/update-experiments.yml
index 8ba24bcc..ecc0a209 100644
--- a/.github/workflows/update-experiments.yml
+++ b/.github/workflows/update-experiments.yml
@@ -6,7 +6,10 @@ on:
     paths:
       - 'experiments/*.md'
       - 'experiments/signals/**'
+      - 'experiments/index/**'
+      - 'experiments/README.template.md'
       - 'benchmark/generate_signals.dart'
+      - 'benchmark/generate_readme.dart'
       - 'benchmark/results/*.md'
       - 'benchmark/results/*.json'
       - 'benchmark/HARDWARE_RESULTS.md'
@@ -44,6 +47,9 @@ jobs:
       - name: Generate signals JSON
         run: dart run benchmark/generate_signals.dart
 
+      - name: Generate experiments README
+        run: dart run benchmark/generate_readme.dart
+
       - name: Generate devices JSON
         run: dart run benchmark/generate_devices.dart
 
@@ -56,13 +62,13 @@ jobs:
       - name: Check for changes
         id: diff
         run: |
-          git diff --quiet docs/ experiments/signals.json && echo "changed=false" >> "$GITHUB_OUTPUT" || echo "changed=true" >> "$GITHUB_OUTPUT"
+          git diff --quiet docs/ experiments/signals.json experiments/README.md && echo "changed=false" >> "$GITHUB_OUTPUT" || echo "changed=true" >> "$GITHUB_OUTPUT"
 
       - name: Commit and push
         if: steps.diff.outputs.changed == 'true'
         run: |
           git config user.name "github-actions[bot]"
           git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
-          git add docs/ experiments/signals.json
-          git commit -m "Auto-update docs (experiments + signals + devices + blog + releases)"
+          git add docs/ experiments/signals.json experiments/README.md
+          git commit -m "Auto-update docs (experiments + signals + README + devices + blog + releases)"
           git push
diff --git a/benchmark/check_experiment_signals.dart b/benchmark/check_experiment_signals.dart
index 355615ff..1a3f8dbf 100644
--- a/benchmark/check_experiment_signals.dart
+++ b/benchmark/check_experiment_signals.dart
@@ -1,3 +1,4 @@
+import 'dart:convert';
 import 'dart:io';
 
 import 'generate_signals.dart' as generate_signals;
@@ -31,40 +32,42 @@ void main() {
   print('Experiment signal map is valid.');
 }
 
+/// Builds the experiment index from the per-experiment fragments
+/// (`experiments/index/NNN.json`). README.md is generated from these, so the
+/// fragments are the fresh source on a branch that hasn't regenerated it. A
+/// fragment is one row object, or a list of rows for a split experiment.
 Map<String, _ExperimentEntry> _readExperimentIndex(
   List<_ValidationError> errors,
 ) {
-  final file = File(_readmePath);
-  if (!file.existsSync()) {
-    _readmeError(errors, 'Missing $_readmePath.');
+  final indexDir = Directory('$_experimentsDir/index');
+  if (!indexDir.existsSync()) {
+    _signalError(errors, 'Missing ${indexDir.path}/ (experiment index fragments).');
     return const {};
   }
 
   final entries = <String, _ExperimentEntry>{};
-  final rowPattern = RegExp(r'^\|\s*\[(\d+\w?)\]\(([^)]+)\)\s*\|');
-  var currentStatus = 'accepted';
-  for (final line in file.readAsStringSync().split('\n')) {
-    if (line.startsWith('## Accepted')) {
-      currentStatus = 'accepted';
-    } else if (line.startsWith('## In Review')) {
-      currentStatus = 'in_review';
-    } else if (line.startsWith('## Rejected')) {
-      currentStatus = 'rejected';
+  for (final file in indexDir.listSync().whereType<File>()) {
+    if (!file.path.endsWith('.json')) continue;
+    final id = file.uri.pathSegments.last.replaceFirst(RegExp(r'\.json$'), '');
+    Object? decoded;
+    try {
+      decoded = json.decode(file.readAsStringSync());
+    } on FormatException catch (error) {
+      _signalError(errors, '${file.path} is not valid JSON: ${error.message}');
+      continue;
+    }
+    final rows = decoded is List ? decoded : [decoded];
+    for (final row in rows) {
+      if (row is! Map) continue;
+      entries[id] = _ExperimentEntry(
+        id: id,
+        filename: row['file']?.toString() ?? '$id.md',
+        status: row['status']?.toString() ?? 'accepted',
+      );
     }
-
-    final match = rowPattern.firstMatch(line);
-    if (match == null) continue;
-
-    final id = match.group(1)!;
-    final filename = match.group(2)!;
-    entries[id] = _ExperimentEntry(
-      id: id,
-      filename: filename,
-      status: currentStatus,
-    );
   }
   if (entries.isEmpty) {
-    _readmeError(errors, 'No experiment rows found in $_readmePath.');
+    _signalError(errors, 'No experiment fragments found in ${indexDir.path}/.');
   }
   return entries;
 }
@@ -631,10 +634,6 @@ void _checkOpenCandidates(
   }
 }
 
-void _readmeError(List<_ValidationError> errors, String message) {
-  errors.add(_ValidationError(_readmePath, message));
-}
-
 void _signalError(List<_ValidationError> errors, String message) {
   errors.add(_ValidationError(_signalsPath, message));
 }
diff --git a/benchmark/check_generated_data.dart b/benchmark/check_generated_data.dart
index 8914e71f..90122c21 100644
--- a/benchmark/check_generated_data.dart
+++ b/benchmark/check_generated_data.dart
@@ -2,6 +2,7 @@ import 'dart:io';
 
 import 'generate_devices.dart' as generate_devices;
 import 'generate_history.dart' as generate_history;
+import 'generate_readme.dart' as generate_readme;
 import 'generate_signals.dart' as generate_signals;
 
 /// Verifies that the generated-docs sources are well-formed enough that the
@@ -35,6 +36,8 @@ Future<void> main() async {
       signalsSourceDir: Directory('experiments/signals'),
       generatedAt: null,
     ),
+    'README.md': () =>
+        generate_readme.buildReadme(experimentsDir: Directory('experiments')),
   };
 
   final failures = <String>[];
diff --git a/benchmark/finalize_experiment.dart b/benchmark/finalize_experiment.dart
index 46892d6a..7b7adcf8 100644
--- a/benchmark/finalize_experiment.dart
+++ b/benchmark/finalize_experiment.dart
@@ -117,14 +117,19 @@ String? _validateExperimentFile(File experimentFile) {
         'experiments/147-short-slug.md: ${p.relative(experimentPath)}';
   }
 
-  final readme = File(p.join(experimentsDir, 'README.md'));
-  if (!readme.existsSync()) {
-    return 'Missing experiments/README.md.';
+  // README.md is generated from the per-experiment index fragments, so a new
+  // experiment is registered by adding its fragment, not by editing README.md
+  // (which the bot regenerates on main). Validate the fragment, not the row.
+  final id = idMatch.group(1)!;
+  final indexFragment = File(p.join(experimentsDir, 'index', '$id.json'));
+  if (!indexFragment.existsSync()) {
+    return 'Experiment $id has no index fragment '
+        'experiments/index/$id.json (its README row: file, title, impact, '
+        'status, link). README.md is generated from these — do not edit it.';
   }
-  final readmeText = readme.readAsStringSync();
-  if (!RegExp(r'\]\(' + RegExp.escape(filename) + r'\)').hasMatch(readmeText)) {
-    return 'Experiment ${idMatch.group(1)} is not linked from '
-        'experiments/README.md.';
+  if (!indexFragment.readAsStringSync().contains('"$filename"')) {
+    return 'experiments/index/$id.json does not reference "$filename" in a '
+        '"file" field.';
   }
 
   final content = experimentFile.readAsStringSync();
diff --git a/benchmark/generate_history.dart b/benchmark/generate_history.dart
index 877cd372..119be5c5 100644
--- a/benchmark/generate_history.dart
+++ b/benchmark/generate_history.dart
@@ -151,9 +151,16 @@ Map<String, Object?> buildHistoryData({
   final experiments = <Map<String, Object?>>[];
 
   if (experimentsDir.existsSync()) {
-    final readmeFile = File('${experimentsDir.path}/README.md');
-    if (readmeFile.existsSync()) {
-      final readme = readmeFile.readAsStringSync();
+    // The per-experiment index fragments (experiments/index/NNN.json) are the
+    // source of truth. README.md is a generated, bot-owned aggregate that a
+    // branch never keeps fresh, so we synthesize the equivalent table markdown
+    // from the fragments and reuse the existing README parser unchanged. Fall
+    // back to a committed README.md when there is no index dir (test fixtures,
+    // legacy trees).
+    final readme =
+        _readmeFromIndex(Directory('${experimentsDir.path}/index')) ??
+        _maybeReadFile('${experimentsDir.path}/README.md');
+    if (readme != null) {
       experiments.addAll(
         _parseExperimentsReadme(readme, experimentsDir, allKeys),
       );
@@ -562,6 +569,57 @@ int? _pickClosestUnclaimedRun(
   return null;
 }
 
+String? _maybeReadFile(String path) {
+  final file = File(path);
+  return file.existsSync() ? file.readAsStringSync() : null;
+}
+
+/// Synthesizes README-equivalent table markdown from the per-experiment index
+/// fragments (`experiments/index/NNN.json`), so [_parseExperimentsReadme] can
+/// consume the fragments without any change to its (golden-fixture-tested)
+/// logic. A fragment is one row object, or a list of rows for a "split"
+/// experiment (e.g. 014 has both an accepted and a rejected finding). Returns
+/// null when there is no index dir or it holds no fragments.
+String? _readmeFromIndex(Directory indexDir) {
+  if (!indexDir.existsSync()) return null;
+  final files = indexDir
+      .listSync()
+      .whereType<File>()
+      .where((f) => f.path.endsWith('.json'))
+      .toList();
+  if (files.isEmpty) return null;
+
+  final rows = <String, List<String>>{
+    'accepted': [],
+    'in_review': [],
+    'rejected': [],
+  };
+  for (final file in files) {
+    final id = file.uri.pathSegments.last.replaceFirst(RegExp(r'\.json$'), '');
+    final decoded = json.decode(file.readAsStringSync());
+    final entries = decoded is List ? decoded : [decoded];
+    for (final entry in entries) {
+      if (entry is! Map) continue;
+      final bucket = rows[entry['status']?.toString()];
+      if (bucket == null) continue;
+      final fileName = entry['file']?.toString() ?? '$id.md';
+      final title = entry['title']?.toString() ?? '';
+      final impact = entry['impact']?.toString() ?? '';
+      final link = entry['link']?.toString() ?? '';
+      bucket.add('| [$id]($fileName) | $title | $impact | $link |');
+    }
+  }
+
+  final buffer = StringBuffer();
+  buffer.writeln('## Accepted');
+  rows['accepted']!.forEach(buffer.writeln);
+  buffer.writeln('## In Review');
+  rows['in_review']!.forEach(buffer.writeln);
+  buffer.writeln('## Rejected');
+  rows['rejected']!.forEach(buffer.writeln);
+  return buffer.toString();
+}
+
 /// Parse experiment entries from the README.md table rows and individual files.
 List<Map<String, Object?>> _parseExperimentsReadme(
   String readme,
@@ -705,18 +763,29 @@ List<Map<String, Object?>> _parseExperimentsReadme(
     }
   }
 
-  // Sort by experiment number.
-  experiments.sort((a, b) {
-    final aNum =
-        int.tryParse((a['id'] as String).replaceAll(RegExp(r'[^0-9]'), '')) ??
-        0;
-    final bNum =
-        int.tryParse((b['id'] as String).replaceAll(RegExp(r'[^0-9]'), '')) ??
-        0;
-    return aNum.compareTo(bNum);
-  });
-
-  return experiments;
+  // Sort by experiment number, kept stable on insertion order so that ids
+  // sharing a number — a suffixed sibling (008 vs 008b) or a split experiment's
+  // two rows (014's accepted + rejected findings) — preserve their source
+  // order. (Dart's List.sort is not stable, so an explicit index tiebreak is
+  // required; without it the tie order depends on sort internals and on whether
+  // the rows came from README.md or the index fragments.)
+  final ordered = experiments.asMap().entries.toList()
+    ..sort((a, b) {
+      final aNum =
+          int.tryParse(
+            (a.value['id'] as String).replaceAll(RegExp(r'[^0-9]'), ''),
+          ) ??
+          0;
+      final bNum =
+          int.tryParse(
+            (b.value['id'] as String).replaceAll(RegExp(r'[^0-9]'), ''),
+          ) ??
+          0;
+      if (aNum != bNum) return aNum.compareTo(bNum);
+      return a.key.compareTo(b.key);
+    });
+
+  return ordered.map((entry) => entry.value).toList();
 }
 
 String? _experimentHeaderValue(String content, String label) {
diff --git a/benchmark/generate_readme.dart b/benchmark/generate_readme.dart
new file mode 100644
index 00000000..eefc76bf
--- /dev/null
+++ b/benchmark/generate_readme.dart
@@ -0,0 +1,110 @@
+// ignore_for_file: avoid_print
+import 'dart:convert';
+import 'dart:io';
+
+/// Assembles `experiments/README.md` from its hand-edited sources:
+///
+///   experiments/README.template.md    — the prose, section headers, and table
+///                                        headers, with `{{ROWS:<status>}}`
+///                                        placeholders where each table body goes
+///   experiments/index/NNN.json         — one file per experiment: its README
+///                                        row data {file, title, impact, status,
+///                                        link}
+///
+/// `README.md` is a *generated* aggregate owned by the post-merge "Update Docs
+/// Data" bot — see experiments/RUNNER_INSTRUCTIONS.md. An experiment adds its
+/// own `index/NNN.json` (its own file, so two concurrent experiments never
+/// touch the same one); rows render newest-first (id descending). Maintainers
+/// edit `README.template.md` for prose. Nobody hand-edits `README.md`.
+String buildReadme({required Directory experimentsDir}) {
+  final templateFile = File('${experimentsDir.path}/README.template.md');
+  if (!templateFile.existsSync()) {
+    throw StateError('Missing ${templateFile.path}');
+  }
+  final indexDir = Directory('${experimentsDir.path}/index');
+  final rows = <String, List<_Row>>{
+    'accepted': [],
+    'in_review': [],
+    'rejected': [],
+  };
+  if (indexDir.existsSync()) {
+    for (final file in indexDir.listSync().whereType<File>()) {
+      if (!file.path.endsWith('.json')) continue;
+      final id = file.uri.pathSegments.last.replaceFirst(RegExp(r'\.json$'), '');
+      final decoded = json.decode(file.readAsStringSync());
+      // A fragment is one row object, or a list of rows for a "split"
+      // experiment (e.g. 014 has an accepted finding and a rejected one).
+      final entries = decoded is List ? decoded : [decoded];
+      for (final entry in entries) {
+        if (entry is! Map<String, Object?>) {
+          throw StateError('${file.path} rows must be JSON objects.');
+        }
+        final status = entry['status'];
+        final bucket = rows[status];
+        if (bucket == null) {
+          throw StateError(
+            '${file.path} has invalid status "$status" '
+            '(expected accepted | in_review | rejected).',
+          );
+        }
+        bucket.add(
+          _Row(
+            id: id,
+            file: entry['file'] as String? ?? '$id.md',
+            title: (entry['title'] as String? ?? '').trim(),
+            impact: (entry['impact'] as String? ?? '').trim(),
+            link: (entry['link'] as String? ?? '').trim(),
+            rejected: status == 'rejected',
+          ),
+        );
+      }
+    }
+  }
+
+  var out = templateFile.readAsStringSync();
+  for (final status in rows.keys) {
+    final sorted = rows[status]!..sort((a, b) => _compareIds(b.id, a.id));
+    final body = sorted.map((r) => r.render()).join('\n');
+    out = out.replaceAll('{{ROWS:$status}}', body);
+  }
+  return out;
+}
+
+class _Row {
+  _Row({
+    required this.id,
+    required this.file,
+    required this.title,
+    required this.impact,
+    required this.link,
+    required this.rejected,
+  });
+
+  final String id;
+  final String file;
+  final String title;
+  final String impact;
+  final String link;
+  final bool rejected;
+
+  String render() => rejected
+      ? '| [$id]($file) | $title | $impact |'
+      : '| [$id]($file) | $title | $impact | $link |';
+}
+
+int _compareIds(String a, String b) {
+  final ma = RegExp(r'^(\d+)(.*)$').firstMatch(a);
+  final mb = RegExp(r'^(\d+)(.*)$').firstMatch(b);
+  final na = ma == null ? (1 << 30) : int.parse(ma.group(1)!);
+  final nb = mb == null ? (1 << 30) : int.parse(mb.group(1)!);
+  if (na != nb) return na.compareTo(nb);
+  final sa = ma == null ? a : ma.group(2)!;
+  final sb = mb == null ? b : mb.group(2)!;
+  return sa.compareTo(sb);
+}
+
+Future<void> main() async {
+  final readme = buildReadme(experimentsDir: Directory('experiments'));
+  File('experiments/README.md').writeAsStringSync(readme);
+  print('Wrote experiments/README.md');
+}
diff --git a/experiments/README.md b/experiments/README.md
index 327b646a..76e2c222 100644
--- a/experiments/README.md
+++ b/experiments/README.md
@@ -11,45 +11,45 @@ Experiments that proved their value and were merged into the codebase.
 | [186](186-single-row-large-text-bind-encoder.md) | Single-row large-text bind encoder | Revives exp 179's direct-ASCII `allocateParams` rewrite against a representative large-payload workload — the explicit revisit condition exp 179 named. Focused `single_row_large_text_bind.dart` measures **−15% to −32%** at 16 KB → 1 MB single-row INSERT text binds, reproduced across order-flipped passes; encoder isolation reproduces exp 179's −45% / −58% / −37% on the synthetic micro. Small-payload release-suite lanes (Parameterized Queries, Single Inserts, Concurrent Single Inserts) stay neutral, confirming exp 179's small-bind finding stands; the lone flagged batch-tx regression is sub-decision-threshold noise on a routing path the encoder does not touch (`allocateBatchParams`). Saves one `Uint8List` allocation + one byte-buffer copy per ASCII string param; non-ASCII strings still take the unchanged `_allocateParamsPreEncoded` fallback. |  |
 | [184](184-writer-residual-resplit.md) | Writer residual re-split (post-159/180) | Measurement: re-ran exp 147's `writer_sqlite_wall_audit` after pipelining + group commit landed. Breakdown essentially unchanged (A11c overlap SQLite 13.6% / invalidation 16.0% / residual 70.3%) — the audit is sequential and exp 180 coalesces only concurrent bursts. Retires writer-residual micro-opts: the residual is the SDK-gated per-write round-trip, invalidation precision is owned by in-flight exp 160 (#155), the dirty harvest (~4–6%, exp 182) is small, SQLite config is mined. No runtime code. |  |
 | [180](180-group-commit-request-batching.md) | Cross-call write request batching (group commit) | The "group commit" lever exp 159 named: standalone `execute()` calls that pile up while a send is in flight coalesce into one `MultiExecuteRequest` (each statement its own autocommit — per-call semantics unchanged), collapsing a concurrent burst's N round-trips toward ~2 and capturing exp 147's ~72% per-round-trip residual that pipelining left behind. **−26% to −32%** on the release Concurrent Single Inserts lane, reproduced across order-flipped runs; sequential lane neutral (backpressure trigger adds no latency to isolated writes); the lone flagged nested-tx regression proven to be drift (sign-flip on an untouched code path). |  |
-| [001](001-c-native-json-serialization.md) | C-native JSON serialization | 3.5x faster bytes path | [`4acfb57`](https://github.com/danReynolds/dune/commit/4acfb57) |
-| [003](003-c-level-connection-and-statement-cache.md) | C-level connection + statement cache | ~0.7ms saved per query | [`4acfb57`](https://github.com/danReynolds/dune/commit/4acfb57) |
-| [004](004-nomutex-per-query-locking.md) | NOMUTEX with per-query locking | Eliminated 60k mutex ops at 20k rows | [`4acfb57`](https://github.com/danReynolds/dune/commit/4acfb57) |
-| [007](007-c-level-connection-pool.md) | C-level connection pool | 4.4x faster concurrent reads | [`3a08838`](https://github.com/danReynolds/dune/commit/3a08838) |
-| [008](008-flat-list-lazy-resultset.md) | Flat value list + lazy ResultSet | The breakthrough — 10x fewer objects, beat sqlite3 | [`a18492c`](https://github.com/danReynolds/dune/commit/a18492c), [`666da73`](https://github.com/danReynolds/dune/commit/666da73) |
-| [009](009-batch-ffi-step-row.md) | Batch FFI (resqlite_step_row) | 9-21% improvement across all benchmarks | [`4c18bb4`](https://github.com/danReynolds/dune/commit/4c18bb4) |
-| [013](013-ffi-isleaf.md) | FFI isLeaf annotation | 12-19% on small results, 5-9% across the board | [`af2cfd0`](https://github.com/danReynolds/dune/commit/af2cfd0) |
-| [014](014-writer-tuning.md) | BEGIN IMMEDIATE + remove clear_bindings | Correct but within noise (write I/O dominated) | [`4c368a6`](https://github.com/danReynolds/dune/commit/4c368a6) |
-| [015](015-cell-buffer-union.md) | Cell buffer union (48 → 16 bytes) | Simplicity win, performance neutral | [`52f1e4b`](https://github.com/danReynolds/dune/commit/52f1e4b) |
-| [016](016-sqlite-compile-flags.md) | SQLite compile flags + prepare_v3 | Correctness wins, performance within noise | [`b9c6b6d`](https://github.com/danReynolds/dune/commit/b9c6b6d) |
-| [019](019-hybrid-reader-pool.md) | Hybrid reader pool (SendPort + sacrifice) | 64-83% faster small reads, 45k qps point queries | [`e07d95b`](https://github.com/danReynolds/dune/commit/e07d95b) |
-| [028](028-static-bind-params.md) | Static bind for text/blob params | Improves targeted small-read and parameterized-query workloads | [`8822bd2`](https://github.com/danReynolds/dune/commit/8822bd2) |
+| [115](115-dispatcher-park-counters.md) | Dispatcher park counters for `ReaderPool` | Measurement-only: profile-mode counters (park-total, wake-retry-total, max-parked-concurrent) that quantify the parked-dispatcher path exp 105 / exp 114 targeted indirectly. Wake-retry/park ratio reaches 93 % at concurrency=32 (pool=4), the direct wake-amplification signal. Tree-shaken from release builds. Unblocks future dispatch-area experiments with a non-wall-time evaluation gate |  |
+| [109](109-inline-param-buffer.md) | Inline-packed parameter buffer | **−10 % to −16 %** on text-param INSERT workloads (Single Inserts, Batch Insert, No-Streams Write Throughput) by collapsing per-text/blob `calloc` into the reusable param-struct buffer and passing actual UTF-8 byte length so `sqlite3_bind_text` skips its internal `strlen` |  |
+| [106](106-column-level-deps.md) | Column-level dependency tracking (re-attempt of 052 under A11c) | **+82 %** on A11c disjoint writer throughput (3,956 → 7,201 w/s); overlap unchanged (4,477 → 4,581 w/s); overlap/disjoint ratio drops 1.132 → 0.636, the direct signature of writer-side dispatch elision |  |
+| [101](101-tx-stmt-cache.md) | Cached BEGIN/COMMIT/ROLLBACK statements | **−13 % to −14 %** on Batched-Write-Inside-Transaction and Growing-Stream Invalidation by replacing `sqlite3_exec`'s per-call prepare+finalize with three persistently prepared transaction-control stmts |  |
+| [077](077-cheap-check-first-sweep.md) | Cheap-check-first sweep (four small wins) | **−13 % to −23 % on write benchmarks** from cached `sqlite3_bind_parameter_count`; pairs with three correctness-neutral fast-rejects on invalidation, hash, and subscription paths |  |
+| [075](075-native-hash-selectifchanged.md) | Native-buffered hash for `selectIfChanged` | **−39 % on unchanged-fanout benchmark**. Worker-side C hash (`resqlite_query_hash`) short-circuits stream re-queries before any Dart decode when the result is unchanged |  |
+| [070](070-zero-row-change-shortcircuit.md) | Zero-row-change short-circuit + persistent dirty buffer | Removes per-write calloc/free pair and short-circuits empty dirty set to a const empty list |  |
+| [064](064-drop-clear-bindings.md) | Drop redundant `sqlite3_clear_bindings` | Provably-redundant call removed; simpler bind path with documented invariants |  |
+| [045](045-microtask-invalidation-coalescing.md) | Microtask invalidation coalescing | Batches rapid sequential writes into a single invalidation pass per microtask |  |
+| [044](044-batch-atomic-write.md) | `SQLITE_ENABLE_BATCH_ATOMIC_WRITE` | Zero-risk compile flag enabling 2-3x write speedup on Android F2FS |  |
+| [043](043-swar-escape-lookup-table.md) | SWAR escape scanning + lookup table | 8-byte-at-a-time escape detection + lookup table eliminates branch chains in JSON strings |  |
+| [040](040-reader-slot-event-port-cleanup.md) | Reader slot event-port cleanup | Simpler reader-worker protocol with a measured point-query and large-read win |  |
+| [039](039-byte-size-sacrifice-threshold.md) | Byte-size sacrifice threshold | Better proxy for SendPort copy cost than cell count |  |
+| [038](038-stack-alloc-col-names.md) | Stack allocation for column name arrays | Eliminates unnecessary heap allocations |  |
+| [037](037-persistent-json-buffer.md) | Persistent JSON buffer per reader | Eliminates syscall-class operations on the hot path |  |
+| [036](036-compiler-hints.md) | Compiler hints (Dart + C) | Zero-risk annotations, no behavioral changes |  |
+| [035](035-cell-buffer-reuse.md) | Reuse cell buffer across queries | Eliminates per-query buffer allocations |  |
+| [034](034-schema-cache.md) | Per-worker schema cache | Eliminates FFI calls + string allocations for repeated queries |  |
+| [033](033-fnv1a-hash.md) | FNV-1a hash for result change detection | Shared module for consistent stream result hashing |  |
+| [032](032-row-map-facade.md) | Row `Map` facade overrides | Keeps the fast transport shape intact while materially improving main-isolate `Map` operations |  |
+| [030](030-dedicated-reader-assignment.md) | Dedicated reader assignment | Removes per-query C pool mutex overhead and closes the point-query gap |  |
 | [029](029-periodic-passive-checkpointing.md) | Periodic PASSIVE checkpointing | Much lower burst write p95/p99/max via writer-side scheduling | [`8822bd2`](https://github.com/danReynolds/dune/commit/8822bd2) |
-| [020](020-lookaside-allocator.md) | SQLITE_DEFAULT_LOOKASIDE tuning | Zero-cost compile flag improvement |  |
-| [021](021-pcache-initsz.md) | SQLITE_DEFAULT_PCACHE_INITSZ=128 | Slight positive trend on larger result sets |  |
-| [022](022-wal-autocheckpoint.md) | WAL autocheckpoint tuning | Correctness and reliability improvement |  |
-| [023](023-fast-itoa.md) | Fast int64-to-string for JSON | Measurable win on the selectBytes hot path |  |
+| [028](028-static-bind-params.md) | Static bind for text/blob params | Improves targeted small-read and parameterized-query workloads | [`8822bd2`](https://github.com/danReynolds/dune/commit/8822bd2) |
 | [024](024-json-buffer-16k.md) | JSON buffer initial size 16KB | Sensible default, no measurable impact |  |
-| [030](030-dedicated-reader-assignment.md) | Dedicated reader assignment | Removes per-query C pool mutex overhead and closes the point-query gap |  |
-| [032](032-row-map-facade.md) | Row `Map` facade overrides | Keeps the fast transport shape intact while materially improving main-isolate `Map` operations |  |
-| [033](033-fnv1a-hash.md) | FNV-1a hash for result change detection | Shared module for consistent stream result hashing |  |
-| [034](034-schema-cache.md) | Per-worker schema cache | Eliminates FFI calls + string allocations for repeated queries |  |
-| [035](035-cell-buffer-reuse.md) | Reuse cell buffer across queries | Eliminates per-query buffer allocations |  |
-| [036](036-compiler-hints.md) | Compiler hints (Dart + C) | Zero-risk annotations, no behavioral changes |  |
-| [037](037-persistent-json-buffer.md) | Persistent JSON buffer per reader | Eliminates syscall-class operations on the hot path |  |
-| [038](038-stack-alloc-col-names.md) | Stack allocation for column name arrays | Eliminates unnecessary heap allocations |  |
-| [039](039-byte-size-sacrifice-threshold.md) | Byte-size sacrifice threshold | Better proxy for SendPort copy cost than cell count |  |
-| [040](040-reader-slot-event-port-cleanup.md) | Reader slot event-port cleanup | Simpler reader-worker protocol with a measured point-query and large-read win |  |
-| [043](043-swar-escape-lookup-table.md) | SWAR escape scanning + lookup table | 8-byte-at-a-time escape detection + lookup table eliminates branch chains in JSON strings |  |
-| [044](044-batch-atomic-write.md) | `SQLITE_ENABLE_BATCH_ATOMIC_WRITE` | Zero-risk compile flag enabling 2-3x write speedup on Android F2FS |  |
-| [045](045-microtask-invalidation-coalescing.md) | Microtask invalidation coalescing | Batches rapid sequential writes into a single invalidation pass per microtask |  |
-| [064](064-drop-clear-bindings.md) | Drop redundant `sqlite3_clear_bindings` | Provably-redundant call removed; simpler bind path with documented invariants |  |
-| [070](070-zero-row-change-shortcircuit.md) | Zero-row-change short-circuit + persistent dirty buffer | Removes per-write calloc/free pair and short-circuits empty dirty set to a const empty list |  |
-| [075](075-native-hash-selectifchanged.md) | Native-buffered hash for `selectIfChanged` | **−39 % on unchanged-fanout benchmark**. Worker-side C hash (`resqlite_query_hash`) short-circuits stream re-queries before any Dart decode when the result is unchanged |  |
-| [077](077-cheap-check-first-sweep.md) | Cheap-check-first sweep (four small wins) | **−13 % to −23 % on write benchmarks** from cached `sqlite3_bind_parameter_count`; pairs with three correctness-neutral fast-rejects on invalidation, hash, and subscription paths |  |
-| [101](101-tx-stmt-cache.md) | Cached BEGIN/COMMIT/ROLLBACK statements | **−13 % to −14 %** on Batched-Write-Inside-Transaction and Growing-Stream Invalidation by replacing `sqlite3_exec`'s per-call prepare+finalize with three persistently prepared transaction-control stmts |  |
-| [106](106-column-level-deps.md) | Column-level dependency tracking (re-attempt of 052 under A11c) | **+82 %** on A11c disjoint writer throughput (3,956 → 7,201 w/s); overlap unchanged (4,477 → 4,581 w/s); overlap/disjoint ratio drops 1.132 → 0.636, the direct signature of writer-side dispatch elision |  |
-| [109](109-inline-param-buffer.md) | Inline-packed parameter buffer | **−10 % to −16 %** on text-param INSERT workloads (Single Inserts, Batch Insert, No-Streams Write Throughput) by collapsing per-text/blob `calloc` into the reusable param-struct buffer and passing actual UTF-8 byte length so `sqlite3_bind_text` skips its internal `strlen` |  |
-| [115](115-dispatcher-park-counters.md) | Dispatcher park counters for `ReaderPool` | Measurement-only: profile-mode counters (park-total, wake-retry-total, max-parked-concurrent) that quantify the parked-dispatcher path exp 105 / exp 114 targeted indirectly. Wake-retry/park ratio reaches 93 % at concurrency=32 (pool=4), the direct wake-amplification signal. Tree-shaken from release builds. Unblocks future dispatch-area experiments with a non-wall-time evaluation gate |  |
+| [023](023-fast-itoa.md) | Fast int64-to-string for JSON | Measurable win on the selectBytes hot path |  |
+| [022](022-wal-autocheckpoint.md) | WAL autocheckpoint tuning | Correctness and reliability improvement |  |
+| [021](021-pcache-initsz.md) | SQLITE_DEFAULT_PCACHE_INITSZ=128 | Slight positive trend on larger result sets |  |
+| [020](020-lookaside-allocator.md) | SQLITE_DEFAULT_LOOKASIDE tuning | Zero-cost compile flag improvement |  |
+| [019](019-hybrid-reader-pool.md) | Hybrid reader pool (SendPort + sacrifice) | 64-83% faster small reads, 45k qps point queries | [`e07d95b`](https://github.com/danReynolds/dune/commit/e07d95b) |
+| [016](016-sqlite-compile-flags.md) | SQLite compile flags + prepare_v3 | Correctness wins, performance within noise | [`b9c6b6d`](https://github.com/danReynolds/dune/commit/b9c6b6d) |
+| [015](015-cell-buffer-union.md) | Cell buffer union (48 → 16 bytes) | Simplicity win, performance neutral | [`52f1e4b`](https://github.com/danReynolds/dune/commit/52f1e4b) |
+| [014](014-writer-tuning.md) | BEGIN IMMEDIATE + remove clear_bindings | Correct but within noise (write I/O dominated) | [`4c368a6`](https://github.com/danReynolds/dune/commit/4c368a6) |
+| [013](013-ffi-isleaf.md) | FFI isLeaf annotation | 12-19% on small results, 5-9% across the board | [`af2cfd0`](https://github.com/danReynolds/dune/commit/af2cfd0) |
+| [009](009-batch-ffi-step-row.md) | Batch FFI (resqlite_step_row) | 9-21% improvement across all benchmarks | [`4c18bb4`](https://github.com/danReynolds/dune/commit/4c18bb4) |
+| [008](008-flat-list-lazy-resultset.md) | Flat value list + lazy ResultSet | The breakthrough — 10x fewer objects, beat sqlite3 | [`a18492c`](https://github.com/danReynolds/dune/commit/a18492c), [`666da73`](https://github.com/danReynolds/dune/commit/666da73) |
+| [007](007-c-level-connection-pool.md) | C-level connection pool | 4.4x faster concurrent reads | [`3a08838`](https://github.com/danReynolds/dune/commit/3a08838) |
+| [004](004-nomutex-per-query-locking.md) | NOMUTEX with per-query locking | Eliminated 60k mutex ops at 20k rows | [`4acfb57`](https://github.com/danReynolds/dune/commit/4acfb57) |
+| [003](003-c-level-connection-and-statement-cache.md) | C-level connection + statement cache | ~0.7ms saved per query | [`4acfb57`](https://github.com/danReynolds/dune/commit/4acfb57) |
+| [001](001-c-native-json-serialization.md) | C-native JSON serialization | 3.5x faster bytes path | [`4acfb57`](https://github.com/danReynolds/dune/commit/4acfb57) |
 
 ## In Review
 
@@ -64,6 +64,7 @@ moved them.
 
 | # | Experiment | Impact | PR |
 |---|---|---|---|
+| [195](195-stmt-cache-name-tokens.md) | Stmt-cache pre-encoded JSON column-name tokens | Extends [exp 190](190-selectbytes-col-name-preencode.md)'s per-query token amortization across re-executions of the same prepared SQL by caching the encoded `"name":` / `,"name":` tokens on the `resqlite_cached_stmt` entry. Eliminates the per-query `buf_init(64)` + `free` pair and the first-row pre-encode walk from `write_json_to_buf`; the per-row loop is bit-identical to exp 190 and JSON output is byte-identical. Focused `select_bytes_repeated_calls.dart` 1-row × 20-col improves **−9.2 % / −7.2 %** and 10-row × 20-col improves **−5.1 % / −2.7 %** across two order-flipped passes, while 100/1000-row guards show sign reversal (drift-suspected — per-query setup is < 0.2 % of wall at those sizes). Exp 190's `wide_cols.dart` shapes trend candidate-faster on every 10k-row lane across both passes. No public API change, ~hundreds of bytes per cached statement |  |
 | [194](194-real-integer-fastpath.md) | Integer-valued REAL selectBytes fast path | Adds a conservative `SQLITE_FLOAT` JSON helper that routes finite, exactly integral REAL values inside the exact double integer range (`abs(v) <= 2^53`) through the existing `fast_i64_to_str` path while preserving `snprintf("%.17g")` for fractional values, huge values, non-finite values, and negative zero. Focused `select_bytes_real_int_fastpath.dart` A/B (order-flipped pair): **10k x 8 integral REAL -79%, 10k x 20 integral REAL -81%, 1k x 2 integral REAL -72%**, with the fractional-REAL fallback guard flat at +0.5% and the mixed lane moving in proportion to its integral-REAL columns. No public API change; new selectBytes test covers integral REAL, fractional REAL, and huge fallback values. |  |
 | [192](192-two-digit-itoa.md) | Two-digit table itoa for selectBytes integer columns | Replaces the single-digit `fast_i64_to_str` body ([exp 023](023-fast-itoa.md)) with a two-digit `[00..99]` lookup table — one `% 100` / `/ 100` and one 2-byte `memcpy` per pair of output digits, halving the division count vs the old loop. Focused `select_bytes_int_heavy.dart` A/B (order-flipped pair): **10k × 8 small ints −11 %, 10k × 20 small ints −8 to −10 %, 10k × 20 big ints (~18 digits) −24 to −26 %**, with mixed-cell and small-payload regression guards inside ±1 %. Adds a 200-byte `kTwoDigits` `const` table; `LLONG_MIN` handling and the `val == 0` short circuit preserved bit-for-bit; new end-to-end int-extremes test covers 0, ±9, ±99, ±10000, ±1234567890, LLONG_MIN, LLONG_MAX through `selectBytes()` |  |
 | [191](191-embedded-nul-public-api-audit.md) | Embedded-NUL public API audit | Correctness guard for the remaining public text surfaces in `parameter-encoding-and-binding`: `selectBytes()` now has an assertion that SQLite `char(0)` TEXT decodes through native JSON bytes without truncation, and `stream()` now verifies both initial and changed emissions preserve embedded-NUL UTF-8 bytes. No runtime code or benchmark run; this consumes the signal-map's broader embedded-NUL audit candidate while leaving performance candidates unchanged. |  |
@@ -73,34 +74,33 @@ moved them.
 | [185](185-json-buf-release-coverage.md) | JSON buffer reclaim release coverage | Measurement-support guard for exp 183: `SQLite Diagnostics` now emits `JSON buf (KiB)` and a `JSON buffer reclaim (8 large selectBytes + 64 small settles)` row. The row grows reader `json_buf` capacity with a concurrent large `selectBytes` burst, settles with small reads, and fails if post-settle retention stays above 512 KiB; the focused suite run settled at **64.0 KiB** with idle readers. Parser/sidecar/history data carry optional `jsonBufKiB` while legacy diagnostics tables remain parseable. No runtime code. |  |
 | [183](183-json-buf-retention-audit.md) | json_buf retention audit + high-threshold reclaim | Diagnostic + reclaim. Adds `Diagnostics.readerJsonBufHighWaterBytes` (sum of per-reader `json_buf.cap`) so the bounded RSS high-water exp 174 left as a known trade-off is now directly observable. Pathological retention is real on a one-off concurrent-burst workload (8 × 8 MB `selectBytes` pins **32 MB** across the 4-reader pool for the rest of the connection's life) and on a recurring-large pattern (16 MB pinned). A high-threshold C-side `realloc` shrink — fired by the reader worker after `SendPort.send` on a `selectBytes` reply when `json_buf.cap > 1 MB` AND the just-sent result was < 256 KB — reclaims back to the 16 KB initial cap on subsequent small reads: **post-burst settle 32 MB → 64 KB** (×4 readers, summed); recurring-large **16 MB → 64 KB**. Neutral on the focused `large_bytes_transfer.dart` lanes (±2 % within run-to-run noise). The 256 KB last-len guard is what makes the policy safe under back-to-back large reads — they keep their warm capacity |  |
 | [178](178-missing-run-declaration-guard.md) | Missing-benchmark-run declaration guard | Measurement-only CI guardrail: `generate_history.dart` now fails the build when a chartable (accepted/in-review) experiment numbered `≥ 178` has no linked benchmark run *and* no `**Benchmark Run:**` opt-out declaration — converting the documented silent chart-invisibility failure (forgotten result file / date mismatch) into a loud error for new work. Reuses the existing `_skipsReleaseBenchmarkRunMapping` opt-out signal as the escape hatch; pre-178 experiments are grandfathered. No runtime code; `history.json` byte-for-byte unchanged |  |
+| [177](177-ab-drift-discriminator.md) | Order-flipped A/B drift discriminator | Methodology tooling: mechanizes the JOURNAL's most-reapplied lesson (phase-ordered A/B gates confound code deltas with time-correlated drift). Adds `cvPct` + `classifyDriftFlag` to `benchmark/shared/stats.dart` and a `benchmark/ab_drift_check.dart` CLI that reads two order-flipped passes of per-run values and classifies a regression flag as `reproduced` (same-direction effect, comparable CVs), `drift-suspected` (CV asymmetry on the flagged phase, or sign reversal across the flip), or `inconclusive`. Re-run against the recorded flags from exp 159 (CV asymmetry) and exp 167 (sign reversal), it reproduces the verdicts those runners reached by hand. No runtime change; 14/14 unit tests pass |  |
+| [176](176-row-containskey-identity-fastpath.md) | Row.containsKey identity fast path | Routes `Row.containsKey` through the exp 158 schema-name identity scan (via a shared `RowSchema.containsName`) instead of always hashing the key in the private `HashMap`. For interned-key probes on schemas ≤ 32 columns the membership test becomes a pointer-identity scan; equal-but-non-identical keys and wider schemas still fall back to the map. Focused `row_map_facade` `containsKey` lane improves **~13.0 → ~10.0 ms (−23%)** with a flat `hot lookup` control, flipping Row from ~+3.6 ms slower than `LinkedHashMap` to at-parity. Behavior-identical, no public API change |  |
+| [175](175-large-selectbytes-coverage.md) | Large selectBytes release coverage | Adds a named `Large payload (~650KB)` `resqlite selectBytes()` row to the release JSON-bytes suite and curates it as `selectBytes() large bytes`, giving exp 174's native-view transfer path a release-history guard above the old 256 KB sacrifice threshold. Single-repeat release run measured 0.323 ms wall / 0.000 ms main for the new row. |  |
+| [174](174-selectbytes-view-transfer.md) | selectBytes native-view transfer | `selectBytes` sends a `Uint8List` view over the reader connection's persistent `json_buf` and never takes the sacrifice (Isolate.exit + reader respawn) path. Sacrifice is a real win for the rows path (zero-copy object transfer) but counterproductive for bytes — native JSON must be `fromList`-copied before `Isolate.exit` can transfer it, so it saved zero copies and only added a respawn, while the non-sacrifice path copied twice. **−44% (~1.8×)** on large (>256KB) byte reads by eliminating the per-query respawn, **−4%** on small, at a bounded ~+15MB RSS high-water. Net code removal, no public API change |  |
+| [172](172-long-payload-stream-hash.md) | Long-payload stream hash coverage | Adds a default streaming-suite row for mixed 32KB TEXT + 32KB BLOB unchanged fanout plus long-BLOB hash correctness coverage. The mixed row lands at 3.446 ms median beside the existing 4KB TEXT row at 2.356 ms, closing the long-payload measurement blocker without justifying an immediate new hash-loop variant |  |
+| [169](169-tracelite-workload-insights.md) | Tracelite workload-summary insight guard | Adds a Resqlite-side validation step to `benchmark/profile/run_tracelite_profile.dart` so canonical profile runs fail if `tracelite explain` regresses to coverage-only output. The validated profile emitted dispatch floors, dispatch-bound point queries, work-bound merge rounds, tail spread, RSS, allocation, and WAL insight IDs; thin `workload_loaded` fixtures now fail locally |  |
+| [161](161-concurrent-writes-release-coverage.md) | Concurrent standalone writes release coverage | Promotes the exp 159 send-gated writer-lock pipelining shape into release write suite coverage with a paired Single Inserts (100 sequential) / Concurrent Single Inserts (100 concurrent) row pair; resqlite concurrent median drops from ~2.9 ms to ~1.1 ms on the new lane (−58% to −61%) while sequential, batch, wide batch, and transaction rows stay untouched. Makes future writer-scheduling experiments evaluable on a public release lane without relying on the focused `writer_pipelining.dart` script |  |
 | [159](159-writer-pipelining.md) | Writer request pipelining + persistent reply port | **−36% to −45%** on concurrent standalone writes (new focused burst benchmark) by holding the write lock only across the send and letting the worker's port FIFO pipeline requests; persistent reply port + cached SendPort + sync completers remove a port allocate/register/close cycle and two scheduling hops from every write round-trip. Stream-dispatch Tracelite guardrails neutral on the clean order-flipped pass; exp 147 `residual_us` drops on all four audit workloads |  |
-| [083](083-stream-rerun-pre-dispatch-queue.md) | Stream rerun pre-dispatch queue | Eliminates the measured `A11` / `A11b` reader-pool wait bottleneck by coalescing reruns before pool admission | [#25](https://github.com/danReynolds/resqlite/pull/25) |
-| [097](097-one-pass-initial-stream-hash.md) | One-pass initial stream decode and hash | 14-16% faster setup-heavy streaming benchmarks by avoiding the initial stream query replay |  |
-| [110](110-long-text-fnv-8byte.md) | Long-text stream hash benchmark + 8-byte FNV | Adds a long-text unchanged-fanout benchmark and cuts its median latency by 76% with chunked byte-stream hashing | [#53](https://github.com/danReynolds/resqlite/pull/53) |
-| [113](113-direct-batch-param-matrix.md) | Direct batch parameter matrix encoding | Avoids the temporary flat Dart parameter list; 10k-row wide batches improve 14-26% in the focused benchmark | [#70](https://github.com/danReynolds/resqlite/pull/70) |
-| [116](116-wide-batch-release-coverage.md) | Wide batch insert release coverage | Adds a 10k-row x 20-parameter mixed-type batch insert to the release write suite so parameter-width regressions are visible on the public benchmark path |  |
-| [118](118-fifo-dispatch-counter-gate.md) | FIFO dispatch waiters with counter gate | Replaces the shared reader-pool dispatch completer with FIFO one-shot waiters; exp 115 counters show wake retries drop to zero under overload |  |
-| [119](119-dispatch-pressure-audit.md) | Post-FIFO dispatch pressure audit | Profile audit shows wake retries stay zero after FIFO, while A11c overlap and keyed-PK streams still produce parked dispatchers; next dispatch work should target stream admission/completion |  |
-| [120](120-flush-admit-bound.md) | Bounded `_flushQueue` admission | Cap stream re-query admission at `ReaderPool.availableWorkerCount` per call so synchronous over-dispatch can no longer pile up against `_dispatchWaiters`. `dispatcherParkedTotal` drops from 3,590 → 0 (A11c overlap) and 1,198 → 0 (keyed-PK); `max_parked` 46 → 0. Release suite: 9 wins, 0 regressions, including neutral high-cardinality fan-out (the exp-100 killer) |  |
-| [121](121-invalidation-traversal-audit.md) | Invalidation traversal cost audit | Measurement-only: profile-mode harness reports `invalidate_us` / `intersection_us` as a fraction of writer-side burst wall on A11c (baseline / disjoint / overlap) and keyed-PK. Overlap invalidation is 10–15% of wall (column intersection 2.5–5.7%); keyed-PK 13–14% (intersection ~4%); disjoint 22–23% only because column elision shrinks the denominator. Per-entry intersection probes are 80–200 ns. Extracts shared `audit_workloads.dart` so this audit and exp 119 stay structurally comparable. Removes invalidation traversal from the active candidate list — the structural ceiling on smarter dependency tracking is ~3 ms / 25k probes per overlap burst |  |
-| [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 |  |
-| [136](136-completion-microtask-counter.md) | Completion-side reader-handler counter | Measurement-only: profile-mode counters (`completion_handler_us`, `stream_emit_us`) expose the main-isolate reader worker port handler chain on A11c overlap as 28.57% of total wall (burst + drain) at ~18 µs per call across 4,228 calls/burst, with subscriber emit only 0.35% of the chain. Reader-reply batching is the natural bounded implementation candidate. Closes the `completion-side microtask scheduling cost counter` entry in `signals.json#stream-rerun-dispatch.blockedOnMeasurement` |  |
-| [143](143-tracelite-profile-insights.md) | Tracelite profile insight audit | Measurement-only: pinned Tracelite profile runs show stable dispatch floors (reader 12 us, writer 16 us), point queries at the dispatch floor, merge rounds with 77 us of floor-subtracted work, and memory/allocation signal that wall time alone hides; current `tracelite explain` only reports coverage, so richer workload-summary insight rules are the next measurement-system improvement |  |
-| [144](144-sqlite3mc-bump-2-3-5.md) | sqlite3mc 2.3.2 → 2.3.5 bump (SQLite 3.51.3 → 3.53.2) | Satisfies exp 090's revisit trigger (SQLite `.2`+ point release with sqlite3mc tracking it); tests stay green including embedded-NUL + Unicode bind regression suite; release-suite single-pass A/Bs swing between 19/18/124 and 30/2/129 — Concurrent Reads 8× is the only metric that flags consistently across reruns (+~20% on a sub-ms metric) and is the focus of the soak window; FP-rounding hazard skipped because resqlite never serialises REAL via `sqlite3_column_text` |  |
-| [147](147-writer-sqlite-wall-split.md) | Writer SQLite wall split | Measurement-only: profile-mode writer responses now report SQLite-facing write time back into `ProfileCounters`; on A11c overlap, SQLite is 15.7 ms / 166.8 ms (9.4%), invalidation is 18.8%, and residual writer/request wall is 71.8%. Keyed-PK shows the same shape (18.1% SQLite, 18.7% invalidation, 63.3% residual). Clears the writer-wall-vs-SQLite-wall blocker; next stream work should reduce completion/reply scheduling or residual writer/request wall rather than SQLite-step tuning |  |
-| [149](149-six-param-batch-packing.md) | Six-parameter batch packing | Lowers the guarded ASCII batch-packing threshold to the Tracelite merge-round shape; profile `merge_rounds` improves executeBatch p50 88 → 75 us and writer SQLite time 87,895 → 75,947 us while keeping 2-3 parameter batches generic |  |
-| [150](150-nullable-batch-packing.md) | Nullable batch parameter packing | Makes the guarded packed batch encoder nullable-aware for first-row `NULL` text columns; focused nullable ASCII 10k x8 improves 13.552 → 11.152 ms and 10k x20 improves 25.738 → 21.723 ms while existing ASCII/Unicode wide guardrails stay neutral |  |
 | [158](158-row-schema-hash-index.md) | Row schema hash index | Adds a schema-name identity fast path for schemas up to 32 columns plus private `HashMap` fallback for `RowSchema` lookup; focused `select_maps` main-isolate consumption improved 0.169 → 0.081 ms at 1K rows and 1.998 → 0.967 ms at 10K rows while point-query throughput stayed neutral/noisy |  |
-| [161](161-concurrent-writes-release-coverage.md) | Concurrent standalone writes release coverage | Promotes the exp 159 send-gated writer-lock pipelining shape into release write suite coverage with a paired Single Inserts (100 sequential) / Concurrent Single Inserts (100 concurrent) row pair; resqlite concurrent median drops from ~2.9 ms to ~1.1 ms on the new lane (−58% to −61%) while sequential, batch, wide batch, and transaction rows stay untouched. Makes future writer-scheduling experiments evaluable on a public release lane without relying on the focused `writer_pipelining.dart` script |  |
-| [169](169-tracelite-workload-insights.md) | Tracelite workload-summary insight guard | Adds a Resqlite-side validation step to `benchmark/profile/run_tracelite_profile.dart` so canonical profile runs fail if `tracelite explain` regresses to coverage-only output. The validated profile emitted dispatch floors, dispatch-bound point queries, work-bound merge rounds, tail spread, RSS, allocation, and WAL insight IDs; thin `workload_loaded` fixtures now fail locally |  |
-| [172](172-long-payload-stream-hash.md) | Long-payload stream hash coverage | Adds a default streaming-suite row for mixed 32KB TEXT + 32KB BLOB unchanged fanout plus long-BLOB hash correctness coverage. The mixed row lands at 3.446 ms median beside the existing 4KB TEXT row at 2.356 ms, closing the long-payload measurement blocker without justifying an immediate new hash-loop variant |  |
-| [174](174-selectbytes-view-transfer.md) | selectBytes native-view transfer | `selectBytes` sends a `Uint8List` view over the reader connection's persistent `json_buf` and never takes the sacrifice (Isolate.exit + reader respawn) path. Sacrifice is a real win for the rows path (zero-copy object transfer) but counterproductive for bytes — native JSON must be `fromList`-copied before `Isolate.exit` can transfer it, so it saved zero copies and only added a respawn, while the non-sacrifice path copied twice. **−44% (~1.8×)** on large (>256KB) byte reads by eliminating the per-query respawn, **−4%** on small, at a bounded ~+15MB RSS high-water. Net code removal, no public API change |  |
-| [175](175-large-selectbytes-coverage.md) | Large selectBytes release coverage | Adds a named `Large payload (~650KB)` `resqlite selectBytes()` row to the release JSON-bytes suite and curates it as `selectBytes() large bytes`, giving exp 174's native-view transfer path a release-history guard above the old 256 KB sacrifice threshold. Single-repeat release run measured 0.323 ms wall / 0.000 ms main for the new row. |  |
-| [176](176-row-containskey-identity-fastpath.md) | Row.containsKey identity fast path | Routes `Row.containsKey` through the exp 158 schema-name identity scan (via a shared `RowSchema.containsName`) instead of always hashing the key in the private `HashMap`. For interned-key probes on schemas ≤ 32 columns the membership test becomes a pointer-identity scan; equal-but-non-identical keys and wider schemas still fall back to the map. Focused `row_map_facade` `containsKey` lane improves **~13.0 → ~10.0 ms (−23%)** with a flat `hot lookup` control, flipping Row from ~+3.6 ms slower than `LinkedHashMap` to at-parity. Behavior-identical, no public API change |  |
-| [177](177-ab-drift-discriminator.md) | Order-flipped A/B drift discriminator | Methodology tooling: mechanizes the JOURNAL's most-reapplied lesson (phase-ordered A/B gates confound code deltas with time-correlated drift). Adds `cvPct` + `classifyDriftFlag` to `benchmark/shared/stats.dart` and a `benchmark/ab_drift_check.dart` CLI that reads two order-flipped passes of per-run values and classifies a regression flag as `reproduced` (same-direction effect, comparable CVs), `drift-suspected` (CV asymmetry on the flagged phase, or sign reversal across the flip), or `inconclusive`. Re-run against the recorded flags from exp 159 (CV asymmetry) and exp 167 (sign reversal), it reproduces the verdicts those runners reached by hand. No runtime change; 14/14 unit tests pass |  |
-| [195](195-stmt-cache-name-tokens.md) | Stmt-cache pre-encoded JSON column-name tokens | Extends [exp 190](190-selectbytes-col-name-preencode.md)'s per-query token amortization across re-executions of the same prepared SQL by caching the encoded `"name":` / `,"name":` tokens on the `resqlite_cached_stmt` entry. Eliminates the per-query `buf_init(64)` + `free` pair and the first-row pre-encode walk from `write_json_to_buf`; the per-row loop is bit-identical to exp 190 and JSON output is byte-identical. Focused `select_bytes_repeated_calls.dart` 1-row × 20-col improves **−9.2 % / −7.2 %** and 10-row × 20-col improves **−5.1 % / −2.7 %** across two order-flipped passes, while 100/1000-row guards show sign reversal (drift-suspected — per-query setup is < 0.2 % of wall at those sizes). Exp 190's `wide_cols.dart` shapes trend candidate-faster on every 10k-row lane across both passes. No public API change, ~hundreds of bytes per cached statement |  |
+| [150](150-nullable-batch-packing.md) | Nullable batch parameter packing | Makes the guarded packed batch encoder nullable-aware for first-row `NULL` text columns; focused nullable ASCII 10k x8 improves 13.552 → 11.152 ms and 10k x20 improves 25.738 → 21.723 ms while existing ASCII/Unicode wide guardrails stay neutral |  |
+| [149](149-six-param-batch-packing.md) | Six-parameter batch packing | Lowers the guarded ASCII batch-packing threshold to the Tracelite merge-round shape; profile `merge_rounds` improves executeBatch p50 88 → 75 us and writer SQLite time 87,895 → 75,947 us while keeping 2-3 parameter batches generic |  |
+| [147](147-writer-sqlite-wall-split.md) | Writer SQLite wall split | Measurement-only: profile-mode writer responses now report SQLite-facing write time back into `ProfileCounters`; on A11c overlap, SQLite is 15.7 ms / 166.8 ms (9.4%), invalidation is 18.8%, and residual writer/request wall is 71.8%. Keyed-PK shows the same shape (18.1% SQLite, 18.7% invalidation, 63.3% residual). Clears the writer-wall-vs-SQLite-wall blocker; next stream work should reduce completion/reply scheduling or residual writer/request wall rather than SQLite-step tuning |  |
+| [144](144-sqlite3mc-bump-2-3-5.md) | sqlite3mc 2.3.2 → 2.3.5 bump (SQLite 3.51.3 → 3.53.2) | Satisfies exp 090's revisit trigger (SQLite `.2`+ point release with sqlite3mc tracking it); tests stay green including embedded-NUL + Unicode bind regression suite; release-suite single-pass A/Bs swing between 19/18/124 and 30/2/129 — Concurrent Reads 8× is the only metric that flags consistently across reruns (+~20% on a sub-ms metric) and is the focus of the soak window; FP-rounding hazard skipped because resqlite never serialises REAL via `sqlite3_column_text` |  |
+| [143](143-tracelite-profile-insights.md) | Tracelite profile insight audit | Measurement-only: pinned Tracelite profile runs show stable dispatch floors (reader 12 us, writer 16 us), point queries at the dispatch floor, merge rounds with 77 us of floor-subtracted work, and memory/allocation signal that wall time alone hides; current `tracelite explain` only reports coverage, so richer workload-summary insight rules are the next measurement-system improvement |  |
+| [136](136-completion-microtask-counter.md) | Completion-side reader-handler counter | Measurement-only: profile-mode counters (`completion_handler_us`, `stream_emit_us`) expose the main-isolate reader worker port handler chain on A11c overlap as 28.57% of total wall (burst + drain) at ~18 µs per call across 4,228 calls/burst, with subscriber emit only 0.35% of the chain. Reader-reply batching is the natural bounded implementation candidate. Closes the `completion-side microtask scheduling cost counter` entry in `signals.json#stream-rerun-dispatch.blockedOnMeasurement` |  |
+| [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 |  |
+| [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 |  |
+| [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 |  |
+| [121](121-invalidation-traversal-audit.md) | Invalidation traversal cost audit | Measurement-only: profile-mode harness reports `invalidate_us` / `intersection_us` as a fraction of writer-side burst wall on A11c (baseline / disjoint / overlap) and keyed-PK. Overlap invalidation is 10–15% of wall (column intersection 2.5–5.7%); keyed-PK 13–14% (intersection ~4%); disjoint 22–23% only because column elision shrinks the denominator. Per-entry intersection probes are 80–200 ns. Extracts shared `audit_workloads.dart` so this audit and exp 119 stay structurally comparable. Removes invalidation traversal from the active candidate list — the structural ceiling on smarter dependency tracking is ~3 ms / 25k probes per overlap burst |  |
+| [120](120-flush-admit-bound.md) | Bounded `_flushQueue` admission | Cap stream re-query admission at `ReaderPool.availableWorkerCount` per call so synchronous over-dispatch can no longer pile up against `_dispatchWaiters`. `dispatcherParkedTotal` drops from 3,590 → 0 (A11c overlap) and 1,198 → 0 (keyed-PK); `max_parked` 46 → 0. Release suite: 9 wins, 0 regressions, including neutral high-cardinality fan-out (the exp-100 killer) |  |
+| [119](119-dispatch-pressure-audit.md) | Post-FIFO dispatch pressure audit | Profile audit shows wake retries stay zero after FIFO, while A11c overlap and keyed-PK streams still produce parked dispatchers; next dispatch work should target stream admission/completion |  |
+| [118](118-fifo-dispatch-counter-gate.md) | FIFO dispatch waiters with counter gate | Replaces the shared reader-pool dispatch completer with FIFO one-shot waiters; exp 115 counters show wake retries drop to zero under overload |  |
+| [116](116-wide-batch-release-coverage.md) | Wide batch insert release coverage | Adds a 10k-row x 20-parameter mixed-type batch insert to the release write suite so parameter-width regressions are visible on the public benchmark path |  |
+| [113](113-direct-batch-param-matrix.md) | Direct batch parameter matrix encoding | Avoids the temporary flat Dart parameter list; 10k-row wide batches improve 14-26% in the focused benchmark | [#70](https://github.com/danReynolds/resqlite/pull/70) |
+| [110](110-long-text-fnv-8byte.md) | Long-text stream hash benchmark + 8-byte FNV | Adds a long-text unchanged-fanout benchmark and cuts its median latency by 76% with chunked byte-stream hashing | [#53](https://github.com/danReynolds/resqlite/pull/53) |
+| [097](097-one-pass-initial-stream-hash.md) | One-pass initial stream decode and hash | 14-16% faster setup-heavy streaming benchmarks by avoiding the initial stream query replay |  |
+| [083](083-stream-rerun-pre-dispatch-queue.md) | Stream rerun pre-dispatch queue | Eliminates the measured `A11` / `A11b` reader-pool wait bottleneck by coalescing reruns before pool admission | [#25](https://github.com/danReynolds/resqlite/pull/25) |
 
 ## Rejected
 
@@ -127,64 +127,64 @@ Experiments that didn't work out. Each has valuable context on *why* — check b
 | [117](117-named-parameters.md) | Named parameter support (`Map<String, Object?>`) | Functionally complete and correct; 5-run focused harness showed wide-batch within noise (+2.7%). Deferred for v0.x launch: 12K-LOC change touching the entire write path for an ergonomics nice-to-have, with 6/7 write-path benchmarks trending slightly slower (monotonic direction = weaker than independent noise). Reopen if (a) community feedback shows named params are a real adoption barrier and a 5-run release suite confirms neutral, or (b) someone redesigns dispatch as two top-level branches in `run_batch_locked` instead of per-row inline dispatch. Implementation lives on the `exp-117-named-parameters` branch. |
 | [114](114-fifo-waiter-queue.md) | FIFO waiter queue for `ReaderPool` dispatch | First A/B pass (against pre-exp-106 baseline) showed −10 % to −32 % on streaming fan-out paths; rebasing onto main with exp 106 polish merged collapsed all targeted wins into noise. Exp 106 elides stream re-queries on the writer side before they reach the reader pool, so the parked-dispatcher contention this change targeted no longer fires under any release-suite workload. Implementation reverted; doc + benchmark artifacts retained as the durable record. Cherry-pickable from PR git history if a workload re-introduces sustained pool parking |
 | [112](112-fixed-length-batch-param-flatten.md) | Fixed-length batch parameter flattening | Focused benchmark medians overlapped after repeated A/B passes; any large-batch improvement was below the current decision threshold, so the simpler growable-list flattening stays |
+| [111](111-nested-tx-benchmark-savepoint-cache.md) | Nested-tx benchmark + revisit savepoint string cache | Built the missing nested-transaction workload (shipped) and re-tested exp 102's archived cached-savepoint-string pattern against it. Even on the worst-case 50×-shallow-fan-out shape the cache landed at -9 % (below the ±17 % decision threshold); deep-5-chain was flat. Confirms exp 102 across a maximally stressing workload — per-isolate-round-trip cost dominates per-call savepoint allocations |
 | [108](108-selectbytes-out-slots.md) | Persistent selectBytes out-parameter slots | Target selectBytes benchmarks stayed within noise, and memory/rss flags removed any case for permanent native scratch state |
-| [103](103-native-nested-tx-depth-control.md) | Native nested transaction depth control | Focused nested-tx benchmark showed at best a small savepoint-only improvement; realistic nested write cases were flat or worse, so extra native API surface is not justified |
 | [105](105-reader-pool-sizing.md) | Raise reader pool worker cap (4→8) | Regressed A11c writer throughput by ~31% under N=50 stream fan-out; the profile's reader-pool serialization bottleneck was actually throttling completion-side microtask churn. Cap=4 is correctly tuned. |
 | [104](104-094-reeval-under-a11c.md) | Re-eval of exp 094 (dirty/read string reuse) under A11c | Even under A11c fan-out (~50× amplification of read-set/dirty-set add traffic), deltas were within noise on every workload the change targets (disjoint +4%, overlap −2%, concurrent reads ±10% — all inside MDE_ci). Empirically validates 094's original "below noise floor" rejection. |
+| [103](103-native-nested-tx-depth-control.md) | Native nested transaction depth control | Focused nested-tx benchmark showed at best a small savepoint-only improvement; realistic nested write cases were flat or worse, so extra native API surface is not justified |
+| [102](102-savepoint-string-cache.md) | Cached SAVEPOINT/RELEASE/ROLLBACK TO strings on `_WriterState` | Theoretically removes per-nested-tx `toNativeUtf8` + `calloc.free` pair, but the benchmark suite has no nested-transaction workload — no directly attributable signal, only run-to-run drift on unrelated read paths. Pattern-matches exp 095. Revisit if a deeply-nested-tx benchmark exists |
 | [100](100-bounded-stream-requery-scheduler.md) | Bounded stream re-query scheduler | Did not improve unrelated reads during fan-out and regressed high-cardinality stream fan-out by 103% |
-| [025](025-pragma-optimize.md) | `PRAGMA optimize` | Right idea in principle, but no compelling or reliable benchmark win in the current suite |
-| [026](026-db-status-probe.md) | `sqlite3_db_status()` probe | Near-perfect cache hit rates and zero spill mean a page-cache experiment is not justified |
-| [027](027-transaction-query-writer-cache.md) | Transaction query writer cache | Did not move the target interactive transaction metric enough to justify merging |
-| [031](031-json1-bulk-shapes.md) | JSON1 bulk shapes | Mixed and workload-specific; only compelling when the payload is already serialized as JSON |
-| [002](002-c-binary-buffer-for-maps.md) | C binary buffer for maps | Double-pass overhead (C encode + Dart decode) negated FFI savings |
-| [005](005-dart-binary-codec-transferable-typed-data.md) | Dart binary codec + TransferableTypedData | 5-7x slower than VM's native SendPort.send serializer |
-| [006](006-string-interning.md) | String interning | Hash lookup cost exceeded dedup savings on mostly-unique data |
-| [008b](008b-byte-backed-lazy-maps.md) | Byte-backed lazy maps | Moved decode work (utf8.decode) to main isolate — wrong trade-off |
-| [010](010-ascii-fast-path-string-decode.md) | ASCII fast-path string decode | Marginal gain for ASCII, strictly worse for non-ASCII |
-| [011](011-persistent-reader-pool.md) | Persistent reader pool | Equivalent to one-off isolates; pool overhead cancels messaging savings |
-| [012](012-sendport-vs-spawn-deep-dive.md) | SendPort vs Isolate.spawn deep dive | Confirmed one-off isolates are optimal; persistent pools not faster |
-| [014](014-writer-tuning.md) | locking_mode=EXCLUSIVE *(partial)* | Blocks all readers — incompatible with concurrent reader pool |
-| [017](017-dart-postcobject.md) | Dart_PostCObject for reads | 2-5x slower — serialize/deserialize costs more than validation walk |
-| [018](018-multi-row-step.md) | Multi-row step (64 rows/FFI call) | String copy overhead exceeds FFI crossing savings |
-| [041](041-ryu-double-to-string.md) | Ryu double-to-string for JSON | Initially accepted but reverted after re-analysis: only -10% on one benchmark (text-heavy 1k rows) was actually attributable to 041; the claimed selectBytes wins were from 043. Not worth ~1500 lines of vendored third-party code + ~85-line format-compatibility wrapper |
-| [042](042-lto-build-flag.md) | LTO build flag (`-flto`) | Four rounds tested (full, noinline, stacked, thin). Every config net negative — icache pressure from cross-unit inlining into the 250k-line SQLite amalgamation |
-| [051](051-lock-free-reader-pool.md) | Lock-free reader pool with atomics | Mutex path is dead code since experiment 030 assigned dedicated readers; optimization target doesn't exist in the live path |
+| [099](099-fnv-8byte-bytestream.md) | 8-byte-chunked FNV for byte-stream cells | Structurally sound (folds 8 bytes per multiply on the long-text hash path) but benchmark-invisible — current streaming workloads carry only short cells (≤ 3–8 bytes) that bypass the new main loop. Same class as exp 071. Revisit when a long-text streaming benchmark exists |
+| [096](096-direct-batch-param-encoding.md) | Direct batch parameter encoding | Large batch medians only trended down; no accepted-level harness win and too much duplicate parameter-encoding code |
+| [095](095-writer-result-buffer.md) | Persistent writer result buffer | The removable 16-byte calloc/free pair did not produce reliable write-path wins |
+| [094](094-dirty-read-string-reuse.md) | Dirty/read table string reuse | Focused dispatch was effectively flat and the full suite produced no wins; native branch/lifetime complexity is not justified |
+| [093](093-alias-cache-entry-read-tables.md) | Alias cache entry's read tables instead of copying | Below the measurement floor — savings ceiling was one `strdup`/`free` pair per cached table name per reader query (~hundreds of ns on a 1–3 table query). Work medians unchanged in 3-run A/B; tail regressions pattern-matched run-to-run variance (`noop` regressed as much as `point_query`, but `noop` never touches the changed path). Same class as exp 076 |
+| [092](092-wal-checkpoint-noop.md) | `wal_checkpoint=NOOP` probe in periodic checkpointer | Premise invalid — exp-029 is hook-gated on `pages_in_wal`, not timer-gated. NOOP exists to report the frame counter the wal-hook already receives; adding NOOP would be a strictly additive header read with no empty-tick cost to amortize |
+| [090](090-sqlite3mc-bump-audit.md) | sqlite3mc dependency bump audit | No bump needed — we are already on the newest stable sqlite3mc (2.3.2 / SQLite 3.51.3, 37 days old). The only newer target (3.53.0) is a 12-day-old .0 release excluded by our known-regressions policy, and its changelog shows no hot-path wins. Revisit when 3.53.2+ ships |
+| [089](089-deeply-immutable-resultset.md) | Deeply-immutable `ResultSet` for zero-copy isolate transfer | Blocked upstream: Dart's `@pragma('vm:deeply-immutable')` requires all fields to be in a closed set that excludes `List<T>`, `Uint8List`, and any typed data. `ResultSet` / `RawQueryResult` are `List<Object?>`-centered and BLOB cells are `Uint8List`. Re-check when SDK #50068 (DI typed-data factory) ships |
+| [088](088-setlk-timeout.md) | `SQLITE_ENABLE_SETLK_TIMEOUT` + `sqlite3_setlk_timeout` on every connection | Downgraded from Accepted after 5-run confirmation: original single-run p99/max wins were noise (baseline outlier that never reproduced). Multi-run median shows p99 +74 % to +172 % worse and max +29 % to +529 % worse on writes; noop regresses even though it has no lock contention. Needs a concurrent-reader harness + shorter timeout to be evaluable |
+| [085](085-reserved-reader-slot-for-reruns.md) | Reserved reader slot for reruns | The queue is the real source of the `A11` / `A11b` win; removing the reserved reader regressed broader workload balance, especially `A7` |
+| [084](084-late-dispatch-generation-stamp.md) | Late dispatch generation stamp | Real partial improvement, but materially weaker than 083 because reruns still pile up inside `ReaderPool` |
+| [082](082-message-graph-handoff.md) | Message-graph hand-off benchmark | Current `ResultSet` / `Row` shape is already near-optimal for the shipped `select()` contract; materialized maps and binary row facades both lose on end-to-end total |
+| [081](081-binary-row-result-storage.md) | Binary row result storage | Transfer-side numeric scan wins collapsed once full main-isolate row consumption was measured; mixed rows regressed and point-query floor worsened |
+| [076](076-prebound-stmt-cache-analysis.md) | Pre-bound statement cache | Rejected in pre-implementation analysis: bind is ~0.3 % of re-query wall time (~50 ns per call). No measurable headroom even for a perfect implementation |
+| [074](074-bulk-step-many.md) | Bulk `step_many` batched FFI for read path | Same wall as exp 018: memcpy-in-C cost exceeds FFI-crossing savings. Text-heavy workloads regressed +38 %. Dart already reads directly from SQLite's text buffer; adding a C-side copy before Dart decode is strictly worse |
+| [073](073-schema-cache-fast-path.md) | Single-slot schema-cache fast-path | Within noise: Dart's cached `String.hashCode` already makes map lookups fast enough that a one-slot bypass is below the measurement floor for the current suite |
+| [072](072-xxhash-for-fnv.md) | xxhash64 replacing FNV-1a for result change detection | +75 % regression on stream invalidation: xxhash mergeRound is ~2× more ops than FNV's xor+mul, and our inputs are pre-hashed 64-bit values rather than byte streams (where xxhash wins) |
+| [071](071-stmt-cache-mru-scan.md) | MRU-first stmt cache scan + SQL hash filter | Structurally sound but unmeasurable: benchmark suite uses ≤ 10 distinct SQLs so the cache never stresses the scan path |
+| [069](069-sql-fingerprint.md) | SQL fingerprint in stmt cache | Deferred: proper normalization needs a ~300+-line SQL rewriter; `sqlite3_normalized_sql` takes a prepared stmt as input, not raw SQL |
+| [068](068-ddl-schema-watchdog.md) | DDL schema_version watchdog | Deferred: initial implementation shipped + reverted after CI flakiness. Root cause is a C-level stmt cache race with SQLite's auto-reprepare — needs its own design pass to invalidate cached stmts on schema version bump |
+| [067](067-shrink-initial-allocation.md) | Shrink initial values allocation (256→4) | Caused +40-44% regressions; Dart VM has a fast path for `List.filled` that shrinking bypasses |
+| [066](066-transparent-fast-path.md) | Transparent single-row fast path in `select()` | Insufficient headroom — most of 063's win came from return-type change (`Map` vs `List<Map>`) which can't be captured transparently |
+| [065](065-json1-reevaluation.md) | JSON1 re-evaluation (post-041/043) | Our custom path now ≥ JSON1 everywhere; confirms 031 with larger margin |
+| [063](063-select-one-fast-path.md) | SelectOne fast path API | +28-48% point query win measured but rejected to preserve lean API surface |
+| [060](060-combined-single-row-ffi.md) | Combined single-row FFI call | Text pointers invalidated by `sqlite3_reset` — required the inline-copy approach explored later |
+| [059](059-row-count-hint.md) | Row count hint in schema cache | Marginal wins (2/0/61) on repeated queries but below noise on primary paths |
+| [058](058-short-string-cache.md) | Short-string value cache | +134-256% regression. Dart's `String.fromCharCodes` is uncatchable with any Dart-level cache |
+| [057](057-preupdate-batching.md) | Preupdate hook batching for batch inserts | Savings (~2ms in 50ms batch) below noise floor |
+| [055](055-columnar-typed-arrays.md) | Columnar typed arrays | Memory win confirmed (75% for numerics, 10000x fewer GC objects) but below time-based benchmark floor; requires memory profiling harness |
+| [054](054-pgo.md) | Profile-Guided Optimization | macOS dylib profraw flush doesn't fire from Dart VM host process; needs CI pipeline with standalone C binary |
+| [053](053-page-size-8192.md) | Page size 8192 | -16% select at 10k rows on new DBs but breaks existing DBs (requires VACUUM); should be exposed as `Database.open` option, not default |
 | [052](052-column-level-dependencies.md) | Column-level dependency tracking | Sound architecture (skip re-queries on writes to non-watched columns), but current streaming benchmarks have 0% disjoint-column rate — benchmark-invisible |
-| [046](046-sync-stream-controller.md) | Synchronous StreamController | Reentrancy crash: sync delivery causes concurrent modification of subscriber list during iteration |
+| [051](051-lock-free-reader-pool.md) | Lock-free reader pool with atomics | Mutex path is dead code since experiment 030 assigned dedicated readers; optimization target doesn't exist in the live path |
 | [047](047-authorizer-opt-out.md) | Authorizer opt-out for non-stream queries | Shared statement cache stores empty dependency sets when tracking is off, breaking stream invalidation |
-| [053](053-page-size-8192.md) | Page size 8192 | -16% select at 10k rows on new DBs but breaks existing DBs (requires VACUUM); should be exposed as `Database.open` option, not default |
-| [054](054-pgo.md) | Profile-Guided Optimization | macOS dylib profraw flush doesn't fire from Dart VM host process; needs CI pipeline with standalone C binary |
-| [055](055-columnar-typed-arrays.md) | Columnar typed arrays | Memory win confirmed (75% for numerics, 10000x fewer GC objects) but below time-based benchmark floor; requires memory profiling harness |
-| [057](057-preupdate-batching.md) | Preupdate hook batching for batch inserts | Savings (~2ms in 50ms batch) below noise floor |
-| [058](058-short-string-cache.md) | Short-string value cache | +134-256% regression. Dart's `String.fromCharCodes` is uncatchable with any Dart-level cache |
-| [059](059-row-count-hint.md) | Row count hint in schema cache | Marginal wins (2/0/61) on repeated queries but below noise on primary paths |
-| [060](060-combined-single-row-ffi.md) | Combined single-row FFI call | Text pointers invalidated by `sqlite3_reset` — required the inline-copy approach explored later |
-| [063](063-select-one-fast-path.md) | SelectOne fast path API | +28-48% point query win measured but rejected to preserve lean API surface |
-| [065](065-json1-reevaluation.md) | JSON1 re-evaluation (post-041/043) | Our custom path now ≥ JSON1 everywhere; confirms 031 with larger margin |
-| [066](066-transparent-fast-path.md) | Transparent single-row fast path in `select()` | Insufficient headroom — most of 063's win came from return-type change (`Map` vs `List<Map>`) which can't be captured transparently |
-| [067](067-shrink-initial-allocation.md) | Shrink initial values allocation (256→4) | Caused +40-44% regressions; Dart VM has a fast path for `List.filled` that shrinking bypasses |
-| [068](068-ddl-schema-watchdog.md) | DDL schema_version watchdog | Deferred: initial implementation shipped + reverted after CI flakiness. Root cause is a C-level stmt cache race with SQLite's auto-reprepare — needs its own design pass to invalidate cached stmts on schema version bump |
-| [069](069-sql-fingerprint.md) | SQL fingerprint in stmt cache | Deferred: proper normalization needs a ~300+-line SQL rewriter; `sqlite3_normalized_sql` takes a prepared stmt as input, not raw SQL |
-| [071](071-stmt-cache-mru-scan.md) | MRU-first stmt cache scan + SQL hash filter | Structurally sound but unmeasurable: benchmark suite uses ≤ 10 distinct SQLs so the cache never stresses the scan path |
-| [072](072-xxhash-for-fnv.md) | xxhash64 replacing FNV-1a for result change detection | +75 % regression on stream invalidation: xxhash mergeRound is ~2× more ops than FNV's xor+mul, and our inputs are pre-hashed 64-bit values rather than byte streams (where xxhash wins) |
-| [073](073-schema-cache-fast-path.md) | Single-slot schema-cache fast-path | Within noise: Dart's cached `String.hashCode` already makes map lookups fast enough that a one-slot bypass is below the measurement floor for the current suite |
-| [074](074-bulk-step-many.md) | Bulk `step_many` batched FFI for read path | Same wall as exp 018: memcpy-in-C cost exceeds FFI-crossing savings. Text-heavy workloads regressed +38 %. Dart already reads directly from SQLite's text buffer; adding a C-side copy before Dart decode is strictly worse |
-| [076](076-prebound-stmt-cache-analysis.md) | Pre-bound statement cache | Rejected in pre-implementation analysis: bind is ~0.3 % of re-query wall time (~50 ns per call). No measurable headroom even for a perfect implementation |
-| [081](081-binary-row-result-storage.md) | Binary row result storage | Transfer-side numeric scan wins collapsed once full main-isolate row consumption was measured; mixed rows regressed and point-query floor worsened |
-| [082](082-message-graph-handoff.md) | Message-graph hand-off benchmark | Current `ResultSet` / `Row` shape is already near-optimal for the shipped `select()` contract; materialized maps and binary row facades both lose on end-to-end total |
-| [084](084-late-dispatch-generation-stamp.md) | Late dispatch generation stamp | Real partial improvement, but materially weaker than 083 because reruns still pile up inside `ReaderPool` |
-| [085](085-reserved-reader-slot-for-reruns.md) | Reserved reader slot for reruns | The queue is the real source of the `A11` / `A11b` win; removing the reserved reader regressed broader workload balance, especially `A7` |
-| [088](088-setlk-timeout.md) | `SQLITE_ENABLE_SETLK_TIMEOUT` + `sqlite3_setlk_timeout` on every connection | Downgraded from Accepted after 5-run confirmation: original single-run p99/max wins were noise (baseline outlier that never reproduced). Multi-run median shows p99 +74 % to +172 % worse and max +29 % to +529 % worse on writes; noop regresses even though it has no lock contention. Needs a concurrent-reader harness + shorter timeout to be evaluable |
-| [089](089-deeply-immutable-resultset.md) | Deeply-immutable `ResultSet` for zero-copy isolate transfer | Blocked upstream: Dart's `@pragma('vm:deeply-immutable')` requires all fields to be in a closed set that excludes `List<T>`, `Uint8List`, and any typed data. `ResultSet` / `RawQueryResult` are `List<Object?>`-centered and BLOB cells are `Uint8List`. Re-check when SDK #50068 (DI typed-data factory) ships |
-| [090](090-sqlite3mc-bump-audit.md) | sqlite3mc dependency bump audit | No bump needed — we are already on the newest stable sqlite3mc (2.3.2 / SQLite 3.51.3, 37 days old). The only newer target (3.53.0) is a 12-day-old .0 release excluded by our known-regressions policy, and its changelog shows no hot-path wins. Revisit when 3.53.2+ ships |
-| [092](092-wal-checkpoint-noop.md) | `wal_checkpoint=NOOP` probe in periodic checkpointer | Premise invalid — exp-029 is hook-gated on `pages_in_wal`, not timer-gated. NOOP exists to report the frame counter the wal-hook already receives; adding NOOP would be a strictly additive header read with no empty-tick cost to amortize |
-| [093](093-alias-cache-entry-read-tables.md) | Alias cache entry's read tables instead of copying | Below the measurement floor — savings ceiling was one `strdup`/`free` pair per cached table name per reader query (~hundreds of ns on a 1–3 table query). Work medians unchanged in 3-run A/B; tail regressions pattern-matched run-to-run variance (`noop` regressed as much as `point_query`, but `noop` never touches the changed path). Same class as exp 076 |
-| [094](094-dirty-read-string-reuse.md) | Dirty/read table string reuse | Focused dispatch was effectively flat and the full suite produced no wins; native branch/lifetime complexity is not justified |
-| [095](095-writer-result-buffer.md) | Persistent writer result buffer | The removable 16-byte calloc/free pair did not produce reliable write-path wins |
-| [096](096-direct-batch-param-encoding.md) | Direct batch parameter encoding | Large batch medians only trended down; no accepted-level harness win and too much duplicate parameter-encoding code |
-| [099](099-fnv-8byte-bytestream.md) | 8-byte-chunked FNV for byte-stream cells | Structurally sound (folds 8 bytes per multiply on the long-text hash path) but benchmark-invisible — current streaming workloads carry only short cells (≤ 3–8 bytes) that bypass the new main loop. Same class as exp 071. Revisit when a long-text streaming benchmark exists |
-| [102](102-savepoint-string-cache.md) | Cached SAVEPOINT/RELEASE/ROLLBACK TO strings on `_WriterState` | Theoretically removes per-nested-tx `toNativeUtf8` + `calloc.free` pair, but the benchmark suite has no nested-transaction workload — no directly attributable signal, only run-to-run drift on unrelated read paths. Pattern-matches exp 095. Revisit if a deeply-nested-tx benchmark exists |
-| [111](111-nested-tx-benchmark-savepoint-cache.md) | Nested-tx benchmark + revisit savepoint string cache | Built the missing nested-transaction workload (shipped) and re-tested exp 102's archived cached-savepoint-string pattern against it. Even on the worst-case 50×-shallow-fan-out shape the cache landed at -9 % (below the ±17 % decision threshold); deep-5-chain was flat. Confirms exp 102 across a maximally stressing workload — per-isolate-round-trip cost dominates per-call savepoint allocations |
+| [046](046-sync-stream-controller.md) | Synchronous StreamController | Reentrancy crash: sync delivery causes concurrent modification of subscriber list during iteration |
+| [042](042-lto-build-flag.md) | LTO build flag (`-flto`) | Four rounds tested (full, noinline, stacked, thin). Every config net negative — icache pressure from cross-unit inlining into the 250k-line SQLite amalgamation |
+| [041](041-ryu-double-to-string.md) | Ryu double-to-string for JSON | Initially accepted but reverted after re-analysis: only -10% on one benchmark (text-heavy 1k rows) was actually attributable to 041; the claimed selectBytes wins were from 043. Not worth ~1500 lines of vendored third-party code + ~85-line format-compatibility wrapper |
+| [031](031-json1-bulk-shapes.md) | JSON1 bulk shapes | Mixed and workload-specific; only compelling when the payload is already serialized as JSON |
+| [027](027-transaction-query-writer-cache.md) | Transaction query writer cache | Did not move the target interactive transaction metric enough to justify merging |
+| [026](026-db-status-probe.md) | `sqlite3_db_status()` probe | Near-perfect cache hit rates and zero spill mean a page-cache experiment is not justified |
+| [025](025-pragma-optimize.md) | `PRAGMA optimize` | Right idea in principle, but no compelling or reliable benchmark win in the current suite |
+| [018](018-multi-row-step.md) | Multi-row step (64 rows/FFI call) | String copy overhead exceeds FFI crossing savings |
+| [017](017-dart-postcobject.md) | Dart_PostCObject for reads | 2-5x slower — serialize/deserialize costs more than validation walk |
+| [014](014-writer-tuning.md) | locking_mode=EXCLUSIVE *(partial)* | Blocks all readers — incompatible with concurrent reader pool |
+| [012](012-sendport-vs-spawn-deep-dive.md) | SendPort vs Isolate.spawn deep dive | Confirmed one-off isolates are optimal; persistent pools not faster |
+| [011](011-persistent-reader-pool.md) | Persistent reader pool | Equivalent to one-off isolates; pool overhead cancels messaging savings |
+| [010](010-ascii-fast-path-string-decode.md) | ASCII fast-path string decode | Marginal gain for ASCII, strictly worse for non-ASCII |
+| [008b](008b-byte-backed-lazy-maps.md) | Byte-backed lazy maps | Moved decode work (utf8.decode) to main isolate — wrong trade-off |
+| [006](006-string-interning.md) | String interning | Hash lookup cost exceeded dedup savings on mostly-unique data |
+| [005](005-dart-binary-codec-transferable-typed-data.md) | Dart binary codec + TransferableTypedData | 5-7x slower than VM's native SendPort.send serializer |
+| [002](002-c-binary-buffer-for-maps.md) | C binary buffer for maps | Double-pass overhead (C encode + Dart decode) negated FFI savings |
 
 ## Conventions
 
diff --git a/experiments/README.template.md b/experiments/README.template.md
new file mode 100644
index 00000000..eb263289
--- /dev/null
+++ b/experiments/README.template.md
@@ -0,0 +1,135 @@
+# resqlite Experiments
+
+Each file documents a performance experiment: what we tried, what we measured, and whether it worked. These serve as institutional memory — before trying a new optimization, check here to see if we've already explored it.
+
+## Accepted
+
+Experiments that proved their value and were merged into the codebase.
+
+| # | Experiment | Impact | Commit |
+|---|---|---|---|
+{{ROWS:accepted}}
+
+## In Review
+
+Recent or pending-acceptance experiments. An entry sits here either
+because the PR is still open, or because the experiment has merged but
+is in its post-merge soak window — typically two weeks, longer if a
+release-cycle metric has not run yet. Soak is for catching regressions
+that only surface under realistic workloads or downstream rebases (see
+the journal entry on exp 114 for the canonical example). Promote rows
+to **Accepted** once the soak window closes and no new evidence has
+moved them.
+
+| # | Experiment | Impact | PR |
+|---|---|---|---|
+{{ROWS:in_review}}
+
+## Rejected
+
+Experiments that didn't work out. Each has valuable context on *why* — check before revisiting similar ideas.
+
+| # | Experiment | Why Rejected |
+|---|---|---|
+{{ROWS:rejected}}
+
+## Conventions
+
+- **Experiment number:** Monotonically increasing, never reused
+- **Date:** When the experiment was run (full timestamp preferred: `2026-04-14T12:30:00`)
+- **Status:** `Accepted` (merged + soak window closed), `In Review` (PR open or in post-merge soak window — typically two weeks), or `Rejected` (abandoned, with explanation). New experiments start at `In Review` and graduate after the soak.
+- **Commit:** Git hash of the implementing commit (added to header of each accepted experiment)
+
+### Research Map
+
+Scheduled experimenters should use
+[`RUNNER_INSTRUCTIONS.md`](RUNNER_INSTRUCTIONS.md) as the copyable instruction
+block for recurring experiment systems. Those instructions point runners at
+this README, [`signals.json`](signals.json), [`JOURNAL.md`](JOURNAL.md), and
+the project [`stories`](../doc/stories/) before choosing work.
+
+`signals.json` is the canonical research map. These files are steering context,
+not an allowed list. They should make prior work easy to understand without
+preventing creative experiments outside the current map. A strong new
+experiment can follow an active direction, revisit an area that recently looked
+weak, or open a new direction entirely. The important thing is to explain why
+the attempt is worth a bounded pass in light of prior work.
+
+When an experiment changes what future work should try, de-emphasize, measure,
+or watch:
+
+- update the experiment writeup with the record of what happened
+- update `signals.json` with machine-readable direction context
+- add to `JOURNAL.md` only when the run surfaced a transferable lesson a
+  future runner could reapply elsewhere
+- leave `../doc/stories/` alone — story posts are updated on maintainer
+  request, not per experiment
+
+`signals.json` per-direction fields (see the inline `schemaNotes` block at
+the top of the file for the canonical descriptions):
+
+- `keyPriors` (required, max 6) — experiments a future runner must read.
+- `archive` (optional) — older or superseded evidence; not required reading.
+  Curate from `keyPriors` when a new accepted experiment supersedes an
+  older one.
+- `openCandidates` (optional) — dated candidate ideas waiting for the
+  right workload, signal, or runner. Each item is `{idea, addedDate,
+  addedAfter?, blockedOn?}`. Prune entries older than ~3 months that
+  nobody picked up.
+- `blockedOnMeasurement` (optional) — measurements that must land before
+  the next implementation experiment in this direction is worth
+  attempting. Empty if no measurement is gating new work.
+
+### Standard Template
+
+Use these exact headings so the experiments page can extract content automatically:
+
+```markdown
+# Experiment NNN: Title
+
+**Date:** 2026-04-14
+**Status:** Accepted / Rejected
+**Direction:** `direction-id`
+**Commit:** [`abc1234`](https://github.com/danReynolds/resqlite/commit/abc1234)
+**Archive:** [`archive/exp-NNN`](https://github.com/danReynolds/resqlite/compare/main...archive/exp-NNN)
+
+## Problem
+
+What performance issue or opportunity was identified.
+
+## Hypothesis
+
+The proposed optimization and why it should work.
+
+## Approach
+
+What was built or changed. Implementation details.
+
+## Results
+
+Benchmark measurements. Use markdown tables for comparisons.
+
+## Decision
+
+Why accepted or rejected. Trade-offs considered.
+
+## Future Notes
+
+Optional. Short notes for future experimenters: adjacent prior work, what would
+make the area interesting again, or what to measure before revisiting.
+```
+
+Header fields:
+
+- **Commit** — required for Accepted experiments; points at the merged
+  implementation commit on main.
+- **Archive** — added for Rejected experiments *whose implementation is
+  worth preserving for future re-evaluation* (the common case when the
+  rejection reason is "below noise floor, not worth the complexity").
+  Points at a git tag (`archive/exp-NNN`) that pins the last commit of
+  the experiment branch before it was deleted. See the
+  `resqlite-experiment` skill for the tagging workflow. Skip this field
+  for rejections of the form "implementation was broken" — there's
+  nothing worth preserving.
+
+Older experiments use varied headings (`What We Built`, `Changes`, `Benchmark`, `Why Accepted`, etc.) — those still work, but new experiments should follow this template.
diff --git a/experiments/RUNNER_INSTRUCTIONS.md b/experiments/RUNNER_INSTRUCTIONS.md
index 81df983b..35320859 100644
--- a/experiments/RUNNER_INSTRUCTIONS.md
+++ b/experiments/RUNNER_INSTRUCTIONS.md
@@ -26,7 +26,8 @@ across future experiments.
 
 Before choosing an experiment, read:
 
-- [`README.md`](README.md) — the experiment table and templates
+- [`README.md`](README.md) — the experiment tables and templates (generated
+  from `experiments/index/NNN.json` fragments; read it, don't hand-edit it)
 - [`signals.json`](signals.json) — the canonical per-direction research map
 - [`JOURNAL.md`](JOURNAL.md) — transferable lessons from prior experiments
 - [`../doc/stories/`](../doc/stories/) — the curated narrative arc, for context
@@ -224,8 +225,14 @@ When finished:
   the journal.
 - do not edit [`../doc/stories/`](../doc/stories/) as part of an experiment
   run. Story posts are updated on maintainer request, not per experiment.
-- run the experiment finalizer after the writeup, README row, and
-  `experiments/signals/entries/NNN.json` are in place:
+- register the experiment by adding its **README row fragment**,
+  `experiments/index/NNN.json` — `{file, title, impact, status, link}` (status
+  is `accepted` / `in_review` / `rejected`). `experiments/README.md` is
+  *generated* from these fragments; do not edit the README table by hand. A
+  split experiment that has both an accepted and a rejected finding (like 014)
+  stores a JSON array of rows.
+- run the experiment finalizer after the writeup, the `index/NNN.json` row
+  fragment, and `experiments/signals/entries/NNN.json` are in place:
 
   ```bash
   dart run benchmark/finalize_experiment.dart \
@@ -234,14 +241,15 @@ When finished:
 
   This verifies the generated-docs **sources** build cleanly and the signal map
   is valid. It does **not** write `docs/experiments/history.json`,
-  `docs/benchmarks/devices.json`, or `experiments/signals.json` — those are
-  generated aggregates owned by the post-merge Update-Docs bot. **Never commit
-  them on your branch** (CI's `guard-generated-docs` job blocks it). You commit
-  only sources: the writeup, the README row, your signal fragment, benchmark
-  result files, and any code; the bot regenerates the aggregates on `main`
-  after merge. This is what keeps a stale branch from re-conflicting on
-  generated files the way the old "regenerate + commit `history.json` on every
-  branch" rule did.
+  `docs/benchmarks/devices.json`, `experiments/signals.json`, or
+  `experiments/README.md` — those are generated aggregates owned by the
+  post-merge Update-Docs bot. **Never commit them on your branch** (CI's
+  `guard-generated-docs` job blocks the JSON aggregates). You commit only
+  sources: the writeup, your `index/NNN.json` row fragment, your signal
+  fragment, benchmark result files, and any code; the bot regenerates the
+  aggregates on `main` after merge. This is what keeps a stale branch from
+  re-conflicting on generated files the way the old "regenerate + commit
+  `history.json` on every branch" rule did.
 - run focused validation plus the relevant repo checks
 - open a PR when the local experiment package is coherent enough for review
 
diff --git a/experiments/index/001.json b/experiments/index/001.json
new file mode 100644
index 00000000..3ab0d25b
--- /dev/null
+++ b/experiments/index/001.json
@@ -0,0 +1,7 @@
+{
+  "file": "001-c-native-json-serialization.md",
+  "title": "C-native JSON serialization",
+  "impact": "3.5x faster bytes path",
+  "status": "accepted",
+  "link": "[`4acfb57`](https://github.com/danReynolds/dune/commit/4acfb57)"
+}
diff --git a/experiments/index/002.json b/experiments/index/002.json
new file mode 100644
index 00000000..584b3c43
--- /dev/null
+++ b/experiments/index/002.json
@@ -0,0 +1,7 @@
+{
+  "file": "002-c-binary-buffer-for-maps.md",
+  "title": "C binary buffer for maps",
+  "impact": "Double-pass overhead (C encode + Dart decode) negated FFI savings",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/003.json b/experiments/index/003.json
new file mode 100644
index 00000000..89d5de8f
--- /dev/null
+++ b/experiments/index/003.json
@@ -0,0 +1,7 @@
+{
+  "file": "003-c-level-connection-and-statement-cache.md",
+  "title": "C-level connection + statement cache",
+  "impact": "~0.7ms saved per query",
+  "status": "accepted",
+  "link": "[`4acfb57`](https://github.com/danReynolds/dune/commit/4acfb57)"
+}
diff --git a/experiments/index/004.json b/experiments/index/004.json
new file mode 100644
index 00000000..ce986fda
--- /dev/null
+++ b/experiments/index/004.json
@@ -0,0 +1,7 @@
+{
+  "file": "004-nomutex-per-query-locking.md",
+  "title": "NOMUTEX with per-query locking",
+  "impact": "Eliminated 60k mutex ops at 20k rows",
+  "status": "accepted",
+  "link": "[`4acfb57`](https://github.com/danReynolds/dune/commit/4acfb57)"
+}
diff --git a/experiments/index/005.json b/experiments/index/005.json
new file mode 100644
index 00000000..1f4d5789
--- /dev/null
+++ b/experiments/index/005.json
@@ -0,0 +1,7 @@
+{
+  "file": "005-dart-binary-codec-transferable-typed-data.md",
+  "title": "Dart binary codec + TransferableTypedData",
+  "impact": "5-7x slower than VM's native SendPort.send serializer",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/006.json b/experiments/index/006.json
new file mode 100644
index 00000000..0ea8b7de
--- /dev/null
+++ b/experiments/index/006.json
@@ -0,0 +1,7 @@
+{
+  "file": "006-string-interning.md",
+  "title": "String interning",
+  "impact": "Hash lookup cost exceeded dedup savings on mostly-unique data",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/007.json b/experiments/index/007.json
new file mode 100644
index 00000000..0f716d75
--- /dev/null
+++ b/experiments/index/007.json
@@ -0,0 +1,7 @@
+{
+  "file": "007-c-level-connection-pool.md",
+  "title": "C-level connection pool",
+  "impact": "4.4x faster concurrent reads",
+  "status": "accepted",
+  "link": "[`3a08838`](https://github.com/danReynolds/dune/commit/3a08838)"
+}
diff --git a/experiments/index/008.json b/experiments/index/008.json
new file mode 100644
index 00000000..2ab1d84d
--- /dev/null
+++ b/experiments/index/008.json
@@ -0,0 +1,7 @@
+{
+  "file": "008-flat-list-lazy-resultset.md",
+  "title": "Flat value list + lazy ResultSet",
+  "impact": "The breakthrough — 10x fewer objects, beat sqlite3",
+  "status": "accepted",
+  "link": "[`a18492c`](https://github.com/danReynolds/dune/commit/a18492c), [`666da73`](https://github.com/danReynolds/dune/commit/666da73)"
+}
diff --git a/experiments/index/008b.json b/experiments/index/008b.json
new file mode 100644
index 00000000..7d881bf6
--- /dev/null
+++ b/experiments/index/008b.json
@@ -0,0 +1,7 @@
+{
+  "file": "008b-byte-backed-lazy-maps.md",
+  "title": "Byte-backed lazy maps",
+  "impact": "Moved decode work (utf8.decode) to main isolate — wrong trade-off",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/009.json b/experiments/index/009.json
new file mode 100644
index 00000000..0758418d
--- /dev/null
+++ b/experiments/index/009.json
@@ -0,0 +1,7 @@
+{
+  "file": "009-batch-ffi-step-row.md",
+  "title": "Batch FFI (resqlite_step_row)",
+  "impact": "9-21% improvement across all benchmarks",
+  "status": "accepted",
+  "link": "[`4c18bb4`](https://github.com/danReynolds/dune/commit/4c18bb4)"
+}
diff --git a/experiments/index/010.json b/experiments/index/010.json
new file mode 100644
index 00000000..8792f09d
--- /dev/null
+++ b/experiments/index/010.json
@@ -0,0 +1,7 @@
+{
+  "file": "010-ascii-fast-path-string-decode.md",
+  "title": "ASCII fast-path string decode",
+  "impact": "Marginal gain for ASCII, strictly worse for non-ASCII",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/011.json b/experiments/index/011.json
new file mode 100644
index 00000000..a643f57c
--- /dev/null
+++ b/experiments/index/011.json
@@ -0,0 +1,7 @@
+{
+  "file": "011-persistent-reader-pool.md",
+  "title": "Persistent reader pool",
+  "impact": "Equivalent to one-off isolates; pool overhead cancels messaging savings",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/012.json b/experiments/index/012.json
new file mode 100644
index 00000000..0b70af66
--- /dev/null
+++ b/experiments/index/012.json
@@ -0,0 +1,7 @@
+{
+  "file": "012-sendport-vs-spawn-deep-dive.md",
+  "title": "SendPort vs Isolate.spawn deep dive",
+  "impact": "Confirmed one-off isolates are optimal; persistent pools not faster",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/013.json b/experiments/index/013.json
new file mode 100644
index 00000000..236f5758
--- /dev/null
+++ b/experiments/index/013.json
@@ -0,0 +1,7 @@
+{
+  "file": "013-ffi-isleaf.md",
+  "title": "FFI isLeaf annotation",
+  "impact": "12-19% on small results, 5-9% across the board",
+  "status": "accepted",
+  "link": "[`af2cfd0`](https://github.com/danReynolds/dune/commit/af2cfd0)"
+}
diff --git a/experiments/index/014.json b/experiments/index/014.json
new file mode 100644
index 00000000..115b1ae2
--- /dev/null
+++ b/experiments/index/014.json
@@ -0,0 +1,16 @@
+[
+  {
+    "file": "014-writer-tuning.md",
+    "title": "BEGIN IMMEDIATE + remove clear_bindings",
+    "impact": "Correct but within noise (write I/O dominated)",
+    "status": "accepted",
+    "link": "[`4c368a6`](https://github.com/danReynolds/dune/commit/4c368a6)"
+  },
+  {
+    "file": "014-writer-tuning.md",
+    "title": "locking_mode=EXCLUSIVE *(partial)*",
+    "impact": "Blocks all readers — incompatible with concurrent reader pool",
+    "status": "rejected",
+    "link": ""
+  }
+]
diff --git a/experiments/index/015.json b/experiments/index/015.json
new file mode 100644
index 00000000..0cc9bec9
--- /dev/null
+++ b/experiments/index/015.json
@@ -0,0 +1,7 @@
+{
+  "file": "015-cell-buffer-union.md",
+  "title": "Cell buffer union (48 → 16 bytes)",
+  "impact": "Simplicity win, performance neutral",
+  "status": "accepted",
+  "link": "[`52f1e4b`](https://github.com/danReynolds/dune/commit/52f1e4b)"
+}
diff --git a/experiments/index/016.json b/experiments/index/016.json
new file mode 100644
index 00000000..88b6966f
--- /dev/null
+++ b/experiments/index/016.json
@@ -0,0 +1,7 @@
+{
+  "file": "016-sqlite-compile-flags.md",
+  "title": "SQLite compile flags + prepare_v3",
+  "impact": "Correctness wins, performance within noise",
+  "status": "accepted",
+  "link": "[`b9c6b6d`](https://github.com/danReynolds/dune/commit/b9c6b6d)"
+}
diff --git a/experiments/index/017.json b/experiments/index/017.json
new file mode 100644
index 00000000..57a4303b
--- /dev/null
+++ b/experiments/index/017.json
@@ -0,0 +1,7 @@
+{
+  "file": "017-dart-postcobject.md",
+  "title": "Dart_PostCObject for reads",
+  "impact": "2-5x slower — serialize/deserialize costs more than validation walk",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/018.json b/experiments/index/018.json
new file mode 100644
index 00000000..cdd8591e
--- /dev/null
+++ b/experiments/index/018.json
@@ -0,0 +1,7 @@
+{
+  "file": "018-multi-row-step.md",
+  "title": "Multi-row step (64 rows/FFI call)",
+  "impact": "String copy overhead exceeds FFI crossing savings",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/019.json b/experiments/index/019.json
new file mode 100644
index 00000000..525f7f7f
--- /dev/null
+++ b/experiments/index/019.json
@@ -0,0 +1,7 @@
+{
+  "file": "019-hybrid-reader-pool.md",
+  "title": "Hybrid reader pool (SendPort + sacrifice)",
+  "impact": "64-83% faster small reads, 45k qps point queries",
+  "status": "accepted",
+  "link": "[`e07d95b`](https://github.com/danReynolds/dune/commit/e07d95b)"
+}
diff --git a/experiments/index/020.json b/experiments/index/020.json
new file mode 100644
index 00000000..1c430a84
--- /dev/null
+++ b/experiments/index/020.json
@@ -0,0 +1,7 @@
+{
+  "file": "020-lookaside-allocator.md",
+  "title": "SQLITE_DEFAULT_LOOKASIDE tuning",
+  "impact": "Zero-cost compile flag improvement",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/021.json b/experiments/index/021.json
new file mode 100644
index 00000000..bc314b90
--- /dev/null
+++ b/experiments/index/021.json
@@ -0,0 +1,7 @@
+{
+  "file": "021-pcache-initsz.md",
+  "title": "SQLITE_DEFAULT_PCACHE_INITSZ=128",
+  "impact": "Slight positive trend on larger result sets",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/022.json b/experiments/index/022.json
new file mode 100644
index 00000000..12644613
--- /dev/null
+++ b/experiments/index/022.json
@@ -0,0 +1,7 @@
+{
+  "file": "022-wal-autocheckpoint.md",
+  "title": "WAL autocheckpoint tuning",
+  "impact": "Correctness and reliability improvement",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/023.json b/experiments/index/023.json
new file mode 100644
index 00000000..c994877c
--- /dev/null
+++ b/experiments/index/023.json
@@ -0,0 +1,7 @@
+{
+  "file": "023-fast-itoa.md",
+  "title": "Fast int64-to-string for JSON",
+  "impact": "Measurable win on the selectBytes hot path",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/024.json b/experiments/index/024.json
new file mode 100644
index 00000000..b52c2142
--- /dev/null
+++ b/experiments/index/024.json
@@ -0,0 +1,7 @@
+{
+  "file": "024-json-buffer-16k.md",
+  "title": "JSON buffer initial size 16KB",
+  "impact": "Sensible default, no measurable impact",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/025.json b/experiments/index/025.json
new file mode 100644
index 00000000..242d6f37
--- /dev/null
+++ b/experiments/index/025.json
@@ -0,0 +1,7 @@
+{
+  "file": "025-pragma-optimize.md",
+  "title": "`PRAGMA optimize`",
+  "impact": "Right idea in principle, but no compelling or reliable benchmark win in the current suite",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/026.json b/experiments/index/026.json
new file mode 100644
index 00000000..18fdca45
--- /dev/null
+++ b/experiments/index/026.json
@@ -0,0 +1,7 @@
+{
+  "file": "026-db-status-probe.md",
+  "title": "`sqlite3_db_status()` probe",
+  "impact": "Near-perfect cache hit rates and zero spill mean a page-cache experiment is not justified",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/027.json b/experiments/index/027.json
new file mode 100644
index 00000000..556b277b
--- /dev/null
+++ b/experiments/index/027.json
@@ -0,0 +1,7 @@
+{
+  "file": "027-transaction-query-writer-cache.md",
+  "title": "Transaction query writer cache",
+  "impact": "Did not move the target interactive transaction metric enough to justify merging",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/028.json b/experiments/index/028.json
new file mode 100644
index 00000000..db183381
--- /dev/null
+++ b/experiments/index/028.json
@@ -0,0 +1,7 @@
+{
+  "file": "028-static-bind-params.md",
+  "title": "Static bind for text/blob params",
+  "impact": "Improves targeted small-read and parameterized-query workloads",
+  "status": "accepted",
+  "link": "[`8822bd2`](https://github.com/danReynolds/dune/commit/8822bd2)"
+}
diff --git a/experiments/index/029.json b/experiments/index/029.json
new file mode 100644
index 00000000..5f39f291
--- /dev/null
+++ b/experiments/index/029.json
@@ -0,0 +1,7 @@
+{
+  "file": "029-periodic-passive-checkpointing.md",
+  "title": "Periodic PASSIVE checkpointing",
+  "impact": "Much lower burst write p95/p99/max via writer-side scheduling",
+  "status": "accepted",
+  "link": "[`8822bd2`](https://github.com/danReynolds/dune/commit/8822bd2)"
+}
diff --git a/experiments/index/030.json b/experiments/index/030.json
new file mode 100644
index 00000000..bc2e6e49
--- /dev/null
+++ b/experiments/index/030.json
@@ -0,0 +1,7 @@
+{
+  "file": "030-dedicated-reader-assignment.md",
+  "title": "Dedicated reader assignment",
+  "impact": "Removes per-query C pool mutex overhead and closes the point-query gap",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/031.json b/experiments/index/031.json
new file mode 100644
index 00000000..d5b43144
--- /dev/null
+++ b/experiments/index/031.json
@@ -0,0 +1,7 @@
+{
+  "file": "031-json1-bulk-shapes.md",
+  "title": "JSON1 bulk shapes",
+  "impact": "Mixed and workload-specific; only compelling when the payload is already serialized as JSON",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/032.json b/experiments/index/032.json
new file mode 100644
index 00000000..2fd42845
--- /dev/null
+++ b/experiments/index/032.json
@@ -0,0 +1,7 @@
+{
+  "file": "032-row-map-facade.md",
+  "title": "Row `Map` facade overrides",
+  "impact": "Keeps the fast transport shape intact while materially improving main-isolate `Map` operations",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/033.json b/experiments/index/033.json
new file mode 100644
index 00000000..7299f85e
--- /dev/null
+++ b/experiments/index/033.json
@@ -0,0 +1,7 @@
+{
+  "file": "033-fnv1a-hash.md",
+  "title": "FNV-1a hash for result change detection",
+  "impact": "Shared module for consistent stream result hashing",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/034.json b/experiments/index/034.json
new file mode 100644
index 00000000..b8dece80
--- /dev/null
+++ b/experiments/index/034.json
@@ -0,0 +1,7 @@
+{
+  "file": "034-schema-cache.md",
+  "title": "Per-worker schema cache",
+  "impact": "Eliminates FFI calls + string allocations for repeated queries",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/035.json b/experiments/index/035.json
new file mode 100644
index 00000000..7aa51712
--- /dev/null
+++ b/experiments/index/035.json
@@ -0,0 +1,7 @@
+{
+  "file": "035-cell-buffer-reuse.md",
+  "title": "Reuse cell buffer across queries",
+  "impact": "Eliminates per-query buffer allocations",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/036.json b/experiments/index/036.json
new file mode 100644
index 00000000..7113c16d
--- /dev/null
+++ b/experiments/index/036.json
@@ -0,0 +1,7 @@
+{
+  "file": "036-compiler-hints.md",
+  "title": "Compiler hints (Dart + C)",
+  "impact": "Zero-risk annotations, no behavioral changes",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/037.json b/experiments/index/037.json
new file mode 100644
index 00000000..182958be
--- /dev/null
+++ b/experiments/index/037.json
@@ -0,0 +1,7 @@
+{
+  "file": "037-persistent-json-buffer.md",
+  "title": "Persistent JSON buffer per reader",
+  "impact": "Eliminates syscall-class operations on the hot path",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/038.json b/experiments/index/038.json
new file mode 100644
index 00000000..79a11c3c
--- /dev/null
+++ b/experiments/index/038.json
@@ -0,0 +1,7 @@
+{
+  "file": "038-stack-alloc-col-names.md",
+  "title": "Stack allocation for column name arrays",
+  "impact": "Eliminates unnecessary heap allocations",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/039.json b/experiments/index/039.json
new file mode 100644
index 00000000..3e7fa7df
--- /dev/null
+++ b/experiments/index/039.json
@@ -0,0 +1,7 @@
+{
+  "file": "039-byte-size-sacrifice-threshold.md",
+  "title": "Byte-size sacrifice threshold",
+  "impact": "Better proxy for SendPort copy cost than cell count",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/040.json b/experiments/index/040.json
new file mode 100644
index 00000000..80557a50
--- /dev/null
+++ b/experiments/index/040.json
@@ -0,0 +1,7 @@
+{
+  "file": "040-reader-slot-event-port-cleanup.md",
+  "title": "Reader slot event-port cleanup",
+  "impact": "Simpler reader-worker protocol with a measured point-query and large-read win",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/041.json b/experiments/index/041.json
new file mode 100644
index 00000000..abf30b62
--- /dev/null
+++ b/experiments/index/041.json
@@ -0,0 +1,7 @@
+{
+  "file": "041-ryu-double-to-string.md",
+  "title": "Ryu double-to-string for JSON",
+  "impact": "Initially accepted but reverted after re-analysis: only -10% on one benchmark (text-heavy 1k rows) was actually attributable to 041; the claimed selectBytes wins were from 043. Not worth ~1500 lines of vendored third-party code + ~85-line format-compatibility wrapper",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/042.json b/experiments/index/042.json
new file mode 100644
index 00000000..33f46c89
--- /dev/null
+++ b/experiments/index/042.json
@@ -0,0 +1,7 @@
+{
+  "file": "042-lto-build-flag.md",
+  "title": "LTO build flag (`-flto`)",
+  "impact": "Four rounds tested (full, noinline, stacked, thin). Every config net negative — icache pressure from cross-unit inlining into the 250k-line SQLite amalgamation",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/043.json b/experiments/index/043.json
new file mode 100644
index 00000000..4f22e7c4
--- /dev/null
+++ b/experiments/index/043.json
@@ -0,0 +1,7 @@
+{
+  "file": "043-swar-escape-lookup-table.md",
+  "title": "SWAR escape scanning + lookup table",
+  "impact": "8-byte-at-a-time escape detection + lookup table eliminates branch chains in JSON strings",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/044.json b/experiments/index/044.json
new file mode 100644
index 00000000..166bcedc
--- /dev/null
+++ b/experiments/index/044.json
@@ -0,0 +1,7 @@
+{
+  "file": "044-batch-atomic-write.md",
+  "title": "`SQLITE_ENABLE_BATCH_ATOMIC_WRITE`",
+  "impact": "Zero-risk compile flag enabling 2-3x write speedup on Android F2FS",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/045.json b/experiments/index/045.json
new file mode 100644
index 00000000..f61f1486
--- /dev/null
+++ b/experiments/index/045.json
@@ -0,0 +1,7 @@
+{
+  "file": "045-microtask-invalidation-coalescing.md",
+  "title": "Microtask invalidation coalescing",
+  "impact": "Batches rapid sequential writes into a single invalidation pass per microtask",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/046.json b/experiments/index/046.json
new file mode 100644
index 00000000..db6ec46a
--- /dev/null
+++ b/experiments/index/046.json
@@ -0,0 +1,7 @@
+{
+  "file": "046-sync-stream-controller.md",
+  "title": "Synchronous StreamController",
+  "impact": "Reentrancy crash: sync delivery causes concurrent modification of subscriber list during iteration",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/047.json b/experiments/index/047.json
new file mode 100644
index 00000000..43dd732a
--- /dev/null
+++ b/experiments/index/047.json
@@ -0,0 +1,7 @@
+{
+  "file": "047-authorizer-opt-out.md",
+  "title": "Authorizer opt-out for non-stream queries",
+  "impact": "Shared statement cache stores empty dependency sets when tracking is off, breaking stream invalidation",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/051.json b/experiments/index/051.json
new file mode 100644
index 00000000..5170fb28
--- /dev/null
+++ b/experiments/index/051.json
@@ -0,0 +1,7 @@
+{
+  "file": "051-lock-free-reader-pool.md",
+  "title": "Lock-free reader pool with atomics",
+  "impact": "Mutex path is dead code since experiment 030 assigned dedicated readers; optimization target doesn't exist in the live path",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/052.json b/experiments/index/052.json
new file mode 100644
index 00000000..69975c66
--- /dev/null
+++ b/experiments/index/052.json
@@ -0,0 +1,7 @@
+{
+  "file": "052-column-level-dependencies.md",
+  "title": "Column-level dependency tracking",
+  "impact": "Sound architecture (skip re-queries on writes to non-watched columns), but current streaming benchmarks have 0% disjoint-column rate — benchmark-invisible",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/053.json b/experiments/index/053.json
new file mode 100644
index 00000000..d7421117
--- /dev/null
+++ b/experiments/index/053.json
@@ -0,0 +1,7 @@
+{
+  "file": "053-page-size-8192.md",
+  "title": "Page size 8192",
+  "impact": "-16% select at 10k rows on new DBs but breaks existing DBs (requires VACUUM); should be exposed as `Database.open` option, not default",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/054.json b/experiments/index/054.json
new file mode 100644
index 00000000..3f1d1bfe
--- /dev/null
+++ b/experiments/index/054.json
@@ -0,0 +1,7 @@
+{
+  "file": "054-pgo.md",
+  "title": "Profile-Guided Optimization",
+  "impact": "macOS dylib profraw flush doesn't fire from Dart VM host process; needs CI pipeline with standalone C binary",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/055.json b/experiments/index/055.json
new file mode 100644
index 00000000..3dfaa23f
--- /dev/null
+++ b/experiments/index/055.json
@@ -0,0 +1,7 @@
+{
+  "file": "055-columnar-typed-arrays.md",
+  "title": "Columnar typed arrays",
+  "impact": "Memory win confirmed (75% for numerics, 10000x fewer GC objects) but below time-based benchmark floor; requires memory profiling harness",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/057.json b/experiments/index/057.json
new file mode 100644
index 00000000..bbd2c083
--- /dev/null
+++ b/experiments/index/057.json
@@ -0,0 +1,7 @@
+{
+  "file": "057-preupdate-batching.md",
+  "title": "Preupdate hook batching for batch inserts",
+  "impact": "Savings (~2ms in 50ms batch) below noise floor",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/058.json b/experiments/index/058.json
new file mode 100644
index 00000000..f75af214
--- /dev/null
+++ b/experiments/index/058.json
@@ -0,0 +1,7 @@
+{
+  "file": "058-short-string-cache.md",
+  "title": "Short-string value cache",
+  "impact": "+134-256% regression. Dart's `String.fromCharCodes` is uncatchable with any Dart-level cache",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/059.json b/experiments/index/059.json
new file mode 100644
index 00000000..b4de4872
--- /dev/null
+++ b/experiments/index/059.json
@@ -0,0 +1,7 @@
+{
+  "file": "059-row-count-hint.md",
+  "title": "Row count hint in schema cache",
+  "impact": "Marginal wins (2/0/61) on repeated queries but below noise on primary paths",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/060.json b/experiments/index/060.json
new file mode 100644
index 00000000..12d2ef5f
--- /dev/null
+++ b/experiments/index/060.json
@@ -0,0 +1,7 @@
+{
+  "file": "060-combined-single-row-ffi.md",
+  "title": "Combined single-row FFI call",
+  "impact": "Text pointers invalidated by `sqlite3_reset` — required the inline-copy approach explored later",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/063.json b/experiments/index/063.json
new file mode 100644
index 00000000..e98ef9de
--- /dev/null
+++ b/experiments/index/063.json
@@ -0,0 +1,7 @@
+{
+  "file": "063-select-one-fast-path.md",
+  "title": "SelectOne fast path API",
+  "impact": "+28-48% point query win measured but rejected to preserve lean API surface",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/064.json b/experiments/index/064.json
new file mode 100644
index 00000000..6b6011b2
--- /dev/null
+++ b/experiments/index/064.json
@@ -0,0 +1,7 @@
+{
+  "file": "064-drop-clear-bindings.md",
+  "title": "Drop redundant `sqlite3_clear_bindings`",
+  "impact": "Provably-redundant call removed; simpler bind path with documented invariants",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/065.json b/experiments/index/065.json
new file mode 100644
index 00000000..b5944c14
--- /dev/null
+++ b/experiments/index/065.json
@@ -0,0 +1,7 @@
+{
+  "file": "065-json1-reevaluation.md",
+  "title": "JSON1 re-evaluation (post-041/043)",
+  "impact": "Our custom path now ≥ JSON1 everywhere; confirms 031 with larger margin",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/066.json b/experiments/index/066.json
new file mode 100644
index 00000000..73c7000a
--- /dev/null
+++ b/experiments/index/066.json
@@ -0,0 +1,7 @@
+{
+  "file": "066-transparent-fast-path.md",
+  "title": "Transparent single-row fast path in `select()`",
+  "impact": "Insufficient headroom — most of 063's win came from return-type change (`Map` vs `List<Map>`) which can't be captured transparently",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/067.json b/experiments/index/067.json
new file mode 100644
index 00000000..b9a97ea6
--- /dev/null
+++ b/experiments/index/067.json
@@ -0,0 +1,7 @@
+{
+  "file": "067-shrink-initial-allocation.md",
+  "title": "Shrink initial values allocation (256→4)",
+  "impact": "Caused +40-44% regressions; Dart VM has a fast path for `List.filled` that shrinking bypasses",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/068.json b/experiments/index/068.json
new file mode 100644
index 00000000..4382c398
--- /dev/null
+++ b/experiments/index/068.json
@@ -0,0 +1,7 @@
+{
+  "file": "068-ddl-schema-watchdog.md",
+  "title": "DDL schema_version watchdog",
+  "impact": "Deferred: initial implementation shipped + reverted after CI flakiness. Root cause is a C-level stmt cache race with SQLite's auto-reprepare — needs its own design pass to invalidate cached stmts on schema version bump",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/069.json b/experiments/index/069.json
new file mode 100644
index 00000000..2b02dc02
--- /dev/null
+++ b/experiments/index/069.json
@@ -0,0 +1,7 @@
+{
+  "file": "069-sql-fingerprint.md",
+  "title": "SQL fingerprint in stmt cache",
+  "impact": "Deferred: proper normalization needs a ~300+-line SQL rewriter; `sqlite3_normalized_sql` takes a prepared stmt as input, not raw SQL",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/070.json b/experiments/index/070.json
new file mode 100644
index 00000000..47d00885
--- /dev/null
+++ b/experiments/index/070.json
@@ -0,0 +1,7 @@
+{
+  "file": "070-zero-row-change-shortcircuit.md",
+  "title": "Zero-row-change short-circuit + persistent dirty buffer",
+  "impact": "Removes per-write calloc/free pair and short-circuits empty dirty set to a const empty list",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/071.json b/experiments/index/071.json
new file mode 100644
index 00000000..8b5ec140
--- /dev/null
+++ b/experiments/index/071.json
@@ -0,0 +1,7 @@
+{
+  "file": "071-stmt-cache-mru-scan.md",
+  "title": "MRU-first stmt cache scan + SQL hash filter",
+  "impact": "Structurally sound but unmeasurable: benchmark suite uses ≤ 10 distinct SQLs so the cache never stresses the scan path",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/072.json b/experiments/index/072.json
new file mode 100644
index 00000000..8c2489ba
--- /dev/null
+++ b/experiments/index/072.json
@@ -0,0 +1,7 @@
+{
+  "file": "072-xxhash-for-fnv.md",
+  "title": "xxhash64 replacing FNV-1a for result change detection",
+  "impact": "+75 % regression on stream invalidation: xxhash mergeRound is ~2× more ops than FNV's xor+mul, and our inputs are pre-hashed 64-bit values rather than byte streams (where xxhash wins)",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/073.json b/experiments/index/073.json
new file mode 100644
index 00000000..18e6e560
--- /dev/null
+++ b/experiments/index/073.json
@@ -0,0 +1,7 @@
+{
+  "file": "073-schema-cache-fast-path.md",
+  "title": "Single-slot schema-cache fast-path",
+  "impact": "Within noise: Dart's cached `String.hashCode` already makes map lookups fast enough that a one-slot bypass is below the measurement floor for the current suite",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/074.json b/experiments/index/074.json
new file mode 100644
index 00000000..514d05f7
--- /dev/null
+++ b/experiments/index/074.json
@@ -0,0 +1,7 @@
+{
+  "file": "074-bulk-step-many.md",
+  "title": "Bulk `step_many` batched FFI for read path",
+  "impact": "Same wall as exp 018: memcpy-in-C cost exceeds FFI-crossing savings. Text-heavy workloads regressed +38 %. Dart already reads directly from SQLite's text buffer; adding a C-side copy before Dart decode is strictly worse",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/075.json b/experiments/index/075.json
new file mode 100644
index 00000000..7b6f6789
--- /dev/null
+++ b/experiments/index/075.json
@@ -0,0 +1,7 @@
+{
+  "file": "075-native-hash-selectifchanged.md",
+  "title": "Native-buffered hash for `selectIfChanged`",
+  "impact": "**−39 % on unchanged-fanout benchmark**. Worker-side C hash (`resqlite_query_hash`) short-circuits stream re-queries before any Dart decode when the result is unchanged",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/076.json b/experiments/index/076.json
new file mode 100644
index 00000000..6f124f9b
--- /dev/null
+++ b/experiments/index/076.json
@@ -0,0 +1,7 @@
+{
+  "file": "076-prebound-stmt-cache-analysis.md",
+  "title": "Pre-bound statement cache",
+  "impact": "Rejected in pre-implementation analysis: bind is ~0.3 % of re-query wall time (~50 ns per call). No measurable headroom even for a perfect implementation",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/077.json b/experiments/index/077.json
new file mode 100644
index 00000000..48731250
--- /dev/null
+++ b/experiments/index/077.json
@@ -0,0 +1,7 @@
+{
+  "file": "077-cheap-check-first-sweep.md",
+  "title": "Cheap-check-first sweep (four small wins)",
+  "impact": "**−13 % to −23 % on write benchmarks** from cached `sqlite3_bind_parameter_count`; pairs with three correctness-neutral fast-rejects on invalidation, hash, and subscription paths",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/081.json b/experiments/index/081.json
new file mode 100644
index 00000000..e7bf9f9f
--- /dev/null
+++ b/experiments/index/081.json
@@ -0,0 +1,7 @@
+{
+  "file": "081-binary-row-result-storage.md",
+  "title": "Binary row result storage",
+  "impact": "Transfer-side numeric scan wins collapsed once full main-isolate row consumption was measured; mixed rows regressed and point-query floor worsened",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/082.json b/experiments/index/082.json
new file mode 100644
index 00000000..80d8fc74
--- /dev/null
+++ b/experiments/index/082.json
@@ -0,0 +1,7 @@
+{
+  "file": "082-message-graph-handoff.md",
+  "title": "Message-graph hand-off benchmark",
+  "impact": "Current `ResultSet` / `Row` shape is already near-optimal for the shipped `select()` contract; materialized maps and binary row facades both lose on end-to-end total",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/083.json b/experiments/index/083.json
new file mode 100644
index 00000000..e21297d0
--- /dev/null
+++ b/experiments/index/083.json
@@ -0,0 +1,7 @@
+{
+  "file": "083-stream-rerun-pre-dispatch-queue.md",
+  "title": "Stream rerun pre-dispatch queue",
+  "impact": "Eliminates the measured `A11` / `A11b` reader-pool wait bottleneck by coalescing reruns before pool admission",
+  "status": "in_review",
+  "link": "[#25](https://github.com/danReynolds/resqlite/pull/25)"
+}
diff --git a/experiments/index/084.json b/experiments/index/084.json
new file mode 100644
index 00000000..c3cd4330
--- /dev/null
+++ b/experiments/index/084.json
@@ -0,0 +1,7 @@
+{
+  "file": "084-late-dispatch-generation-stamp.md",
+  "title": "Late dispatch generation stamp",
+  "impact": "Real partial improvement, but materially weaker than 083 because reruns still pile up inside `ReaderPool`",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/085.json b/experiments/index/085.json
new file mode 100644
index 00000000..171781e0
--- /dev/null
+++ b/experiments/index/085.json
@@ -0,0 +1,7 @@
+{
+  "file": "085-reserved-reader-slot-for-reruns.md",
+  "title": "Reserved reader slot for reruns",
+  "impact": "The queue is the real source of the `A11` / `A11b` win; removing the reserved reader regressed broader workload balance, especially `A7`",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/088.json b/experiments/index/088.json
new file mode 100644
index 00000000..45015220
--- /dev/null
+++ b/experiments/index/088.json
@@ -0,0 +1,7 @@
+{
+  "file": "088-setlk-timeout.md",
+  "title": "`SQLITE_ENABLE_SETLK_TIMEOUT` + `sqlite3_setlk_timeout` on every connection",
+  "impact": "Downgraded from Accepted after 5-run confirmation: original single-run p99/max wins were noise (baseline outlier that never reproduced). Multi-run median shows p99 +74 % to +172 % worse and max +29 % to +529 % worse on writes; noop regresses even though it has no lock contention. Needs a concurrent-reader harness + shorter timeout to be evaluable",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/089.json b/experiments/index/089.json
new file mode 100644
index 00000000..a476c2c6
--- /dev/null
+++ b/experiments/index/089.json
@@ -0,0 +1,7 @@
+{
+  "file": "089-deeply-immutable-resultset.md",
+  "title": "Deeply-immutable `ResultSet` for zero-copy isolate transfer",
+  "impact": "Blocked upstream: Dart's `@pragma('vm:deeply-immutable')` requires all fields to be in a closed set that excludes `List<T>`, `Uint8List`, and any typed data. `ResultSet` / `RawQueryResult` are `List<Object?>`-centered and BLOB cells are `Uint8List`. Re-check when SDK #50068 (DI typed-data factory) ships",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/090.json b/experiments/index/090.json
new file mode 100644
index 00000000..ba5aaf6c
--- /dev/null
+++ b/experiments/index/090.json
@@ -0,0 +1,7 @@
+{
+  "file": "090-sqlite3mc-bump-audit.md",
+  "title": "sqlite3mc dependency bump audit",
+  "impact": "No bump needed — we are already on the newest stable sqlite3mc (2.3.2 / SQLite 3.51.3, 37 days old). The only newer target (3.53.0) is a 12-day-old .0 release excluded by our known-regressions policy, and its changelog shows no hot-path wins. Revisit when 3.53.2+ ships",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/092.json b/experiments/index/092.json
new file mode 100644
index 00000000..5fe1e000
--- /dev/null
+++ b/experiments/index/092.json
@@ -0,0 +1,7 @@
+{
+  "file": "092-wal-checkpoint-noop.md",
+  "title": "`wal_checkpoint=NOOP` probe in periodic checkpointer",
+  "impact": "Premise invalid — exp-029 is hook-gated on `pages_in_wal`, not timer-gated. NOOP exists to report the frame counter the wal-hook already receives; adding NOOP would be a strictly additive header read with no empty-tick cost to amortize",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/093.json b/experiments/index/093.json
new file mode 100644
index 00000000..89d68c69
--- /dev/null
+++ b/experiments/index/093.json
@@ -0,0 +1,7 @@
+{
+  "file": "093-alias-cache-entry-read-tables.md",
+  "title": "Alias cache entry's read tables instead of copying",
+  "impact": "Below the measurement floor — savings ceiling was one `strdup`/`free` pair per cached table name per reader query (~hundreds of ns on a 1–3 table query). Work medians unchanged in 3-run A/B; tail regressions pattern-matched run-to-run variance (`noop` regressed as much as `point_query`, but `noop` never touches the changed path). Same class as exp 076",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/094.json b/experiments/index/094.json
new file mode 100644
index 00000000..d2255358
--- /dev/null
+++ b/experiments/index/094.json
@@ -0,0 +1,7 @@
+{
+  "file": "094-dirty-read-string-reuse.md",
+  "title": "Dirty/read table string reuse",
+  "impact": "Focused dispatch was effectively flat and the full suite produced no wins; native branch/lifetime complexity is not justified",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/095.json b/experiments/index/095.json
new file mode 100644
index 00000000..fe7cc3a6
--- /dev/null
+++ b/experiments/index/095.json
@@ -0,0 +1,7 @@
+{
+  "file": "095-writer-result-buffer.md",
+  "title": "Persistent writer result buffer",
+  "impact": "The removable 16-byte calloc/free pair did not produce reliable write-path wins",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/096.json b/experiments/index/096.json
new file mode 100644
index 00000000..152bc34a
--- /dev/null
+++ b/experiments/index/096.json
@@ -0,0 +1,7 @@
+{
+  "file": "096-direct-batch-param-encoding.md",
+  "title": "Direct batch parameter encoding",
+  "impact": "Large batch medians only trended down; no accepted-level harness win and too much duplicate parameter-encoding code",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/097.json b/experiments/index/097.json
new file mode 100644
index 00000000..67d0b7d2
--- /dev/null
+++ b/experiments/index/097.json
@@ -0,0 +1,7 @@
+{
+  "file": "097-one-pass-initial-stream-hash.md",
+  "title": "One-pass initial stream decode and hash",
+  "impact": "14-16% faster setup-heavy streaming benchmarks by avoiding the initial stream query replay",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/099.json b/experiments/index/099.json
new file mode 100644
index 00000000..98b4e11d
--- /dev/null
+++ b/experiments/index/099.json
@@ -0,0 +1,7 @@
+{
+  "file": "099-fnv-8byte-bytestream.md",
+  "title": "8-byte-chunked FNV for byte-stream cells",
+  "impact": "Structurally sound (folds 8 bytes per multiply on the long-text hash path) but benchmark-invisible — current streaming workloads carry only short cells (≤ 3–8 bytes) that bypass the new main loop. Same class as exp 071. Revisit when a long-text streaming benchmark exists",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/100.json b/experiments/index/100.json
new file mode 100644
index 00000000..12732636
--- /dev/null
+++ b/experiments/index/100.json
@@ -0,0 +1,7 @@
+{
+  "file": "100-bounded-stream-requery-scheduler.md",
+  "title": "Bounded stream re-query scheduler",
+  "impact": "Did not improve unrelated reads during fan-out and regressed high-cardinality stream fan-out by 103%",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/101.json b/experiments/index/101.json
new file mode 100644
index 00000000..b864b608
--- /dev/null
+++ b/experiments/index/101.json
@@ -0,0 +1,7 @@
+{
+  "file": "101-tx-stmt-cache.md",
+  "title": "Cached BEGIN/COMMIT/ROLLBACK statements",
+  "impact": "**−13 % to −14 %** on Batched-Write-Inside-Transaction and Growing-Stream Invalidation by replacing `sqlite3_exec`'s per-call prepare+finalize with three persistently prepared transaction-control stmts",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/102.json b/experiments/index/102.json
new file mode 100644
index 00000000..11aa8e48
--- /dev/null
+++ b/experiments/index/102.json
@@ -0,0 +1,7 @@
+{
+  "file": "102-savepoint-string-cache.md",
+  "title": "Cached SAVEPOINT/RELEASE/ROLLBACK TO strings on `_WriterState`",
+  "impact": "Theoretically removes per-nested-tx `toNativeUtf8` + `calloc.free` pair, but the benchmark suite has no nested-transaction workload — no directly attributable signal, only run-to-run drift on unrelated read paths. Pattern-matches exp 095. Revisit if a deeply-nested-tx benchmark exists",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/103.json b/experiments/index/103.json
new file mode 100644
index 00000000..eafeac11
--- /dev/null
+++ b/experiments/index/103.json
@@ -0,0 +1,7 @@
+{
+  "file": "103-native-nested-tx-depth-control.md",
+  "title": "Native nested transaction depth control",
+  "impact": "Focused nested-tx benchmark showed at best a small savepoint-only improvement; realistic nested write cases were flat or worse, so extra native API surface is not justified",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/104.json b/experiments/index/104.json
new file mode 100644
index 00000000..556500b3
--- /dev/null
+++ b/experiments/index/104.json
@@ -0,0 +1,7 @@
+{
+  "file": "104-094-reeval-under-a11c.md",
+  "title": "Re-eval of exp 094 (dirty/read string reuse) under A11c",
+  "impact": "Even under A11c fan-out (~50× amplification of read-set/dirty-set add traffic), deltas were within noise on every workload the change targets (disjoint +4%, overlap −2%, concurrent reads ±10% — all inside MDE_ci). Empirically validates 094's original \"below noise floor\" rejection.",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/105.json b/experiments/index/105.json
new file mode 100644
index 00000000..6b4d80d9
--- /dev/null
+++ b/experiments/index/105.json
@@ -0,0 +1,7 @@
+{
+  "file": "105-reader-pool-sizing.md",
+  "title": "Raise reader pool worker cap (4→8)",
+  "impact": "Regressed A11c writer throughput by ~31% under N=50 stream fan-out; the profile's reader-pool serialization bottleneck was actually throttling completion-side microtask churn. Cap=4 is correctly tuned.",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/106.json b/experiments/index/106.json
new file mode 100644
index 00000000..16ff9826
--- /dev/null
+++ b/experiments/index/106.json
@@ -0,0 +1,7 @@
+{
+  "file": "106-column-level-deps.md",
+  "title": "Column-level dependency tracking (re-attempt of 052 under A11c)",
+  "impact": "**+82 %** on A11c disjoint writer throughput (3,956 → 7,201 w/s); overlap unchanged (4,477 → 4,581 w/s); overlap/disjoint ratio drops 1.132 → 0.636, the direct signature of writer-side dispatch elision",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/108.json b/experiments/index/108.json
new file mode 100644
index 00000000..2b010443
--- /dev/null
+++ b/experiments/index/108.json
@@ -0,0 +1,7 @@
+{
+  "file": "108-selectbytes-out-slots.md",
+  "title": "Persistent selectBytes out-parameter slots",
+  "impact": "Target selectBytes benchmarks stayed within noise, and memory/rss flags removed any case for permanent native scratch state",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/109.json b/experiments/index/109.json
new file mode 100644
index 00000000..46225e52
--- /dev/null
+++ b/experiments/index/109.json
@@ -0,0 +1,7 @@
+{
+  "file": "109-inline-param-buffer.md",
+  "title": "Inline-packed parameter buffer",
+  "impact": "**−10 % to −16 %** on text-param INSERT workloads (Single Inserts, Batch Insert, No-Streams Write Throughput) by collapsing per-text/blob `calloc` into the reusable param-struct buffer and passing actual UTF-8 byte length so `sqlite3_bind_text` skips its internal `strlen`",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/110.json b/experiments/index/110.json
new file mode 100644
index 00000000..72b74971
--- /dev/null
+++ b/experiments/index/110.json
@@ -0,0 +1,7 @@
+{
+  "file": "110-long-text-fnv-8byte.md",
+  "title": "Long-text stream hash benchmark + 8-byte FNV",
+  "impact": "Adds a long-text unchanged-fanout benchmark and cuts its median latency by 76% with chunked byte-stream hashing",
+  "status": "in_review",
+  "link": "[#53](https://github.com/danReynolds/resqlite/pull/53)"
+}
diff --git a/experiments/index/111.json b/experiments/index/111.json
new file mode 100644
index 00000000..0b2c304a
--- /dev/null
+++ b/experiments/index/111.json
@@ -0,0 +1,7 @@
+{
+  "file": "111-nested-tx-benchmark-savepoint-cache.md",
+  "title": "Nested-tx benchmark + revisit savepoint string cache",
+  "impact": "Built the missing nested-transaction workload (shipped) and re-tested exp 102's archived cached-savepoint-string pattern against it. Even on the worst-case 50×-shallow-fan-out shape the cache landed at -9 % (below the ±17 % decision threshold); deep-5-chain was flat. Confirms exp 102 across a maximally stressing workload — per-isolate-round-trip cost dominates per-call savepoint allocations",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/112.json b/experiments/index/112.json
new file mode 100644
index 00000000..3577ca1d
--- /dev/null
+++ b/experiments/index/112.json
@@ -0,0 +1,7 @@
+{
+  "file": "112-fixed-length-batch-param-flatten.md",
+  "title": "Fixed-length batch parameter flattening",
+  "impact": "Focused benchmark medians overlapped after repeated A/B passes; any large-batch improvement was below the current decision threshold, so the simpler growable-list flattening stays",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/113.json b/experiments/index/113.json
new file mode 100644
index 00000000..83ea61bf
--- /dev/null
+++ b/experiments/index/113.json
@@ -0,0 +1,7 @@
+{
+  "file": "113-direct-batch-param-matrix.md",
+  "title": "Direct batch parameter matrix encoding",
+  "impact": "Avoids the temporary flat Dart parameter list; 10k-row wide batches improve 14-26% in the focused benchmark",
+  "status": "in_review",
+  "link": "[#70](https://github.com/danReynolds/resqlite/pull/70)"
+}
diff --git a/experiments/index/114.json b/experiments/index/114.json
new file mode 100644
index 00000000..f4b273f3
--- /dev/null
+++ b/experiments/index/114.json
@@ -0,0 +1,7 @@
+{
+  "file": "114-fifo-waiter-queue.md",
+  "title": "FIFO waiter queue for `ReaderPool` dispatch",
+  "impact": "First A/B pass (against pre-exp-106 baseline) showed −10 % to −32 % on streaming fan-out paths; rebasing onto main with exp 106 polish merged collapsed all targeted wins into noise. Exp 106 elides stream re-queries on the writer side before they reach the reader pool, so the parked-dispatcher contention this change targeted no longer fires under any release-suite workload. Implementation reverted; doc + benchmark artifacts retained as the durable record. Cherry-pickable from PR git history if a workload re-introduces sustained pool parking",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/115.json b/experiments/index/115.json
new file mode 100644
index 00000000..af43e400
--- /dev/null
+++ b/experiments/index/115.json
@@ -0,0 +1,7 @@
+{
+  "file": "115-dispatcher-park-counters.md",
+  "title": "Dispatcher park counters for `ReaderPool`",
+  "impact": "Measurement-only: profile-mode counters (park-total, wake-retry-total, max-parked-concurrent) that quantify the parked-dispatcher path exp 105 / exp 114 targeted indirectly. Wake-retry/park ratio reaches 93 % at concurrency=32 (pool=4), the direct wake-amplification signal. Tree-shaken from release builds. Unblocks future dispatch-area experiments with a non-wall-time evaluation gate",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/116.json b/experiments/index/116.json
new file mode 100644
index 00000000..0b40fe8c
--- /dev/null
+++ b/experiments/index/116.json
@@ -0,0 +1,7 @@
+{
+  "file": "116-wide-batch-release-coverage.md",
+  "title": "Wide batch insert release coverage",
+  "impact": "Adds a 10k-row x 20-parameter mixed-type batch insert to the release write suite so parameter-width regressions are visible on the public benchmark path",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/117.json b/experiments/index/117.json
new file mode 100644
index 00000000..2b12a92a
--- /dev/null
+++ b/experiments/index/117.json
@@ -0,0 +1,7 @@
+{
+  "file": "117-named-parameters.md",
+  "title": "Named parameter support (`Map<String, Object?>`)",
+  "impact": "Functionally complete and correct; 5-run focused harness showed wide-batch within noise (+2.7%). Deferred for v0.x launch: 12K-LOC change touching the entire write path for an ergonomics nice-to-have, with 6/7 write-path benchmarks trending slightly slower (monotonic direction = weaker than independent noise). Reopen if (a) community feedback shows named params are a real adoption barrier and a 5-run release suite confirms neutral, or (b) someone redesigns dispatch as two top-level branches in `run_batch_locked` instead of per-row inline dispatch. Implementation lives on the `exp-117-named-parameters` branch.",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/118.json b/experiments/index/118.json
new file mode 100644
index 00000000..41c9f3e3
--- /dev/null
+++ b/experiments/index/118.json
@@ -0,0 +1,7 @@
+{
+  "file": "118-fifo-dispatch-counter-gate.md",
+  "title": "FIFO dispatch waiters with counter gate",
+  "impact": "Replaces the shared reader-pool dispatch completer with FIFO one-shot waiters; exp 115 counters show wake retries drop to zero under overload",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/119.json b/experiments/index/119.json
new file mode 100644
index 00000000..4f06b4a1
--- /dev/null
+++ b/experiments/index/119.json
@@ -0,0 +1,7 @@
+{
+  "file": "119-dispatch-pressure-audit.md",
+  "title": "Post-FIFO dispatch pressure audit",
+  "impact": "Profile audit shows wake retries stay zero after FIFO, while A11c overlap and keyed-PK streams still produce parked dispatchers; next dispatch work should target stream admission/completion",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/120.json b/experiments/index/120.json
new file mode 100644
index 00000000..3d53af0f
--- /dev/null
+++ b/experiments/index/120.json
@@ -0,0 +1,7 @@
+{
+  "file": "120-flush-admit-bound.md",
+  "title": "Bounded `_flushQueue` admission",
+  "impact": "Cap stream re-query admission at `ReaderPool.availableWorkerCount` per call so synchronous over-dispatch can no longer pile up against `_dispatchWaiters`. `dispatcherParkedTotal` drops from 3,590 → 0 (A11c overlap) and 1,198 → 0 (keyed-PK); `max_parked` 46 → 0. Release suite: 9 wins, 0 regressions, including neutral high-cardinality fan-out (the exp-100 killer)",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/121.json b/experiments/index/121.json
new file mode 100644
index 00000000..34b24048
--- /dev/null
+++ b/experiments/index/121.json
@@ -0,0 +1,7 @@
+{
+  "file": "121-invalidation-traversal-audit.md",
+  "title": "Invalidation traversal cost audit",
+  "impact": "Measurement-only: profile-mode harness reports `invalidate_us` / `intersection_us` as a fraction of writer-side burst wall on A11c (baseline / disjoint / overlap) and keyed-PK. Overlap invalidation is 10–15% of wall (column intersection 2.5–5.7%); keyed-PK 13–14% (intersection ~4%); disjoint 22–23% only because column elision shrinks the denominator. Per-entry intersection probes are 80–200 ns. Extracts shared `audit_workloads.dart` so this audit and exp 119 stay structurally comparable. Removes invalidation traversal from the active candidate list — the structural ceiling on smarter dependency tracking is ~3 ms / 25k probes per overlap burst",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/122.json b/experiments/index/122.json
new file mode 100644
index 00000000..c7e36386
--- /dev/null
+++ b/experiments/index/122.json
@@ -0,0 +1,7 @@
+{
+  "file": "122-concrete-reader-pool-stream-admission.md",
+  "title": "Concrete reader-pool stream admission",
+  "impact": "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",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/125.json b/experiments/index/125.json
new file mode 100644
index 00000000..eaa05f51
--- /dev/null
+++ b/experiments/index/125.json
@@ -0,0 +1,7 @@
+{
+  "file": "125-wide-ascii-batch-params.md",
+  "title": "Wide ASCII batch parameter encoding",
+  "impact": "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",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/126.json b/experiments/index/126.json
new file mode 100644
index 00000000..e733ba23
--- /dev/null
+++ b/experiments/index/126.json
@@ -0,0 +1,7 @@
+{
+  "file": "126-wide-utf8-batch-packing.md",
+  "title": "Wide UTF-8 batch parameter packing",
+  "impact": "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",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/134.json b/experiments/index/134.json
new file mode 100644
index 00000000..384f127e
--- /dev/null
+++ b/experiments/index/134.json
@@ -0,0 +1,7 @@
+{
+  "file": "134-keyed-pk-dirty-elision.md",
+  "title": "Keyed PK dirty rowid elision",
+  "impact": "Profile proof was real (keyed-PK writer-burst wall 25.54 → 12.45 ms; probes 10,000 → 3), but the mergeable implementation depended on internal SQL text recognition for `WHERE id = ?`. Keep as future evidence for explicit row-level observer APIs or a stronger dependency model; implementation preserved at `archive/exp-134`.",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/136.json b/experiments/index/136.json
new file mode 100644
index 00000000..7103e3ee
--- /dev/null
+++ b/experiments/index/136.json
@@ -0,0 +1,7 @@
+{
+  "file": "136-completion-microtask-counter.md",
+  "title": "Completion-side reader-handler counter",
+  "impact": "Measurement-only: profile-mode counters (`completion_handler_us`, `stream_emit_us`) expose the main-isolate reader worker port handler chain on A11c overlap as 28.57% of total wall (burst + drain) at ~18 µs per call across 4,228 calls/burst, with subscriber emit only 0.35% of the chain. Reader-reply batching is the natural bounded implementation candidate. Closes the `completion-side microtask scheduling cost counter` entry in `signals.json#stream-rerun-dispatch.blockedOnMeasurement`",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/142.json b/experiments/index/142.json
new file mode 100644
index 00000000..12ea9af2
--- /dev/null
+++ b/experiments/index/142.json
@@ -0,0 +1,7 @@
+{
+  "file": "142-single-row-text-direct-encoding.md",
+  "title": "Single-row text parameter direct encoding",
+  "impact": "Tracelite retest over `chat-sim` and `narrow-batch-insert` did not clear the primary gate: resqlite changed +6.86% and +16.4% with neutral/inconclusive verdicts. Do not carry the `allocateParams` direct UTF-8 path unless a future workload shows single-row string binding is material.",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/143.json b/experiments/index/143.json
new file mode 100644
index 00000000..fe368a11
--- /dev/null
+++ b/experiments/index/143.json
@@ -0,0 +1,7 @@
+{
+  "file": "143-tracelite-profile-insights.md",
+  "title": "Tracelite profile insight audit",
+  "impact": "Measurement-only: pinned Tracelite profile runs show stable dispatch floors (reader 12 us, writer 16 us), point queries at the dispatch floor, merge rounds with 77 us of floor-subtracted work, and memory/allocation signal that wall time alone hides; current `tracelite explain` only reports coverage, so richer workload-summary insight rules are the next measurement-system improvement",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/144.json b/experiments/index/144.json
new file mode 100644
index 00000000..19b96e31
--- /dev/null
+++ b/experiments/index/144.json
@@ -0,0 +1,7 @@
+{
+  "file": "144-sqlite3mc-bump-2-3-5.md",
+  "title": "sqlite3mc 2.3.2 → 2.3.5 bump (SQLite 3.51.3 → 3.53.2)",
+  "impact": "Satisfies exp 090's revisit trigger (SQLite `.2`+ point release with sqlite3mc tracking it); tests stay green including embedded-NUL + Unicode bind regression suite; release-suite single-pass A/Bs swing between 19/18/124 and 30/2/129 — Concurrent Reads 8× is the only metric that flags consistently across reruns (+~20% on a sub-ms metric) and is the focus of the soak window; FP-rounding hazard skipped because resqlite never serialises REAL via `sqlite3_column_text`",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/145.json b/experiments/index/145.json
new file mode 100644
index 00000000..19eb4c65
--- /dev/null
+++ b/experiments/index/145.json
@@ -0,0 +1,7 @@
+{
+  "file": "145-stream-flush-inline-dequeue.md",
+  "title": "Inline stream flush dequeue",
+  "impact": "Replacing `_flushQueue`'s `take(...).toList()` dequeue and `availableWorkerCount`'s `where(...).length` with inline loops kept dispatch counters at zero but produced mixed wall-time signal: A11c overlap trended better, keyed-PK trended worse, and the active stream bottleneck remained elsewhere. No runtime code kept.",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/146.json b/experiments/index/146.json
new file mode 100644
index 00000000..38869aa1
--- /dev/null
+++ b/experiments/index/146.json
@@ -0,0 +1,7 @@
+{
+  "file": "146-lower-batch-pack-threshold.md",
+  "title": "Lower batch packing threshold",
+  "impact": "Tracelite A/B run over `narrow-batch-insert` collected clean baseline and candidate histories but produced no primary improvement: resqlite changed +1.45% with neutral verdict, while the sqlite_async guardrail was too noisy. Keep the exp 125 large-wide-batch guard; small/narrow batches stay generic until a new workload proves parameter encoding is material.",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/147.json b/experiments/index/147.json
new file mode 100644
index 00000000..ea8e2cb3
--- /dev/null
+++ b/experiments/index/147.json
@@ -0,0 +1,7 @@
+{
+  "file": "147-writer-sqlite-wall-split.md",
+  "title": "Writer SQLite wall split",
+  "impact": "Measurement-only: profile-mode writer responses now report SQLite-facing write time back into `ProfileCounters`; on A11c overlap, SQLite is 15.7 ms / 166.8 ms (9.4%), invalidation is 18.8%, and residual writer/request wall is 71.8%. Keyed-PK shows the same shape (18.1% SQLite, 18.7% invalidation, 63.3% residual). Clears the writer-wall-vs-SQLite-wall blocker; next stream work should reduce completion/reply scheduling or residual writer/request wall rather than SQLite-step tuning",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/148.json b/experiments/index/148.json
new file mode 100644
index 00000000..534c7ffc
--- /dev/null
+++ b/experiments/index/148.json
@@ -0,0 +1,7 @@
+{
+  "file": "148-reader-reply-batching.md",
+  "title": "Reader reply batching",
+  "impact": "Batching stream re-query replies reduced the exp 136 completion counter in a profile smoke (A11c overlap completion callbacks 4,527 → 1,425, completion wall 109.6 ms → 55.6 ms), but the formal Tracelite stream-dispatch A/B did not produce a measured-elapsed win. High-cardinality fanout changed +5.18%, many-streams writer throughput +3.28%, and keyed-PK subscriptions +13.5%. Do not merge worker-side reader-reply batching without a workload that turns the callback reduction into end-to-end wall improvement.",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/149.json b/experiments/index/149.json
new file mode 100644
index 00000000..5513b014
--- /dev/null
+++ b/experiments/index/149.json
@@ -0,0 +1,7 @@
+{
+  "file": "149-six-param-batch-packing.md",
+  "title": "Six-parameter batch packing",
+  "impact": "Lowers the guarded ASCII batch-packing threshold to the Tracelite merge-round shape; profile `merge_rounds` improves executeBatch p50 88 → 75 us and writer SQLite time 87,895 → 75,947 us while keeping 2-3 parameter batches generic",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/150.json b/experiments/index/150.json
new file mode 100644
index 00000000..1a6968d1
--- /dev/null
+++ b/experiments/index/150.json
@@ -0,0 +1,7 @@
+{
+  "file": "150-nullable-batch-packing.md",
+  "title": "Nullable batch parameter packing",
+  "impact": "Makes the guarded packed batch encoder nullable-aware for first-row `NULL` text columns; focused nullable ASCII 10k x8 improves 13.552 → 11.152 ms and 10k x20 improves 25.738 → 21.723 ms while existing ASCII/Unicode wide guardrails stay neutral",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/151.json b/experiments/index/151.json
new file mode 100644
index 00000000..05493f9c
--- /dev/null
+++ b/experiments/index/151.json
@@ -0,0 +1,7 @@
+{
+  "file": "151-sync-writer-response.md",
+  "title": "Synchronous writer response resolution",
+  "impact": "Switching writer response futures to `Completer<T>.sync()` was a concrete request-resolution attempt against exp 147's residual writer/request bucket, but the formal Tracelite stream-dispatch A/B did not clear the primary gate. High-cardinality fanout changed +2.92%, keyed-PK subscriptions changed +18.5% with too-noisy evidence, and many-streams writer throughput changed +14.0%. No runtime code kept.",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/158.json b/experiments/index/158.json
new file mode 100644
index 00000000..eee5da90
--- /dev/null
+++ b/experiments/index/158.json
@@ -0,0 +1,7 @@
+{
+  "file": "158-row-schema-hash-index.md",
+  "title": "Row schema hash index",
+  "impact": "Adds a schema-name identity fast path for schemas up to 32 columns plus private `HashMap` fallback for `RowSchema` lookup; focused `select_maps` main-isolate consumption improved 0.169 → 0.081 ms at 1K rows and 1.998 → 0.967 ms at 10K rows while point-query throughput stayed neutral/noisy",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/159.json b/experiments/index/159.json
new file mode 100644
index 00000000..c5da0aba
--- /dev/null
+++ b/experiments/index/159.json
@@ -0,0 +1,7 @@
+{
+  "file": "159-writer-pipelining.md",
+  "title": "Writer request pipelining + persistent reply port",
+  "impact": "**−36% to −45%** on concurrent standalone writes (new focused burst benchmark) by holding the write lock only across the send and letting the worker's port FIFO pipeline requests; persistent reply port + cached SendPort + sync completers remove a port allocate/register/close cycle and two scheduling hops from every write round-trip. Stream-dispatch Tracelite guardrails neutral on the clean order-flipped pass; exp 147 `residual_us` drops on all four audit workloads",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/161.json b/experiments/index/161.json
new file mode 100644
index 00000000..34f56754
--- /dev/null
+++ b/experiments/index/161.json
@@ -0,0 +1,7 @@
+{
+  "file": "161-concurrent-writes-release-coverage.md",
+  "title": "Concurrent standalone writes release coverage",
+  "impact": "Promotes the exp 159 send-gated writer-lock pipelining shape into release write suite coverage with a paired Single Inserts (100 sequential) / Concurrent Single Inserts (100 concurrent) row pair; resqlite concurrent median drops from ~2.9 ms to ~1.1 ms on the new lane (−58% to −61%) while sequential, batch, wide batch, and transaction rows stay untouched. Makes future writer-scheduling experiments evaluable on a public release lane without relying on the focused `writer_pipelining.dart` script",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/164.json b/experiments/index/164.json
new file mode 100644
index 00000000..0809b6db
--- /dev/null
+++ b/experiments/index/164.json
@@ -0,0 +1,7 @@
+{
+  "file": "164-eqp-rowid-dirty-elision.md",
+  "title": "EQP rowid dirty elision",
+  "impact": "Replaced exp 134's custom SQL recognizer with SQLite `EXPLAIN QUERY PLAN` plus native dirty-row harvesting and a private plan cache, but the focused Tracelite initial-drain lane stayed neutral/inconclusive (`stream-initial-drain-rowid` -2.33%) and broader stream guardrails did not produce a stable keyed-PK win. No runtime code kept; implementation preserved at `archive/exp-164`.",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/167.json b/experiments/index/167.json
new file mode 100644
index 00000000..256924ab
--- /dev/null
+++ b/experiments/index/167.json
@@ -0,0 +1,7 @@
+{
+  "file": "167-resultset-foreach-consumer.md",
+  "title": "ResultSet.forEach consumer recheck",
+  "impact": "Re-tested closed exp 141 after exp 158 on a real SQLite-backed consumer lane. The one-method `ResultSet.forEach` override had no stable current win: Pair A `forEach lookup` improved 30.525 -> 28.383 ms, but the longer confirmation reversed to 28.563 -> 30.942 ms, and `forEach length` also reversed. No runtime code kept; the focused benchmark remains for future result-shape rechecks.",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/169.json b/experiments/index/169.json
new file mode 100644
index 00000000..67269ace
--- /dev/null
+++ b/experiments/index/169.json
@@ -0,0 +1,7 @@
+{
+  "file": "169-tracelite-workload-insights.md",
+  "title": "Tracelite workload-summary insight guard",
+  "impact": "Adds a Resqlite-side validation step to `benchmark/profile/run_tracelite_profile.dart` so canonical profile runs fail if `tracelite explain` regresses to coverage-only output. The validated profile emitted dispatch floors, dispatch-bound point queries, work-bound merge rounds, tail spread, RSS, allocation, and WAL insight IDs; thin `workload_loaded` fixtures now fail locally",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/170.json b/experiments/index/170.json
new file mode 100644
index 00000000..038f0b7b
--- /dev/null
+++ b/experiments/index/170.json
@@ -0,0 +1,7 @@
+{
+  "file": "170-uncontended-mutex-fastpath.md",
+  "title": "Synchronous uncontended writer mutex fast-path",
+  "impact": "`Mutex.tryLock()` plus a non-`async` `Writer.execute` / `executeBatch` were a concrete request-scheduling attempt against exp 147's residual writer/request bucket. Paired focused + release runs showed the primary `sequential-awaited` / Single Inserts lanes within ±2 % (wrong direction), only Concurrent Single Inserts moved by −7.8 % — a lane exp 159 already drives at −58 % to −61 %. Sub-decision-threshold gain doesn't justify adding a slow-path branch plus the behavior change of sync-before-close writes no longer being rejected. No runtime code kept.",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/171.json b/experiments/index/171.json
new file mode 100644
index 00000000..9a1ac996
--- /dev/null
+++ b/experiments/index/171.json
@@ -0,0 +1,7 @@
+{
+  "file": "171-resolved-runtime-cache.md",
+  "title": "Resolved runtime cache for `Database` hot paths",
+  "impact": "Mirrored exp 159's `_sendPort` cache one layer up: a sync-readable `_resolvedRuntime` field on `Database` so post-open `select`/`execute`/`executeBatch`/`transaction` skip the `await _runtime` microtask hop. Two order-flipped passes on `writer_pipelining.dart` produced alternating-sign deltas inside per-round variance (sequential-awaited −2.3% / +2.5%, transaction-guardrail −7.5% / +6.1%, concurrent-burst +4–5% both passes). The theoretical ~1–2 µs/call saving sits at or below the focused-harness floor. No runtime code kept; exp 159's \"the residual is the round-trip floor itself; further reduction needs group commit or a different transport\" framing stands.",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/172.json b/experiments/index/172.json
new file mode 100644
index 00000000..639e7293
--- /dev/null
+++ b/experiments/index/172.json
@@ -0,0 +1,7 @@
+{
+  "file": "172-long-payload-stream-hash.md",
+  "title": "Long-payload stream hash coverage",
+  "impact": "Adds a default streaming-suite row for mixed 32KB TEXT + 32KB BLOB unchanged fanout plus long-BLOB hash correctness coverage. The mixed row lands at 3.446 ms median beside the existing 4KB TEXT row at 2.356 ms, closing the long-payload measurement blocker without justifying an immediate new hash-loop variant",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/173.json b/experiments/index/173.json
new file mode 100644
index 00000000..ad9173dc
--- /dev/null
+++ b/experiments/index/173.json
@@ -0,0 +1,7 @@
+{
+  "file": "173-long-text-32kb-hash.md",
+  "title": "32 KB long-text streaming benchmark + 16-byte FNV fold",
+  "impact": "Filled the open `long-text-stream-hashing` candidate by building the missing ≥32 KB cell workload, then tested an unrolled 16-byte FNV body inside `fnv_combine_bytes` against it. Two order-flipped passes showed the candidate consistently +4.5 % and +12.1 % vs the exp 110 8-byte body — slight regressions inside a 2.6 → 6.0 ms per-pass spread, no real signal. Premise refuted: at 32 KB on a pool-of-4 reader fleet the byte-stream fold is at most ~50 % of wall, so loop-overhead removal is below noise. C body reverted to exp 110's path; new `streaming.dart` 32 KB section, `workload_registry.dart` curated metric, and focused `benchmark/experiments/long_text_32kb_hash.dart` harness retained as the durable contribution.",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/174.json b/experiments/index/174.json
new file mode 100644
index 00000000..123ead41
--- /dev/null
+++ b/experiments/index/174.json
@@ -0,0 +1,7 @@
+{
+  "file": "174-selectbytes-view-transfer.md",
+  "title": "selectBytes native-view transfer",
+  "impact": "`selectBytes` sends a `Uint8List` view over the reader connection's persistent `json_buf` and never takes the sacrifice (Isolate.exit + reader respawn) path. Sacrifice is a real win for the rows path (zero-copy object transfer) but counterproductive for bytes — native JSON must be `fromList`-copied before `Isolate.exit` can transfer it, so it saved zero copies and only added a respawn, while the non-sacrifice path copied twice. **−44% (~1.8×)** on large (>256KB) byte reads by eliminating the per-query respawn, **−4%** on small, at a bounded ~+15MB RSS high-water. Net code removal, no public API change",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/175.json b/experiments/index/175.json
new file mode 100644
index 00000000..8f77afd0
--- /dev/null
+++ b/experiments/index/175.json
@@ -0,0 +1,7 @@
+{
+  "file": "175-large-selectbytes-coverage.md",
+  "title": "Large selectBytes release coverage",
+  "impact": "Adds a named `Large payload (~650KB)` `resqlite selectBytes()` row to the release JSON-bytes suite and curates it as `selectBytes() large bytes`, giving exp 174's native-view transfer path a release-history guard above the old 256 KB sacrifice threshold. Single-repeat release run measured 0.323 ms wall / 0.000 ms main for the new row.",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/176.json b/experiments/index/176.json
new file mode 100644
index 00000000..a0431f41
--- /dev/null
+++ b/experiments/index/176.json
@@ -0,0 +1,7 @@
+{
+  "file": "176-row-containskey-identity-fastpath.md",
+  "title": "Row.containsKey identity fast path",
+  "impact": "Routes `Row.containsKey` through the exp 158 schema-name identity scan (via a shared `RowSchema.containsName`) instead of always hashing the key in the private `HashMap`. For interned-key probes on schemas ≤ 32 columns the membership test becomes a pointer-identity scan; equal-but-non-identical keys and wider schemas still fall back to the map. Focused `row_map_facade` `containsKey` lane improves **~13.0 → ~10.0 ms (−23%)** with a flat `hot lookup` control, flipping Row from ~+3.6 ms slower than `LinkedHashMap` to at-parity. Behavior-identical, no public API change",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/177.json b/experiments/index/177.json
new file mode 100644
index 00000000..30ddb2b1
--- /dev/null
+++ b/experiments/index/177.json
@@ -0,0 +1,7 @@
+{
+  "file": "177-ab-drift-discriminator.md",
+  "title": "Order-flipped A/B drift discriminator",
+  "impact": "Methodology tooling: mechanizes the JOURNAL's most-reapplied lesson (phase-ordered A/B gates confound code deltas with time-correlated drift). Adds `cvPct` + `classifyDriftFlag` to `benchmark/shared/stats.dart` and a `benchmark/ab_drift_check.dart` CLI that reads two order-flipped passes of per-run values and classifies a regression flag as `reproduced` (same-direction effect, comparable CVs), `drift-suspected` (CV asymmetry on the flagged phase, or sign reversal across the flip), or `inconclusive`. Re-run against the recorded flags from exp 159 (CV asymmetry) and exp 167 (sign reversal), it reproduces the verdicts those runners reached by hand. No runtime change; 14/14 unit tests pass",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/178.json b/experiments/index/178.json
new file mode 100644
index 00000000..861ce717
--- /dev/null
+++ b/experiments/index/178.json
@@ -0,0 +1,7 @@
+{
+  "file": "178-missing-run-declaration-guard.md",
+  "title": "Missing-benchmark-run declaration guard",
+  "impact": "Measurement-only CI guardrail: `generate_history.dart` now fails the build when a chartable (accepted/in-review) experiment numbered `≥ 178` has no linked benchmark run *and* no `**Benchmark Run:**` opt-out declaration — converting the documented silent chart-invisibility failure (forgotten result file / date mismatch) into a loud error for new work. Reuses the existing `_skipsReleaseBenchmarkRunMapping` opt-out signal as the escape hatch; pre-178 experiments are grandfathered. No runtime code; `history.json` byte-for-byte unchanged",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/179.json b/experiments/index/179.json
new file mode 100644
index 00000000..dc570a19
--- /dev/null
+++ b/experiments/index/179.json
@@ -0,0 +1,7 @@
+{
+  "file": "179-single-row-ascii-param-packing.md",
+  "title": "Single-row ASCII parameter packing",
+  "impact": "Extended exp 125/149's direct-code-unit batch write to the single-row `allocateParams` path, removing the per-string `utf8.encode()` `Uint8List` + `encodedStrings` list for all-ASCII parameter lists. The focused `single_row_param_packing.dart` micro confirms the mechanism — encoder **−45% / −58% / −37%** on 1-short / 5-mixed / 1-KB ASCII shapes, flat blob+int control — but the full release suite is neutral (Parameterized +0.04%, Single Inserts −1.7%, 1 win / 0 reg / 166 neutral, the flags on untouched read paths). The bind is too small a fraction of any representative workload to register (exp 146 restated for single-row). Reverted from `lib/`; micro retained; implementation preserved at `archive/exp-179`.",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/180.json b/experiments/index/180.json
new file mode 100644
index 00000000..da9d457a
--- /dev/null
+++ b/experiments/index/180.json
@@ -0,0 +1,7 @@
+{
+  "file": "180-group-commit-request-batching.md",
+  "title": "Cross-call write request batching (group commit)",
+  "impact": "The \"group commit\" lever exp 159 named: standalone `execute()` calls that pile up while a send is in flight coalesce into one `MultiExecuteRequest` (each statement its own autocommit — per-call semantics unchanged), collapsing a concurrent burst's N round-trips toward ~2 and capturing exp 147's ~72% per-round-trip residual that pipelining left behind. **−26% to −32%** on the release Concurrent Single Inserts lane, reproduced across order-flipped runs; sequential lane neutral (backpressure trigger adds no latency to isolated writes); the lone flagged nested-tx regression proven to be drift (sign-flip on an untouched code path).",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/181.json b/experiments/index/181.json
new file mode 100644
index 00000000..5b76a7e0
--- /dev/null
+++ b/experiments/index/181.json
@@ -0,0 +1,7 @@
+{
+  "file": "181-single-stream-long-payload-hash.md",
+  "title": "Single-stream long-payload hash",
+  "impact": "Added a focused one-reader harness that removes exp 173's eight-stream reader-pool parallelism: one unchanged stream hashes 64 rows x 64 KB TEXT + 64 KB BLOB (~8 MB) before a queued `COUNT(*)` barrier can emit. Re-tested the 16-byte FNV fold against the exp 110 8-byte body across an order-flipped pair. Baseline medians were 2.771 / 2.777 ms; candidate medians were 2.763 / 2.792 ms (-0.3% / +0.5%), with fully overlapping ranges. Rejected: even isolated to one stream, loop unrolling is invisible on the public stream path. Native C reverted; focused harness retained.",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/182.json b/experiments/index/182.json
new file mode 100644
index 00000000..6d93e952
--- /dev/null
+++ b/experiments/index/182.json
@@ -0,0 +1,7 @@
+{
+  "file": "182-skip-dep-tracking-no-streams.md",
+  "title": "Skip preupdate dependency tracking when no streams active",
+  "impact": "Added a `track_dirty` flag on `resqlite_db` plus a `tracksDirty` field on writer requests so `preupdate_hook` and the reply harvest both short-circuit when `_streamEngine.length == 0` at send time, with a `DrainRequest` no-op barrier from `StreamEngine._createStream` to fence in-flight non-tracking writes before the new stream's initial query. Two order-flipped focused passes confirm the no-stream wins (sequential **−3.8% / −5.3%**, wide-batch **−2.4% / −5.9%**) but also reproduce a with-streams regression (`with-streams guardrail` **+2.7% / +3.7%**, classified `reproduced` by `ab_drift_check.dart`), and the Tracelite `stream-rerun-dispatch` decision came back `inconclusive` with all three stream-direction warmup elapsed regressing in the same direction (+12% / +36% / +21%, gated `too_noisy`). Reactive streams are the library's primary use case, so the workload mix where the optimization helps is narrower than the one it slows. Reverted from `lib/` and `native/`; focused harness retained; implementation preserved at `archive/exp-182`.",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/183.json b/experiments/index/183.json
new file mode 100644
index 00000000..153585c1
--- /dev/null
+++ b/experiments/index/183.json
@@ -0,0 +1,7 @@
+{
+  "file": "183-json-buf-retention-audit.md",
+  "title": "json_buf retention audit + high-threshold reclaim",
+  "impact": "Diagnostic + reclaim. Adds `Diagnostics.readerJsonBufHighWaterBytes` (sum of per-reader `json_buf.cap`) so the bounded RSS high-water exp 174 left as a known trade-off is now directly observable. Pathological retention is real on a one-off concurrent-burst workload (8 × 8 MB `selectBytes` pins **32 MB** across the 4-reader pool for the rest of the connection's life) and on a recurring-large pattern (16 MB pinned). A high-threshold C-side `realloc` shrink — fired by the reader worker after `SendPort.send` on a `selectBytes` reply when `json_buf.cap > 1 MB` AND the just-sent result was < 256 KB — reclaims back to the 16 KB initial cap on subsequent small reads: **post-burst settle 32 MB → 64 KB** (×4 readers, summed); recurring-large **16 MB → 64 KB**. Neutral on the focused `large_bytes_transfer.dart` lanes (±2 % within run-to-run noise). The 256 KB last-len guard is what makes the policy safe under back-to-back large reads — they keep their warm capacity",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/184.json b/experiments/index/184.json
new file mode 100644
index 00000000..831a491b
--- /dev/null
+++ b/experiments/index/184.json
@@ -0,0 +1,7 @@
+{
+  "file": "184-writer-residual-resplit.md",
+  "title": "Writer residual re-split (post-159/180)",
+  "impact": "Measurement: re-ran exp 147's `writer_sqlite_wall_audit` after pipelining + group commit landed. Breakdown essentially unchanged (A11c overlap SQLite 13.6% / invalidation 16.0% / residual 70.3%) — the audit is sequential and exp 180 coalesces only concurrent bursts. Retires writer-residual micro-opts: the residual is the SDK-gated per-write round-trip, invalidation precision is owned by in-flight exp 160 (#155), the dirty harvest (~4–6%, exp 182) is small, SQLite config is mined. No runtime code.",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/185.json b/experiments/index/185.json
new file mode 100644
index 00000000..b8752ab3
--- /dev/null
+++ b/experiments/index/185.json
@@ -0,0 +1,7 @@
+{
+  "file": "185-json-buf-release-coverage.md",
+  "title": "JSON buffer reclaim release coverage",
+  "impact": "Measurement-support guard for exp 183: `SQLite Diagnostics` now emits `JSON buf (KiB)` and a `JSON buffer reclaim (8 large selectBytes + 64 small settles)` row. The row grows reader `json_buf` capacity with a concurrent large `selectBytes` burst, settles with small reads, and fails if post-settle retention stays above 512 KiB; the focused suite run settled at **64.0 KiB** with idle readers. Parser/sidecar/history data carry optional `jsonBufKiB` while legacy diagnostics tables remain parseable. No runtime code.",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/186.json b/experiments/index/186.json
new file mode 100644
index 00000000..6e03c921
--- /dev/null
+++ b/experiments/index/186.json
@@ -0,0 +1,7 @@
+{
+  "file": "186-single-row-large-text-bind-encoder.md",
+  "title": "Single-row large-text bind encoder",
+  "impact": "Revives exp 179's direct-ASCII `allocateParams` rewrite against a representative large-payload workload — the explicit revisit condition exp 179 named. Focused `single_row_large_text_bind.dart` measures **−15% to −32%** at 16 KB → 1 MB single-row INSERT text binds, reproduced across order-flipped passes; encoder isolation reproduces exp 179's −45% / −58% / −37% on the synthetic micro. Small-payload release-suite lanes (Parameterized Queries, Single Inserts, Concurrent Single Inserts) stay neutral, confirming exp 179's small-bind finding stands; the lone flagged batch-tx regression is sub-decision-threshold noise on a routing path the encoder does not touch (`allocateBatchParams`). Saves one `Uint8List` allocation + one byte-buffer copy per ASCII string param; non-ASCII strings still take the unchanged `_allocateParamsPreEncoded` fallback.",
+  "status": "accepted",
+  "link": ""
+}
diff --git a/experiments/index/187.json b/experiments/index/187.json
new file mode 100644
index 00000000..6670604c
--- /dev/null
+++ b/experiments/index/187.json
@@ -0,0 +1,7 @@
+{
+  "file": "187-single-row-utf8-bind-encoder.md",
+  "title": "Single-row UTF-8 bind encoder",
+  "impact": "Extends exp 186's single-row large-text encoder from ASCII-only to direct UTF-8 for non-ASCII parameter lists, reusing the wide-batch `_utf8Length` / `_writeUtf8` helpers and removing the temporary `utf8.encode()` list plus second copy. The broadened `single_row_large_text_bind.dart` CJK rows improve **~31% to ~39%** at 16 KB through 1 MB across an order-flipped pair; ASCII controls stay comparable because the exp 186 all-ASCII fast path is preserved. Adds single-row multibyte + embedded-NUL correctness coverage. Runtime code change; held in review.",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/188.json b/experiments/index/188.json
new file mode 100644
index 00000000..9e22bd59
--- /dev/null
+++ b/experiments/index/188.json
@@ -0,0 +1,7 @@
+{
+  "file": "188-prerun-declarations-backfill.md",
+  "title": "Pre-178 benchmark-run declarations backfill",
+  "impact": "Extends [exp 178](178-missing-run-declaration-guard.md) by walking `_benchmarkRunDeclarationCutoff` from `178` back to `1`, so every chartable (accepted/in-review) experiment is now under the missing-run-without-declaration guard. Backfills `**Benchmark Run:**` opt-out headers on the 16 silently-unmapped chartable experiments (003, 004, 007, 008, 009, 037, 038, 083, 116, 118, 119, 125, 126, 136, 161, 172) plus exp 174 (whose existing header was descriptive but did not start with an opt-out keyword). `docs/experiments/history.json` is unchanged for every pre-existing row — only the new exp 188 entry is added. A new unit test (`exp 188 walked the cutoff to 1`) anchors the cutoff change inside the same `findUndeclaredMissingRunExperiments` suite exp 178 shipped. No runtime code.",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/189.json b/experiments/index/189.json
new file mode 100644
index 00000000..eebdb4af
--- /dev/null
+++ b/experiments/index/189.json
@@ -0,0 +1,7 @@
+{
+  "file": "189-savepoint-name-compression.md",
+  "title": "Savepoint name compression",
+  "impact": "Replaced depth-specific nested transaction SQL with cached same-name savepoint strings (`SAVEPOINT s`, `RELEASE s`, `ROLLBACK TO s`) and measured it with a new focused `savepoint_name_compression.dart` harness. Best-case control rows trended faster (empty fanout ~-6% both passes; rollback fanout -17% / -13%; deep chain -7% / -8%), but the representative nested-write fanout did not reproduce: -1.3% in the baseline-first pass, then +21.6% slower in the candidate-first pass. Same-name savepoint semantics are not worth carrying for a noisy/non-reproducing write-fanout result. Runtime change reverted; focused harness retained. Future transaction-control work needs to collapse savepoint round trips, not rename/cache per-boundary SQL strings.",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/190.json b/experiments/index/190.json
new file mode 100644
index 00000000..891cff0a
--- /dev/null
+++ b/experiments/index/190.json
@@ -0,0 +1,7 @@
+{
+  "file": "190-selectbytes-col-name-preencode.md",
+  "title": "selectBytes column-name token pre-encoding",
+  "impact": "Native-side encoder amortization for `Database.selectBytes()`. `write_json_to_buf` in `native/resqlite.c` now pre-builds each column's `\"col\":` / `,\"col\":` token once at first-row time into a per-query scratch buffer, then emits each column on subsequent rows with a single `buf_write` instead of comma + `json_write_string` (SWAR scan + escape walk) + colon — collapsing four `buf_write*` calls per column per row into one on the common ASCII identifier case. Focused `select_bytes_wide_cols.dart` measures **−4% to −11%** across two order-flipped passes on 10k-row × 8 / 20-col shapes, with the 1-row and 100-row regression guards staying inside the sub-µs noise floor; `large_bytes_transfer.dart` (exp 174's focused guard) also moves **−8.7% / −8.2%** on large/small lanes. No public API change; behavior preserved by reusing `json_write_string` for the token build so escape semantics are identical.",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/191.json b/experiments/index/191.json
new file mode 100644
index 00000000..ea63746c
--- /dev/null
+++ b/experiments/index/191.json
@@ -0,0 +1,7 @@
+{
+  "file": "191-embedded-nul-public-api-audit.md",
+  "title": "Embedded-NUL public API audit",
+  "impact": "Correctness guard for the remaining public text surfaces in `parameter-encoding-and-binding`: `selectBytes()` now has an assertion that SQLite `char(0)` TEXT decodes through native JSON bytes without truncation, and `stream()` now verifies both initial and changed emissions preserve embedded-NUL UTF-8 bytes. No runtime code or benchmark run; this consumes the signal-map's broader embedded-NUL audit candidate while leaving performance candidates unchanged.",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/192.json b/experiments/index/192.json
new file mode 100644
index 00000000..e6f218c5
--- /dev/null
+++ b/experiments/index/192.json
@@ -0,0 +1,7 @@
+{
+  "file": "192-two-digit-itoa.md",
+  "title": "Two-digit table itoa for selectBytes integer columns",
+  "impact": "Replaces the single-digit `fast_i64_to_str` body ([exp 023](023-fast-itoa.md)) with a two-digit `[00..99]` lookup table — one `% 100` / `/ 100` and one 2-byte `memcpy` per pair of output digits, halving the division count vs the old loop. Focused `select_bytes_int_heavy.dart` A/B (order-flipped pair): **10k × 8 small ints −11 %, 10k × 20 small ints −8 to −10 %, 10k × 20 big ints (~18 digits) −24 to −26 %**, with mixed-cell and small-payload regression guards inside ±1 %. Adds a 200-byte `kTwoDigits` `const` table; `LLONG_MIN` handling and the `val == 0` short circuit preserved bit-for-bit; new end-to-end int-extremes test covers 0, ±9, ±99, ±10000, ±1234567890, LLONG_MIN, LLONG_MAX through `selectBytes()`",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/193.json b/experiments/index/193.json
new file mode 100644
index 00000000..b6e31c06
--- /dev/null
+++ b/experiments/index/193.json
@@ -0,0 +1,7 @@
+{
+  "file": "193-row-values-list-view.md",
+  "title": "Row.values list-view iterator",
+  "impact": "Tried replacing `Row.values`' custom `_RowValueIterator` with a fixed-length `ListBase` slice view after a JIT `row_map_facade` sample suggested values iteration was slower than `LinkedHashMap.values`. The JIT signal did not reproduce cleanly, and the decisive AOT check reversed it: baseline `_RowValueIterator` values iteration stayed at 2.663 / 2.675 / 2.687 ms, while the list-view candidate regressed to 6.828 / 6.847 / 7.101 ms (~2.6x slower). Controls stayed neutral. No runtime code kept; future `Row.values` changes should compile the focused harness to AOT before trusting JIT microbenchmarks.",
+  "status": "rejected",
+  "link": ""
+}
diff --git a/experiments/index/194.json b/experiments/index/194.json
new file mode 100644
index 00000000..1c381ba2
--- /dev/null
+++ b/experiments/index/194.json
@@ -0,0 +1,7 @@
+{
+  "file": "194-real-integer-fastpath.md",
+  "title": "Integer-valued REAL selectBytes fast path",
+  "impact": "Adds a conservative `SQLITE_FLOAT` JSON helper that routes finite, exactly integral REAL values inside the exact double integer range (`abs(v) <= 2^53`) through the existing `fast_i64_to_str` path while preserving `snprintf(\"%.17g\")` for fractional values, huge values, non-finite values, and negative zero. Focused `select_bytes_real_int_fastpath.dart` A/B (order-flipped pair): **10k x 8 integral REAL -79%, 10k x 20 integral REAL -81%, 1k x 2 integral REAL -72%**, with the fractional-REAL fallback guard flat at +0.5% and the mixed lane moving in proportion to its integral-REAL columns. No public API change; new selectBytes test covers integral REAL, fractional REAL, and huge fallback values.",
+  "status": "in_review",
+  "link": ""
+}
diff --git a/experiments/index/195.json b/experiments/index/195.json
new file mode 100644
index 00000000..1b7f1804
--- /dev/null
+++ b/experiments/index/195.json
@@ -0,0 +1,7 @@
+{
+  "file": "195-stmt-cache-name-tokens.md",
+  "title": "Stmt-cache pre-encoded JSON column-name tokens",
+  "impact": "Extends [exp 190](190-selectbytes-col-name-preencode.md)'s per-query token amortization across re-executions of the same prepared SQL by caching the encoded `\"name\":` / `,\"name\":` tokens on the `resqlite_cached_stmt` entry. Eliminates the per-query `buf_init(64)` + `free` pair and the first-row pre-encode walk from `write_json_to_buf`; the per-row loop is bit-identical to exp 190 and JSON output is byte-identical. Focused `select_bytes_repeated_calls.dart` 1-row × 20-col improves **−9.2 % / −7.2 %** and 10-row × 20-col improves **−5.1 % / −2.7 %** across two order-flipped passes, while 100/1000-row guards show sign reversal (drift-suspected — per-query setup is < 0.2 % of wall at those sizes). Exp 190's `wide_cols.dart` shapes trend candidate-faster on every 10k-row lane across both passes. No public API change, ~hundreds of bytes per cached statement",
+  "status": "in_review",
+  "link": ""
+}