Configuration You Regenerate

# labs/service_unit.py
SERVICE_TEMPLATE = """[Unit]
Description=GLaDOS voice assistant
After=network.target

[Service]
Type=simple
User={user}
WorkingDirectory={work_dir}
ExecStart={python} {script}

[Install]
WantedBy=multi-user.target
"""

if __name__ == "__main__":
    print(SERVICE_TEMPLATE.format(
        user="kryo",
        work_dir="/home/kryo/src/GladOS",
        python="/home/kryo/src/GladOS/.venv/bin/python",
        script="/home/kryo/src/GladOS/labs/wire_core.py",
    ))

$ uv run python labs/service_unit.py
[Unit]
Description=GLaDOS voice assistant
After=network.target

[Service]
Type=simple
User=kryo
WorkingDirectory=/home/kryo/src/GladOS
ExecStart=/home/kryo/src/GladOS/.venv/bin/python /home/kryo/src/GladOS/labs/wire_core.py

[Install]
WantedBy=multi-user.target

A unit file is an INI file: named sections, one Key=Value per line. Most of it is structure that is identical on every machine in the world, and exactly four values differ. Splitting those four out as {} placeholders means the structure gets written once, correctly, and every later stage in this chapter only improves where the four values come from. Right now they come from your fingers, which is why this version is correct on precisely one computer.

import getpass
import sys
from pathlib import Path

PROJECT_ROOT = Path(__file__).resolve().parents[1]
ENTRY_SCRIPT = PROJECT_ROOT / "labs" / "wire_core.py"


def unit_values() -> dict[str, str]:
    return {
        "user": getpass.getuser(),
        "work_dir": str(PROJECT_ROOT),
        "python": sys.executable,
        "script": str(ENTRY_SCRIPT),
    }


if __name__ == "__main__":
    for key, value in unit_values().items():
        print(f"{key:9} {value}")

$ uv run python labs/service_unit.py
user      kryo
work_dir  /home/kryo/src/GladOS
python    /home/kryo/src/GladOS/.venv/bin/python
script    /home/kryo/src/GladOS/labs/wire_core.py

Four hand-typed strings became four questions with authoritative answers. sys.executable is the absolute path of the interpreter running this line, so under uv run it is the workspace venv and the generator cannot disagree with the environment it was launched in. Path(__file__).resolve().parents[1] walks up from labs/service_unit.py to the project root, so a clone in a different directory produces the right answer with no edit. getpass.getuser() checks the usual environment variables and falls back to the system password database, so it still answers on a Pi that booted with nobody logged in. Your four lines will read differently from mine; that is the point.

from labs.system_config import SystemConfig, load_config

CONFIG_PATH = PROJECT_ROOT / "configs" / "system_config.json"

# What each subsystem needs the operating system to have running first.
UNIT_REQUIREMENTS = {
    "llm": ["ollama.service"],
    "stt": ["sound.target"],
    "tts": ["sound.target"],
}


def ordering_lines(cfg: SystemConfig) -> list[str]:
    units = ["network.target"]
    for comp in cfg.components:
        if not comp.enabled:
            continue
        for unit in UNIT_REQUIREMENTS.get(comp.name, []):
            if unit not in units:
                units.append(unit)
    lines = [f"After={' '.join(units)}"]
    wants = [u for u in units if u.endswith(".service")]
    if wants:
        lines.append(f"Wants={' '.join(wants)}")
    return lines


if __name__ == "__main__":
    for line in ordering_lines(load_config(CONFIG_PATH)):
        print(line)

$ uv run python labs/service_unit.py
After=network.target sound.target ollama.service
Wants=ollama.service

$ uv run python labs/service_unit.py   # after setting "enabled": false on the llm component
After=network.target sound.target

This is the part a hand-written unit file can never keep true. The registry records which subsystems exist and which are switched on; the table above records what each one needs from the operating system. Compose them and the deployment follows the configuration by itself: switch the language model off for a listening-only build and the dependency on Ollama leaves the unit, with nothing to remember. After= and Wants= are different promises. After= is ordering only: if that unit is starting too, wait for it. Wants= actually pulls the other service up, so it belongs on ollama.service and not on sound.target, which is a milestone in the boot sequence and not something you can want.

# labs/service_unit.py -- full file
import difflib
import getpass
import socket
import sys
from pathlib import Path

