Trim the harness to what it needs to keep going

Host:
- test first: a new version is tested where it lies; only an installed
  version goes to versions/, and instances run from there
- data/ and public/ are shared by all versions; no snapshots; rollback
  restores code only
- no re-delivery, status.json, list, remove/archive, smoke test, data/
  hiding, or stdin timeout; rollback needs a version
- supervisor.rs split out; one place for installing a version
- init only writes the agent folder; run installs it like any actor
- console: @actor, text to the agent, /help, /quit

Agent:
- every text goes out as a broadcast; 5-line prompt; 5 tools that describe
  themselves; turn.json only marks an active turn

Docs: PROTOCOL.md, README.md, DECISIONS.md, AGENTS.md rewritten.
Examples: only notes and notes-v2.

cli/src/main.rs

@@ -1,14 +1,13 @@
 use std::io::Write;
 use std::path::PathBuf;
-use std::sync::Arc;
 
 use anyhow::{Context, Result, bail};
 use clap::{Parser, Subcommand};
 use include_dir::{Dir, include_dir};
 use serde_json::json;
 
-use sausage::world::{self, ActorMeta, VersionMeta, World};
-use sausage::{Broker, Host, cargo_actor, console, runtime};
+use sausage::world::{ActorMeta, World};
+use sausage::{Host, cargo_actor, console};
 
 /// The source of the agent actor. `init` builds it like any other actor.
 static AGENT_SOURCE: Dir<'_> = include_dir!("$CARGO_MANIFEST_DIR/../agent");
@@ -72,45 +71,28 @@ async fn init(dir: PathBuf) -> Result<()> {
     let console = ActorMeta { subscriptions: ["agent".to_string()].into(), ..world.read_meta(console::ID) };
     world.write_meta(console::ID, &console)?;
 
-    // The agent's private configuration. Only the agent can read /data.
+    // The agent's configuration, in its /data.
     world.ensure_actor_dirs("agent")?;
     let config = json!({"api": api, "base_url": base_url.trim_end_matches('/'), "model": model, "token": token});
     let config_path = world.data_dir("agent").join("config.json");
     std::fs::write(&config_path, serde_json::to_string_pretty(&config)?)?;
-    #[cfg(unix)]
-    {
-        use std::os::unix::fs::PermissionsExt;
-        std::fs::set_permissions(&config_path, std::fs::Permissions::from_mode(0o600))?;
-    }
 
-    let source = world.scratch_dir().join("seed").join("agent");
+    // The agent is an ordinary actor folder: `run` finds its `actor.wasm`,
+    // tests it, and installs it as version 1.
+    let source = world.source_dir("agent");
     std::fs::create_dir_all(&source)?;
     AGENT_SOURCE.extract(&source).context("extract agent source")?;
     println!("Building the agent actor (the first build takes a few minutes) …");
     let out = cargo_actor::Cargo::new(world.clone())?.build(&source).await.context("build agent")?;
-    println!("Built in {:.1} s.", out.seconds);
-
-    let broker = Broker::new(world.clone(), runtime::Runtime::new()?)?;
-    let meta = VersionMeta {
-        version: 1,
-        wasm: world.global_path(&out.wasm).unwrap_or_default(),
-        source: Some(source.display().to_string()),
-        built_by: Some(cargo_actor::ID.into()),
-        requested_by: "init".into(),
-        created_at: world::now(),
-        rejected: None,
-    };
-    broker.create_actor("agent", &out.wasm, Some(&source), meta, false).await?;
-    println!("World ready. Start it with: sausage run {}", dir.display());
+    std::fs::copy(&out.wasm, world.wasm_path("agent"))?;
+    println!("Built in {:.1} s. Start the world with: sausage run {}", out.seconds, dir.display());
     Ok(())
 }
 
 async fn run(dir: PathBuf) -> Result<()> {
     let host = Host::start(&dir).await?;
-    let rx = host.mailbox(console::ID);
-    let console = console::Console::new(host.broker.clone());
-    tokio::spawn(Arc::clone(&console).run_mailbox(rx));
-    console.run_input().await;
+    tokio::spawn(console::run_mailbox(host.mailbox(console::ID)));
+    console::run_input(host.broker.clone()).await;
     println!("Stopping actors …");
     host.stop().await;
     Ok(())