core: review fixes, init builds the agent, console without a terminal

Activation path (review T6R): a broken plugin or a stray file in
/plugins blocks no activation; candidates replace their own entries;
discovery has a 10 s deadline and its process is stopped after the
answer; an unchanged hash keeps plugin.prev.wasm; activations run in
their own task; the watcher is not recursive; no duplicate services;
rpc.retired waits for live processes of its version; reads and hashes
on blocking threads.

Guest I/O and per-call paths: a stdin write error is EOF, stdout and
stderr are drained before the status; stderr is lossy UTF-8 and goes
to the journal from its own reader; compiled components are freed;
shutdown starts no new processes; lock queues drop stopping processes;
compile before the admission gate; CommandPre per component;
core.unlock in order; null errors are successes; the journal thread
survives SQLite errors.

sausage init builds the agent with cargo.build; sausage without a
command creates ./world. The console reads plain lines without a
terminal. PROTOCOL.md and DECISIONS.md describe the decided rules. The
flake tests the whole workspace and checks the packaged cargo.build.

cli/src/services.rs

@@ -6,6 +6,7 @@ pub(crate) struct Service {
     pub(crate) method: String,
     pub(crate) params: Value,
     pub(crate) request: Value,
+    pub(crate) starting: std::sync::Arc<std::sync::atomic::AtomicBool>,
 }
 impl Host {
     /// Starts discovery in the background, then waits for each boot service in order.
@@ -25,11 +26,16 @@ impl Host {
     }
     /// Records a unique request identity before the service can answer or exit.
     pub(crate) async fn start_service(&self, method: String, params: Value) {
+        if self.0.shutdown.load(std::sync::atomic::Ordering::SeqCst) {
+            return;
+        }
         let request = json!(uuid::Uuid::now_v7().to_string());
+        let starting = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(true));
         self.0.state.lock().unwrap().services.push(Service {
             method: method.clone(),
             params: params.clone(),
             request: request.clone(),
+            starting: starting.clone(),
         });
         self.0
             .journal
@@ -42,5 +48,6 @@ impl Host {
                 .journal
                 .write("core", "core", "core", &format!("service failed {error}"));
         }
+        starting.store(false, std::sync::atomic::Ordering::SeqCst);
     }
 }