core: sausage-vfs per process (/, /proc, /self, /run), activation, graph, watcher, upgrades

- /proc is a core layer: core/ (PROTOCOL.md, graph.json, graph.dot,
  locks.json, plugins/<name>/discover.json and client.rs) and one folder
  per process (info.json, log, and its /self files).
- Locks are released only after the task ended, the store dropped, and
  in-flight file operations returned.
- core.activate and core.revert with copies, discovery, compatibility
  checks of imports and consumers, groups, force. An admission gate
  makes the snapshot of old processes complete.
- Graph of discover documents by hash, refreshed by a file watcher.
- Upgrades: grace periods (x-sausage-grace), stop, service restarts,
  rpc.retired.
- SDK plugins in the real core (cli/tests/sdk.rs).

cli/src/routing.rs

@@ -93,6 +93,7 @@ impl Host {
             {
                 return Err(error(-32601, "invalid plugin name"));
             }
+            let admission = host.0.admission.read().await;
             let native = host.0.state.lock().unwrap().native.get(plugin).cloned();
             let (component, version) = if native.is_some() {
                 (None, "native".into())
@@ -141,6 +142,9 @@ impl Host {
                     pid.clone(),
                     Process {
                         info: info.clone(),
+                        memory: sausage_vfs::Memory::default(),
+                        files: sausage_vfs::Process::default(),
+                        store_ended: watch::channel(true).0,
                         input: Some(input),
                         abort: None,
                         caller,
@@ -153,15 +157,34 @@ impl Host {
             let h = host.clone();
             let p = pid.clone();
             let has_id = id.is_some();
+            let (start, ready) = oneshot::channel();
             let task = tokio::spawn(async move {
+                let _ = ready.await;
                 h.run_process(p, info, component, native, incoming, has_id)
-                    .await;
+                    .await
             });
             if let Some(p) = host.0.state.lock().unwrap().processes.get_mut(&pid) {
                 p.abort = Some(task.abort_handle());
+                if p.info.state == "stopping" {
+                    task.abort();
+                }
             } else {
                 task.abort();
             }
+            drop(admission);
+            let cleanup = host.clone();
+            let finished_pid = pid.clone();
+            tokio::spawn(async move {
+                let status = task.await.unwrap_or_else(|error| {
+                    if error.is_cancelled() {
+                        "killed".into()
+                    } else {
+                        format!("host task failed: {error}")
+                    }
+                });
+                cleanup.finish(&finished_pid, &status).await;
+            });
+            let _ = start.send(());
             if id.is_none() {
                 return Ok(Value::Null);
             }