proto becomes bxcore, the one shared crate (M5b task 00)

Done the way the owner asked and the spike mapped: the crate and the
manifests renamed, then what the build reported fixed. Layers: 138
"proto unresolved" errors across 169 files; cargo fmt reordering
imports; six fixture paths built as strings in brokerd's and bxctl's
tests, which the compiler cannot see, and comments naming
crates/proto/; the crate-dependency check and its self-test. One more
the spike did not reach: a `\nproto =` key inside a printf format in
the self-test, which a word-boundary replacement skips because `n` and
`p` are both word characters.

make gate: gate: ok, 944 tests; no new entry in /tmp.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

crates/loopd/tests/support/broker.rs

@@ -12,12 +12,12 @@ use std::sync::{Arc, Mutex};
 use std::thread::{self, JoinHandle};
 use std::time::{Duration, Instant};
 
-use loopd::broker_port::{BrokerPort, UNAVAILABLE};
-use loopd::tools::{Pending, ToolPort};
-use proto::{
+use bxcore::{
     CallId, DataClass, Envelope, Message, PROTOCOL_VERSION, SessionId, Timestamp, ToolRequest,
     ToolResponse, read_frame, write_frame,
 };
+use loopd::broker_port::{BrokerPort, UNAVAILABLE};
+use loopd::tools::{Pending, ToolPort};
 
 static NEXT: AtomicU32 = AtomicU32::new(0);
 

crates/loopd/tests/support/mod.rs

@@ -94,7 +94,7 @@ impl Home {
     }
 
     /// The records of a session's log, epoch 0.
-    pub fn records(&self, session: &str) -> Vec<proto::LogRecord> {
+    pub fn records(&self, session: &str) -> Vec<bxcore::LogRecord> {
         let text = self.read(&format!("sessions/{session}/0.jsonl"));
         text.lines()
             .map(|l| serde_json::from_str(l).unwrap())
@@ -104,37 +104,37 @@ impl Home {
 
 /// A tool port that answers from a script and records what it was asked.
 pub struct ScriptedPort {
-    replies: Mutex<VecDeque<proto::ToolResponse>>,
-    calls: Mutex<Vec<proto::ToolRequest>>,
+    replies: Mutex<VecDeque<bxcore::ToolResponse>>,
+    calls: Mutex<Vec<bxcore::ToolRequest>>,
 }
 
 impl ScriptedPort {
     /// Replies are given in order; when they run out, every call gets `fallback`.
-    pub fn new(replies: Vec<proto::ToolResponse>) -> ScriptedPort {
+    pub fn new(replies: Vec<bxcore::ToolResponse>) -> ScriptedPort {
         ScriptedPort {
             replies: Mutex::new(replies.into()),
             calls: Mutex::new(Vec::new()),
         }
     }
 
-    pub fn calls(&self) -> Vec<proto::ToolRequest> {
+    pub fn calls(&self) -> Vec<bxcore::ToolRequest> {
         self.calls.lock().unwrap().clone()
     }
 }
 
-pub fn ok_result(content: &str) -> proto::ToolResponse {
-    proto::ToolResponse::Result {
+pub fn ok_result(content: &str) -> bxcore::ToolResponse {
+    bxcore::ToolResponse::Result {
         content: content.to_string(),
-        class: proto::DataClass::Private,
+        class: bxcore::DataClass::Private,
         untrusted: true,
         truncated: false,
     }
 }
 
-pub fn pending(approval: u64, expires: &str) -> proto::ToolResponse {
-    proto::ToolResponse::PendingApproval {
+pub fn pending(approval: u64, expires: &str) -> bxcore::ToolResponse {
+    bxcore::ToolResponse::PendingApproval {
         approval,
-        expires: proto::Timestamp::parse(expires).unwrap(),
+        expires: bxcore::Timestamp::parse(expires).unwrap(),
     }
 }
 
@@ -144,13 +144,13 @@ impl loopd::tools::ToolPort for ScriptedPort {
     /// `ReturnsPendingPort` for a port that breaks the rule and returns one.
     fn call(
         &self,
-        request: &proto::ToolRequest,
+        request: &bxcore::ToolRequest,
         on_pending: &mut dyn FnMut(&loopd::tools::Pending),
-    ) -> proto::ToolResponse {
+    ) -> bxcore::ToolResponse {
         self.calls.lock().unwrap().push(request.clone());
         let mut replies = self.replies.lock().unwrap();
         let mut reply = replies.pop_front();
-        if let Some(proto::ToolResponse::PendingApproval { approval, expires }) = reply {
+        if let Some(bxcore::ToolResponse::PendingApproval { approval, expires }) = reply {
             on_pending(&loopd::tools::Pending { approval, expires });
             reply = replies.pop_front();
         }
@@ -164,9 +164,9 @@ pub struct ReturnsPendingPort;
 impl loopd::tools::ToolPort for ReturnsPendingPort {
     fn call(
         &self,
-        _request: &proto::ToolRequest,
+        _request: &bxcore::ToolRequest,
         _on_pending: &mut dyn FnMut(&loopd::tools::Pending),
-    ) -> proto::ToolResponse {
+    ) -> bxcore::ToolResponse {
         pending(1, "2026-09-18T12:00:00.000Z")
     }
 }

crates/loopd/tests/support/turn.rs

@@ -5,12 +5,12 @@
 #![allow(dead_code)]
 
 use crate::support::{FakeServer, Home, ScriptedPort};
+use bxcore::{LogRecord, SessionId, ToolResponse, TurnEvent};
 use loopd::baseline::Baseline;
 use loopd::llama::Client;
 use loopd::session::Session;
 use loopd::tools::Registry;
 use loopd::turn::{Runtime, TurnError, run_turn};
-use proto::{LogRecord, SessionId, ToolResponse, TurnEvent};
 
 pub struct Setup {
     pub home: Home,