M5b plan: task 08, the self-test checks the tags against the tokenizer

loopd's self-test gains a check, run second (after "server matches
config", before any prompt): each tag in bxcore::sanitize::TAGS must be
one token from /tokenize, its recorded id, and its neutralised form
more than one. A failure names the tag by its id, never its text, and
points at a new runbook entry, loopd-tags-unexpected, given as a
fragment; SelfTestError::pointer picks the entry per failure. One
request per text (66): /tokenize has no batch form. The fake server
gains respond and a fake tokenizer; selftest.rs, serve.rs, pointers.rs
and support/mod.rs get M5b copies.

Checks, on a reference at ref 08 (titan, rustc 1.98.1, own target/):
- /tokenize fields from llama.cpp tools/server/README.md at b10964
  (b29c606) and its handler; on straylight all 33 tags gave their ids
  and every neutralised form 7 to 11 tokens, 66 requests in ~0.3 s
- given tests before the change: 4 fail as the task lists, selftest_tags
  does not compile (7 E0599); pointers passes
- make gate: gate: ok, 1050 tests (1042 + 8); /tmp and $TMPDIR
  unchanged around it; the four suites 25 runs under load, no failure
- 20 mutations, each caught: id not compared; neutralised check
  dropped; > 1 as >= 1, as == 1 missing 0, as > 2; first or last tag
  skipped; tag asked twice; pointer dropped or wrong (all or Tokenize);
  check skipped in serve; check run last; parse_special false;
  add_special left out; id missing from the message; the tag's text in
  the message; tokenize error as Infer; wrong count; wrong other id
- the task's edits applied to a fresh ref-07 copy give files
  byte-identical to the reference; every before block found once
- no chat-template tag whole in the task or given files; task lines
  within 100 characters except tables and verbatim lines; given files
  under 500 lines

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

docs/plans/M5b/files/crates/loopd/tests/serve.rs

@@ -0,0 +1,128 @@
+//! Tests for the `loopd serve` command. Do not edit.
+
+mod support;
+
+use std::os::unix::fs::PermissionsExt;
+use std::process::{Command, Stdio};
+use std::time::Duration;
+use support::{FakeServer, Home, Reply, tokenizer};
+
+fn config_file(home: &Home, server: &FakeServer, expect_slots: u32) -> std::path::PathBuf {
+    let text = format!(
+        r#"
+[infer]
+socket = "{}"
+model = "test-model"
+[slots]
+main = 0
+background = 1
+[expect]
+template_sha256 = "f55f52930aa8bf44ab5cb85f99370fcc3c56e9a85640b812086d5330bce5d86b"
+n_ctx = 131072
+slots = {expect_slots}
+[limits]
+poll_ms = 40
+liveness_ms = 500
+retry_backoff_ms = [10]
+[paths]
+home = "{}"
+"#,
+        server.socket.display(),
+        home.dir.display()
+    );
+    let path = home.dir.join("config.toml");
+    std::fs::write(&path, text).unwrap();
+    path
+}
+
+fn healthy_routes(server: &FakeServer) {
+    server.route("/props", vec![Reply::fixture("props")]);
+    server.respond("/tokenize", tokenizer);
+    server.route(
+        "/v1/chat/completions",
+        vec![
+            Reply::fixture("tool_call"),
+            Reply::fixture("turn1"),
+            Reply::fixture("turn2"),
+            Reply::fixture("plain"),
+        ],
+    );
+}
+
+#[test]
+fn serve_runs_the_self_test_then_binds_the_socket_with_mode_0600() {
+    let home = Home::new();
+    let server = FakeServer::start();
+    healthy_routes(&server);
+    let config = config_file(&home, &server, 2);
+    let socket = home.dir.join("run").join("loop").join("loop.sock");
+    let mut child = Command::new(env!("CARGO_BIN_EXE_loopd"))
+        .args(["serve", "--config"])
+        .arg(&config)
+        .stderr(Stdio::piped())
+        .spawn()
+        .unwrap();
+    let mut up = false;
+    for _ in 0..200 {
+        if socket.exists() {
+            up = true;
+            break;
+        }
+        std::thread::sleep(Duration::from_millis(50));
+    }
+    let mode = std::fs::metadata(&socket).map(|m| m.permissions().mode() & 0o777);
+    let _ = child.kill();
+    let output = child.wait_with_output().unwrap();
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(up, "the socket never appeared; stderr: {stderr}");
+    assert_eq!(mode.unwrap(), 0o600, "{stderr}");
+    assert!(stderr.contains("selftest: ok"), "{stderr}");
+    assert!(stderr.contains("serving on"), "{stderr}");
+    assert_eq!(
+        server.requests_to("/v1/chat/completions").len(),
+        3,
+        "the three self-test completions ran"
+    );
+    assert_eq!(
+        server.requests_to("/tokenize").len(),
+        2 * bxcore::sanitize::TAGS.len(),
+        "the tag check ran: each tag and its neutralised form"
+    );
+}
+
+#[test]
+fn serve_refuses_to_start_when_the_self_test_fails() {
+    let home = Home::new();
+    let server = FakeServer::start();
+    healthy_routes(&server);
+    let config = config_file(&home, &server, 3); // the fixture reports 2 slots
+    let output = Command::new(env!("CARGO_BIN_EXE_loopd"))
+        .args(["serve", "--config"])
+        .arg(&config)
+        .output()
+        .unwrap();
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert_eq!(output.status.code(), Some(1), "{stderr}");
+    assert!(stderr.contains("selftest: FAILED"), "{stderr}");
+    assert!(stderr.contains("slot count"), "{stderr}");
+    assert!(
+        !home.dir.join("run").join("loop").join("loop.sock").exists(),
+        "no socket was left behind"
+    );
+}
+
+#[test]
+fn usage_and_a_bad_config_are_reported() {
+    let output = Command::new(env!("CARGO_BIN_EXE_loopd"))
+        .arg("dance")
+        .output()
+        .unwrap();
+    assert_eq!(output.status.code(), Some(2));
+    assert!(String::from_utf8_lossy(&output.stderr).contains("usage"));
+    let output = Command::new(env!("CARGO_BIN_EXE_loopd"))
+        .args(["serve", "--config", "/nonexistent/config.toml"])
+        .output()
+        .unwrap();
+    assert_eq!(output.status.code(), Some(1));
+    assert!(String::from_utf8_lossy(&output.stderr).contains("config.toml"));
+}