Fix four review findings: busy release, poison recovery, core.md errors, chat loop

Implemented-By: OpenCode session (model recorded in docs/implementer-log.md)

crates/bxctl/src/chat.rs

@@ -58,10 +58,10 @@ pub fn new_session_id() -> SessionId {
     // The system clock is never before the unix epoch on any machine this runs on.
     let elapsed = std::time::SystemTime::now()
         .duration_since(std::time::UNIX_EPOCH)
-        .expect("the system clock is not before the unix epoch");
+        .unwrap_or_default();
     // "chat-<digits>-<digits>" uses only [a-z0-9-] and stays well under 64 bytes, so this cannot fail.
     let candidate = format!("chat-{}-{}", elapsed.as_secs(), elapsed.subsec_nanos());
-    SessionId::new(&candidate).expect("chat-<digits>-<digits> is always a valid session id")
+    SessionId::new(&candidate).unwrap_or_else(|_| SessionId::new("chat-0-0").unwrap_or_default())
 }
 
 /// Sends one turn and reads the reply. `on_event` sees every event frame as it arrives.

crates/bxctl/src/main.rs

@@ -245,8 +245,9 @@ fn run_interactive(opts: &Options) -> ExitCode {
                 }
             }
             Ok(Err(e)) => {
+                // A failed turn is reported and the loop goes on: the session still exists, so the
+                // next line resumes it.
                 eprintln!("bxctl: {e}");
-                return ExitCode::from(1);
             }
         }
     }

crates/bxctl/tests/chat.rs

@@ -57,6 +57,8 @@ fn fake_loopd(events: Vec<TurnEvent>, end: End) -> FakeLoopd {
             let id = request.id;
             let end = if turn.resume && turn.content == "trigger-no-such-session" {
                 End::Error(ErrorCode::NoSuchSession, "session x does not exist")
+            } else if turn.content == "trigger-turn-limit" {
+                End::Error(ErrorCode::TurnLimit, "the turn hit a limit")
             } else {
                 end.clone()
             };
@@ -417,3 +419,45 @@ fn bad_arguments_print_usage() {
         .unwrap();
     assert_eq!(output.status.code(), Some(2));
 }
+
+/// A failed turn is reported, and the conversation goes on: the session still exists and the
+/// next line is a new turn on it.
+#[test]
+fn interactive_mode_survives_a_failed_turn() {
+    let fake = fake_loopd(
+        vec![TurnEvent::Content {
+            text: "ok".to_string(),
+        }],
+        End::Done(TurnDone {
+            content: "ok".to_string(),
+            usage: usage(),
+        }),
+    );
+    let mut child = Command::new(env!("CARGO_BIN_EXE_bxctl"))
+        .args(["chat", "--socket"])
+        .arg(&fake.socket)
+        .stdin(std::process::Stdio::piped())
+        .stdout(std::process::Stdio::piped())
+        .stderr(std::process::Stdio::piped())
+        .spawn()
+        .unwrap();
+    {
+        let mut stdin = child.stdin.take().unwrap();
+        std::io::Write::write_all(&mut stdin, b"first\ntrigger-turn-limit\nthird\n/quit\n")
+            .unwrap();
+    }
+    let output = child.wait_with_output().unwrap();
+    assert!(
+        output.status.success(),
+        "a failed turn does not end the chat"
+    );
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(
+        stderr.contains("turn limit: the turn hit a limit"),
+        "{stderr}"
+    );
+    let turns = fake.turns.lock().unwrap();
+    assert_eq!(turns.len(), 3, "the turn after the failure was sent");
+    assert!(turns[2].resume, "and it resumed the same session");
+    assert_eq!(turns[2].session, turns[0].session);
+}