test: cover one-way text bundle behavior

Author: t-kalinowski

…active/one-way-output-bundle-previews.md …pleted/one-way-output-bundle-previews.mddocs/plans/active/one-way-output-bundle-previews.md renamed to docs/plans/completed/one-way-output-bundle-previews.md docs/plans/active/one-way-output-bundle-previews.md renamed to docs/plans/completed/one-way-output-bundle-previews.md

@@ -9,9 +9,9 @@
 
 ## Status
 
-- State: active
+- State: completed
 - Last updated: 2026-04-17
-- Current phase: implementation
+- Current phase: completed
 
 ## Current Direction
 
@@ -38,12 +38,12 @@
   - Define the one-way contract and the bounded in-memory preview state.
 - Phase 1: completed
   - Add cached image-preview state to `ActiveOutputBundle` and remove old-image rereads from later reply rendering.
-- Phase 2: pending
-  - Add cached text head/tail preview state and stop reconstructing later previews from spilled file state.
-- Phase 3: pending
-  - Replace tests that depend on disk rereads with tests for the one-way contract.
-- Phase 4: pending
-  - Run full validation and update plan status for any remaining follow-on work.
+- Phase 2: completed
+  - Confirm that later text replies already render from in-memory retained reply items and do not reread `transcript.txt`.
+- Phase 3: completed
+  - Replace reread-oriented regressions with one-way contract coverage for deleted bundle image and transcript files.
+- Phase 4: completed
+  - Run full validation and close the initiative.
 
 ## Locked Decisions
 
@@ -55,18 +55,11 @@
 
 ## Open Questions
 
-- What exact text preview state should be cached in memory?
-  - Likely one bounded head window plus one bounded tail window, but the final shape should preserve current preview wording and stream ordering.
-- Should the preview cache live only on `ActiveOutputBundle`, or should `StagedTimeoutOutput` also keep a lightweight preview summary before a bundle is materialized?
-- When an output-bundle directory or subdirectory disappears mid-session, what minimal recreation behavior is worth supporting for continued appends without expanding this slice into generic filesystem recovery logic?
-- Can image preview caching reuse the existing `ReplyImage` payloads directly, or should it store a more compact internal representation?
+- None for this slice.
 
 ## Next Safe Slice
 
-- Decide whether the text-preview slice is needed at all.
-- If text preview caching is needed, start that slice only after confirming that the remaining text path still violates the one-way contract in a user-visible way.
-- Decide whether text preview caching is needed purely for architectural consistency or whether the current text spill path is already sufficiently one-way.
-- If text caching is needed, define the exact bounded head/tail representation before changing text compaction behavior.
+- None. The planned work is complete.
 
 ## Stop Conditions
 
@@ -82,3 +75,4 @@
 - 2026-04-17: Kept the public bundle layout unchanged for this initiative so the refactor can land without redefining the client-facing files-mode contract.
 - 2026-04-17: Began the image-preview implementation by caching the first-history and latest image previews on `ActiveOutputBundle` and moving the public regression toward “later replies do not depend on old bundle image files remaining on disk”.
 - 2026-04-17: Completed the image-preview slice. Later image-bundle replies now render from cached preview images in memory instead of rereading old image files from the bundle directory.
+- 2026-04-17: Confirmed the text spill path already satisfied the one-way contract for visible replies. Later text replies render from in-memory retained reply items, and a new public regression now covers transcript deletion and recreation without replaying previously spilled text.

tests/write_stdin_behavior.rs

@@ -1048,6 +1048,78 @@ async fn timeout_spill_file_path_stays_stable_across_later_small_poll() -> TestR
     Ok(())
 }
 
+#[tokio::test(flavor = "multi_thread")]
+async fn timeout_spill_recreates_deleted_transcript_without_replaying_old_text() -> TestResult<()> {
+    let _guard = lock_test_mutex();
+    let mut session = spawn_behavior_session().await?;
+
+    let input = "big <- paste(rep('y', 120), collapse = ''); cat('start\\n'); flush.console(); Sys.sleep(0.2); for (i in 1:80) cat(sprintf('mid%03d %s\\n', i, big)); flush.console(); Sys.sleep(0.35); cat('tail\\n')";
+    let first = session.write_stdin_raw_with(input, Some(0.05)).await?;
+    let first_text = result_text(&first);
+    if backend_unavailable(&first_text) {
+        eprintln!("write_stdin_behavior backend unavailable in this environment; skipping");
+        session.cancel().await?;
+        return Ok(());
+    }
+
+    sleep(Duration::from_millis(260)).await;
+    let spilled = session.write_stdin_raw_with("", Some(0.1)).await?;
+    let spilled_text = result_text(&spilled);
+    let transcript_path = match bundle_transcript_path(&spilled_text) {
+        Some(path) => path,
+        None if spilled_text.contains("<<repl status: busy") => {
+            eprintln!("write_stdin_behavior spill poll remained busy; skipping");
+            session.cancel().await?;
+            return Ok(());
+        }
+        None => {
+            panic!("expected transcript path in first oversized poll reply, got: {spilled_text:?}")
+        }
+    };
+
+    fs::remove_file(&transcript_path)?;
+
+    sleep(Duration::from_millis(450)).await;
+    let final_poll = session.write_stdin_raw_with("", Some(2.0)).await?;
+    let final_text = result_text(&final_poll);
+    if final_text.contains("<<repl status: busy") {
+        eprintln!("write_stdin_behavior final poll remained busy; skipping");
+        session.cancel().await?;
+        return Ok(());
+    }
+    let recreated_transcript = fs::read_to_string(&transcript_path)?;
+
+    let follow_up = session.write_stdin_raw_with("1+1", Some(2.0)).await?;
+    let follow_up_text = result_text(&follow_up);
+
+    session.cancel().await?;
+
+    if let Some(path) = bundle_transcript_path(&final_text) {
+        assert_eq!(
+            path, transcript_path,
+            "did not expect later polls to switch transcript paths after transcript deletion, got: {final_text:?}"
+        );
+    }
+    assert!(
+        recreated_transcript.contains("tail"),
+        "expected later small poll output to recreate the deleted spill file, got: {recreated_transcript:?}"
+    );
+    assert!(
+        !recreated_transcript.contains("mid080"),
+        "did not expect earlier spilled text to be replayed after transcript deletion, got: {recreated_transcript:?}"
+    );
+    assert!(
+        final_text.contains("tail") || final_text.contains("<<repl status: idle>>"),
+        "expected later small poll to either return inline tail text or settle idle after recreating the spill file, got: {final_text:?}"
+    );
+    assert!(
+        follow_up_text.contains("[1] 2"),
+        "expected session to stay alive after transcript deletion, got: {follow_up_text:?}"
+    );
+
+    Ok(())
+}
+
 #[tokio::test(flavor = "multi_thread")]
 async fn timeout_bundle_file_creation_failure_preserves_inline_content() -> TestResult<()> {
     let _guard = lock_test_mutex();