feat(aura-registry, aura-runner): deferred writer opener; TapRecorder moves in-graph to the assembly crate

Two #283 groundwork moves for the fold-registry model:

- TraceStreamer::register_tap returns a TapWriterOpener — everything
  needed to open one tap's incremental writer later, from inside a
  consumer node's initialize, without holding the streamer. tap_writer
  is re-expressed as register_tap(..).open(), so there is exactly one
  open path; pinned by a byte-equality test between the two.

- TapRecorder leaves aura-std (which must not know aura-registry, C28
  layering) and is reworked in aura-runner as the record entry's
  consumer: it holds the TapTraceWriter in-graph — initialize opens
  (deferred; an open error is stored and the node degrades to inert),
  eval appends per fired warm cycle (zero heap, no thread, no
  channel), finalize finishes the writer and reports exactly one
  terminal outcome. The SyncSender-based aura-std variant and its
  planned writer-thread protocol are retired; newest_cell becomes pub
  for the assembly crate.

Verification: cargo clippy --workspace --all-targets -D warnings
clean; aura-core/engine/registry/std/runner suites green (new tests:
opener equivalence, happy-path capture + single Ok outcome,
failed-open inert + single Err outcome).

refs #283 refs #77

crates/aura-registry/src/lib.rs

@@ -38,7 +38,8 @@ pub use lineage::{
 
 mod trace_store;
 pub use trace_store::{
-    FamilyMember, NameKind, RunTraces, TraceStore, TraceStoreError, TraceStreamer, WriteKind,
+    FamilyMember, NameKind, RunTraces, TapTraceWriter, TapWriterOpener, TraceStore,
+    TraceStoreError, TraceStreamer, WriteKind,
 };
 
 /// An append-only run registry over a JSONL file: one serde_json line per

crates/aura-registry/src/trace_store.rs

@@ -276,30 +276,19 @@ pub struct TraceStreamer {
 }
 
 impl TraceStreamer {
-    /// An incremental writer for one tap; `Send`, moved into a writer thread.
+    /// An incremental writer for one tap, opened now. `Send`. Expressed
+    /// through [`TraceStreamer::register_tap`] so there is exactly one open
+    /// path and the two cannot drift.
     pub fn tap_writer(&self, tap: &str, kind: ScalarKind) -> Result<TapTraceWriter, TraceStoreError> {
-        let final_path = self.run_dir.join(format!("{tap}.json"));
-        let ts_path = self.run_dir.join(format!("{tap}.ts.tmp"));
-        let col_path = self.run_dir.join(format!("{tap}.col.tmp"));
-        // Read+write handles, NOT `File::create`: `finish` seeks these same
-        // handles back and `io::copy`-reads them, and a `File::create` handle
-        // is O_WRONLY — reading it back fails with EBADF (os error 9).
-        let ts_w = BufWriter::new(
-            OpenOptions::new().read(true).write(true).create(true).truncate(true).open(&ts_path)?,
-        );
-        let col_w = BufWriter::new(
-            OpenOptions::new().read(true).write(true).create(true).truncate(true).open(&col_path)?,
-        );
-        Ok(TapTraceWriter {
-            tap: tap.to_string(),
-            kind,
-            final_path,
-            ts_path,
-            col_path,
-            ts_w,
-            col_w,
-            any: false,
-        })
+        self.register_tap(tap, kind).open()
+    }
+
+    /// The deferred twin of [`TraceStreamer::tap_writer`]: everything needed
+    /// to open one tap's incremental writer later — from inside a consumer
+    /// node's `initialize`, at run start — without holding the streamer.
+    /// `Send`; opens no handles until [`TapWriterOpener::open`].
+    pub fn register_tap(&self, tap: &str, kind: ScalarKind) -> TapWriterOpener {
+        TapWriterOpener { run_dir: self.run_dir.clone(), tap: tap.to_string(), kind }
     }
 
     /// Write one complete tap file at once (the fold path's one-row trace) —
@@ -314,6 +303,41 @@ impl TraceStreamer {
     }
 }
 
+/// See [`TraceStreamer::register_tap`].
+pub struct TapWriterOpener {
+    run_dir: PathBuf,
+    tap: String,
+    kind: ScalarKind,
+}
+
+impl TapWriterOpener {
+    /// Open the two temp column streams and return the incremental writer.
+    pub fn open(self) -> Result<TapTraceWriter, TraceStoreError> {
+        let final_path = self.run_dir.join(format!("{}.json", self.tap));
+        let ts_path = self.run_dir.join(format!("{}.ts.tmp", self.tap));
+        let col_path = self.run_dir.join(format!("{}.col.tmp", self.tap));
+        // Read+write handles, NOT `File::create`: `finish` seeks these same
+        // handles back and `io::copy`-reads them, and a `File::create` handle
+        // is O_WRONLY — reading it back fails with EBADF (os error 9).
+        let ts_w = BufWriter::new(
+            OpenOptions::new().read(true).write(true).create(true).truncate(true).open(&ts_path)?,
+        );
+        let col_w = BufWriter::new(
+            OpenOptions::new().read(true).write(true).create(true).truncate(true).open(&col_path)?,
+        );
+        Ok(TapTraceWriter {
+            tap: self.tap,
+            kind: self.kind,
+            final_path,
+            ts_path,
+            col_path,
+            ts_w,
+            col_w,
+            any: false,
+        })
+    }
+}
+
 /// The four-kind tag string (the on-disk `ColumnarTrace.kinds` form). A local
 /// copy of `report.rs`'s private `kind_tag`; the streamed-vs-write
 /// byte-equality test below is the drift guard.
@@ -733,6 +757,42 @@ mod tests {
         let _ = fs::remove_dir_all(&root);
     }
 
+    /// `register_tap`/`TapWriterOpener::open` produce the exact same bytes as
+    /// `tap_writer` for the same rows — the deferred opener and the
+    /// open-now writer are one write path (`tap_writer` delegates to
+    /// `register_tap(..).open()`), so they cannot drift.
+    #[test]
+    fn register_tap_open_is_the_same_write_path_as_tap_writer() {
+        use aura_core::Cell;
+        let root = temp_traces_root("deferred-open");
+        let store = TraceStore::open(&root);
+        let rows =
+            [(Timestamp(2), Cell::from_f64(0.25)), (Timestamp(3), Cell::from_f64(-1.5))];
+
+        // run "a": open-now.
+        let sa = store.begin_run("a").expect("begin a");
+        let mut wa = sa.tap_writer("t", ScalarKind::F64).expect("open now");
+        for &(ts, c) in &rows {
+            wa.append(ts, c).expect("append a");
+        }
+        wa.finish().expect("finish a");
+
+        // run "b": deferred — the opener is Send and opens at use time.
+        let sb = store.begin_run("b").expect("begin b");
+        let opener = sb.register_tap("t", ScalarKind::F64);
+        fn assert_send<T: Send>(_: &T) {}
+        assert_send(&opener);
+        let mut wb = opener.open().expect("deferred open");
+        for &(ts, c) in &rows {
+            wb.append(ts, c).expect("append b");
+        }
+        wb.finish().expect("finish b");
+
+        let a = fs::read(root.join("traces").join("a").join("t.json")).expect("read a");
+        let b = fs::read(root.join("traces").join("b").join("t.json")).expect("read b");
+        assert_eq!(a, b, "one open path, identical bytes");
+    }
+
     /// `TraceStreamer::finish` + `write_full` produce a run `read` returns in
     /// caller order — the fold path's one-row trace beside a streamed tap.
     #[test]