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/host.rs

@@ -23,7 +23,7 @@ pub(crate) struct Inner {
     pub(crate) world: World,
     pub(crate) runtime: Arc<Runtime>,
     pub(crate) state: Mutex<State>,
-    pub(crate) journal: journal::Journal,
+    pub(crate) journal: Arc<journal::Journal>,
     pub(crate) notifications: tokio::sync::broadcast::Sender<Value>,
     pub(crate) exit: watch::Sender<bool>,
     pub(crate) components: components::Components,
@@ -31,6 +31,9 @@ pub(crate) struct Inner {
     /// process is in the table. Activation holds it for writing while it
     /// installs a version, so that it sees every process of the old version.
     pub(crate) admission: tokio::sync::RwLock<()>,
+    /// Set when the host starts to stop. After that, the core starts no new
+    /// processes, and upgrade tasks do nothing.
+    pub(crate) shutdown: std::sync::atomic::AtomicBool,
     pub(crate) run: sausage_vfs::Memory,
     pub(crate) graph: Mutex<crate::graph::Graph>,
     pub(crate) activations: tokio::sync::Mutex<()>,
@@ -65,7 +68,7 @@ impl Host {
         let host = Self(Arc::new(Inner {
             world,
             runtime,
-            journal,
+            journal: Arc::new(journal),
             state: Mutex::new(State {
                 processes: HashMap::new(),
                 locks: HashMap::new(),
@@ -76,6 +79,7 @@ impl Host {
             exit: watch::channel(false).0,
             components: components::Components::default(),
             admission: tokio::sync::RwLock::new(()),
+            shutdown: std::sync::atomic::AtomicBool::new(false),
             run: sausage_vfs::Memory::default(),
             graph: Mutex::new(crate::graph::Graph::default()),
             activations: tokio::sync::Mutex::new(()),