Tell being away from giving up

Leaving was the only way out of a network, and it is the irreversible one:
it publishes a release and then removes the configuration, the secret, the
network's signed records, its cached hints and the protocol key it used.
What somebody usually wants before a reboot, a trip or an experiment is
the other thing — stop serving it and keep everything.

`tsunagi network stop <id>` closes that network's sessions, takes its
address off the interface and keeps it from starting again. Nothing is
announced, deliberately: to the others this device is away, which is an
ordinary condition they already handle, and the address and name it holds
stay reserved for it. `tsunagi network start <id>` resumes it where it left
off. Both are remembered, so a restart does what the last instruction said
rather than what the last command line happened to say.

Except when the command line says otherwise: `up --network X` starts X
whatever its stored state, because a command naming a network is an
instruction to run it. The banner now says which of the three happened —
`new`, `already here`, or `was stopped; this command starts it` — since
silently, that is a stop that comes back from the dead with nothing to
explain it.

The listing tells the three states apart too: running with its address,
stopped and kept, or configured and waiting for an agent to start. Each row
says what to type to move it, because "stop" and "leave" are a pair that
has to be easy to tell apart before the irreversible one is typed.

The local control protocol is 11.

Covered end to end against a running agent: stopping leaves it configured
and says so, stopping twice is the state asked for rather than an error,
starting brings it back, and the secret afterwards is the one from before —
so it is the same network and not a lookalike.

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

crates/tsunagi-cli/tests/network_cli.rs

@@ -124,3 +124,67 @@ fn a_bare_name_resumes_the_network_of_that_name_rather_than_inventing_one() {
     assert!(out.contains(&id), "the same network, not a new one: {out}");
     assert!(out.contains("already configured"), "{out}");
 }
+
+#[test]
+fn a_network_can_be_stopped_and_resumed_without_losing_anything() {
+    // Leaving gives everything up; stopping is being away. The difference
+    // is what somebody wants when they will be back.
+    let agent = start("resident", 45073);
+    let listed = agent.run(&["network"]);
+    let out = String::from_utf8_lossy(&listed.stdout).to_string();
+    let id = out
+        .lines()
+        .find(|line| line.contains("resident"))
+        .and_then(|line| line.split_whitespace().nth(1))
+        .expect("the network is listed")
+        .to_string();
+    let secret_before = agent.run(&["network", "secret", &id[..10]]);
+    let secret_before = String::from_utf8_lossy(&secret_before.stdout)
+        .trim()
+        .to_string();
+    assert!(secret_before.starts_with("tsn1"));
+
+    let stopped = agent.run(&["network", "stop", &id[..10]]);
+    assert!(
+        stopped.status.success(),
+        "{}",
+        String::from_utf8_lossy(&stopped.stderr)
+    );
+    assert!(
+        String::from_utf8_lossy(&stopped.stdout).contains("stopped `resident`"),
+        "{}",
+        String::from_utf8_lossy(&stopped.stdout)
+    );
+
+    // Still configured, and said to be stopped rather than missing.
+    let listed = String::from_utf8_lossy(&agent.run(&["network"]).stdout).to_string();
+    assert!(listed.contains(&id), "still configured: {listed}");
+    assert!(listed.contains("stopped"), "{listed}");
+
+    // Stopping what is stopped is the state asked for, not an error.
+    let again = agent.run(&["network", "stop", &id[..10]]);
+    assert!(again.status.success());
+    assert!(
+        String::from_utf8_lossy(&again.stdout).contains("already stopped"),
+        "{}",
+        String::from_utf8_lossy(&again.stdout)
+    );
+
+    let started = agent.run(&["network", "start", &id[..10]]);
+    assert!(started.status.success());
+    assert!(
+        String::from_utf8_lossy(&started.stdout).contains("started `resident`"),
+        "{}",
+        String::from_utf8_lossy(&started.stdout)
+    );
+    let listed = String::from_utf8_lossy(&agent.run(&["network"]).stdout).to_string();
+    assert!(listed.contains("running"), "{listed}");
+
+    // And nothing was given up on the way: the same network, same secret.
+    let secret_after = agent.run(&["network", "secret", &id[..10]]);
+    assert_eq!(
+        String::from_utf8_lossy(&secret_after.stdout).trim(),
+        secret_before,
+        "the secret is kept, so this is the same network"
+    );
+}