from labs.system_config import SystemConfig, load_config

PROJECT_ROOT = Path(__file__).resolve().parents[1]
CONFIG_PATH = PROJECT_ROOT / "configs" / "system_config.json"
ENTRY_SCRIPT = PROJECT_ROOT / "labs" / "wire_core.py"
HEALTH_CHECK = PROJECT_ROOT / "glados" / "health_check.py"
GENERATED = Path("/tmp/glados.service")
INSTALLED = Path("/etc/systemd/system/glados.service")

UNIT_REQUIREMENTS = {
    "llm": ["ollama.service"],
    "stt": ["sound.target"],
    "tts": ["sound.target"],
}

SERVICE_TEMPLATE = """# Generated by labs/service_unit.py on {host}. Do not edit by hand.
[Unit]
Description=GLaDOS voice assistant
{ordering}

[Service]
Type=simple
User={user}
WorkingDirectory={work_dir}
Environment=PYTHONUNBUFFERED=1
Environment=GLADOS_CONFIG={config_path}
ExecStartPre={python} {health_check}
ExecStart={python} {script}
Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target
"""


def ordering_lines(cfg: SystemConfig) -> list[str]:
    units = ["network.target"]
    for comp in cfg.components:
        if not comp.enabled:
            continue
        for unit in UNIT_REQUIREMENTS.get(comp.name, []):
            if unit not in units:
                units.append(unit)
    lines = [f"After={' '.join(units)}"]
    wants = [u for u in units if u.endswith(".service")]
    if wants:
        lines.append(f"Wants={' '.join(wants)}")
    return lines


def render_unit(cfg: SystemConfig) -> str:
    if sys.prefix == sys.base_prefix:
        raise RuntimeError("not in the project venv: run with `uv run python labs/service_unit.py`")
    return SERVICE_TEMPLATE.format(
        host=socket.gethostname(),
        ordering="\n".join(ordering_lines(cfg)),
        user=getpass.getuser(),
        work_dir=PROJECT_ROOT,
        config_path=CONFIG_PATH,
        python=sys.executable,
        health_check=HEALTH_CHECK,
        script=ENTRY_SCRIPT,
    )


def check_installed(unit: str) -> int:
    if not INSTALLED.exists():
        print(f"{INSTALLED}: not installed yet")
        return 1
    current = INSTALLED.read_text()
    if current == unit:
        print(f"{INSTALLED}: matches this machine")
        return 0
    print("\n".join(difflib.unified_diff(
        current.splitlines(), unit.splitlines(),
        fromfile=str(INSTALLED), tofile="generated", lineterm="")))
    return 1


def main() -> int:
    unit = render_unit(load_config(CONFIG_PATH))
    if "--check" in sys.argv:
        return check_installed(unit)
    GENERATED.write_text(unit)
    print(unit)
    print(f"Wrote {GENERATED}")
    print(f"Install: sudo cp {GENERATED} {INSTALLED}")
    print("         sudo systemctl daemon-reload")
    print("         sudo systemctl enable --now glados")
    return 0


if __name__ == "__main__":
    sys.exit(main())

$ uv run python labs/service_unit.py --check
--- /etc/systemd/system/glados.service
+++ generated
@@ -10,7 +10,7 @@
 Environment=GLADOS_CONFIG=/home/kryo/src/GladOS/configs/system_config.json
 ExecStartPre=/home/kryo/src/GladOS/.venv/bin/python /home/kryo/src/GladOS/glados/health_check.py
-ExecStart=/home/kryo/src/GladOS/.venv/bin/python /home/kryo/src/GladOS/labs/voice_loop.py
+ExecStart=/home/kryo/src/GladOS/.venv/bin/python /home/kryo/src/GladOS/labs/wire_core.py
 Restart=on-failure
 RestartSec=10

Three additions earn their place. ExecStartPre runs the startup probe from chapter 33 first: if a model file is missing or Ollama is not answering, the probe exits non-zero, systemd never reaches ExecStart, and the reason lands in the log instead of a half-started assistant sitting there deaf. The header comment makes an installed unit name its own origin machine. And --check compares the installed file against what this project would generate right now, printing a diff and returning 1 when they differ; the run above came from a box whose unit still pointed at the old entry script. That turns "is the deployed configuration current?" into a command a timer can run instead of a question you answer by squinting.