@vibelord/lanes 1.2.0 → 1.5.0

package/payload/lanes/libexec/tokens.py

@@ -1,8 +1,9 @@
 #!/usr/bin/env python3
-"""The Lanes design tokens: ONE table, rendered seven ways. The sidebar imports `sgr_table` (truecolor, 256, 16 or
-none); `--kdl`, `--css`, `--sh`, `--md`, `--js` and `--ghostty-dark|--ghostty-light` write the Zellij theme, the phone
-CSS, the viewer's shell colour sets, the docs tables, the phone's terminal palette and the optional Ghostty palette
-files between markers; `--check` fails when any committed block differs. Spec:
+"""The Lanes design tokens: ONE table, rendered eight ways. The sidebar imports `sgr_table` (truecolor, 256, 16 or
+none); `--kdl`, `--css`, `--sh`, `--md`, `--js`, `--ghostty-dark|--ghostty-light` and `--docs-css` write the Zellij
+theme, the phone CSS, the viewer's shell colour sets, the docs tables, the phone's terminal palette, the optional
+Ghostty palette files and the docs page's CSS (plan W10 W6) between markers; `--check` fails when any committed block
+differs. Spec:
 docs/superpowers/specs/2026-10-03-lanes-cockpit-design.md; palette v2 + the 256-colour set: cockpit v3 P1 (LNS-69).
 No third-party code; importable with no side effects."""
 import difflib
@@ -89,7 +90,21 @@ MARKS = {'cursor': ('▌', '|', 'accent'), 'viewing': ('›', '=', 'accent'), 'v
          # more`. The lowest of column 3's marks: pending, the viewports and the viewing mark win over it. Seven-bit
          # `^` is free in column 3 (`=` `2` `3` `~` are the others; the upload strip's `^` is no column-3 mark).
          'pinned': ('▲', '^', 'accent'),
-         'ok': ('✓', 'OK', 'tone-done'), 'fail': ('✗', 'X', 'tone-urgent')}
+         'ok': ('✓', 'OK', 'tone-done'), 'fail': ('✗', 'X', 'tone-urgent'),
+         # The docs cockpit on the upload strip (` ↑ uploads · ▤ docs 3  (U)`, plan W10 W7): the strip's own tone.
+         # Seven-bit `#` is free on that row (`^` uploads, `v` armed, `-` sep are the others).
+         'docs': ('▤', '#', 'ink-dim'),
+         # The fleet block (W11, spec 2026-10-11 §3), pinned above the upload strip: column 2 of each row says what
+         # the row is about — Throttle ⚙, a provider's subscription pool ◆, the host and its containers ▣ — in the
+         # row's worst tone; then a provider's availability bar, ten cells of usable ▰ · cooling ▱ · benched ▪ ·
+         # dead ·. The seven-bit twins are unique among the block's own marks and against every other mark its rows
+         # draw (`-` sep, `?` stale, `OK` / `!` / `X` the folded line's verdict). `#` stays the docs twin alone; the
+         # unicode `·` of a dead cell is the spec's (it shares the separator's glyph, never its place: a bar has no
+         # blank inside it).
+         'fleet-throttle': ('⚙', '@', 'ink-dim'), 'fleet-provider': ('◆', '*', 'ink-dim'),
+         'fleet-host': ('▣', '[', 'ink-dim'),
+         'bar-usable': ('▰', '=', 'tone-done'), 'bar-cooling': ('▱', '~', 'ink-dim'),
+         'bar-benched': ('▪', ':', 'tone-attention'), 'bar-dead': ('·', '.', 'ink-faint')}
 ECONOMY_TAIL = {'starving': ('⚠', '!', 'tone-attention'), 'downgraded': ('↓', 'v', 'tone-attention'), 'paid': ('$', '$', 'ink-dim')}
 MOBILE_AGENT_LABELS = {'needs_approval': 'Needs approval', 'needs_input': 'Needs you', 'working': 'Working',
                        'done': 'Done', 'errored': 'Error', 'shell': 'Shell', 'idle': 'Idle'}
@@ -242,6 +257,22 @@ def render_css():
     return '\n'.join(out) + '\n'
 
 
+# The docs page (plan W10 W6, LNS-107; web/docs.css) is its own HTML document, served by lanes-docsd, not the phone
+# shell: no html.lanes-mobile, no Zellij data-zj-theme. Its block puts the roles it paints on :root, dark by default and
+# light under the system's prefers-color-scheme, and only those roles (docs.css has a 2.5 KB cap; the full --css block
+# alone is 2 KB). test_docs_assets pins that docs.css uses exactly these.
+DOCS_ROLES = ('surface', 'surface-raised', 'line', 'ink', 'ink-dim', 'accent')
+
+
+def render_docs_css():
+    out = ['/* BEGIN lanes tokens (generated by libexec/tokens.py --docs-css; do not edit by hand) */', ':root {']
+    out += [f'  --lanes-{role}: {TOKENS["dark"][role]};' for role in DOCS_ROLES]
+    out += ['  color-scheme: dark;', '}', '@media (prefers-color-scheme: light) {', '  :root {']
+    out += [f'    --lanes-{role}: {TOKENS["light"][role]};' for role in DOCS_ROLES]
+    out += ['    color-scheme: light;', '  }', '}', '/* END lanes tokens */']
+    return '\n'.join(out) + '\n'
+
+
 # The painted roles as the viewer's shell variables (`tokens.sh`), in PAINTED order. LZ_DIM kept its v1 name.
 SH_NAMES = {'ink': 'LZ_INK', 'ink-dim': 'LZ_DIM', 'ink-faint': 'LZ_FAINT', 'accent': 'LZ_ACCENT',
             'tone-urgent': 'LZ_URGENT', 'tone-attention': 'LZ_ATTENTION', 'tone-working': 'LZ_WORKING',
@@ -333,14 +364,16 @@ def render_ghostty(variant):
 
 
 RENDERERS = {'kdl': render_kdl, 'css': render_css, 'sh': render_sh, 'md': render_md, 'js': render_js,
-             'ghostty-dark': lambda: render_ghostty('dark'), 'ghostty-light': lambda: render_ghostty('light')}
+             'ghostty-dark': lambda: render_ghostty('dark'), 'ghostty-light': lambda: render_ghostty('light'),
+             'docs-css': render_docs_css}
 TARGETS = {'kdl': 'zellij/config.kdl', 'css': 'web/mobile.css', 'sh': 'libexec/tokens.sh', 'md': 'docs/DESIGN.md',
            'js': 'web/mobile.js', 'ghostty-dark': 'client/ghostty/lanes-palette.conf',
-           'ghostty-light': 'client/ghostty/lanes-palette-light.conf'}
+           'ghostty-light': 'client/ghostty/lanes-palette-light.conf', 'docs-css': 'web/docs.css'}
 MARKERS = {'kdl': ('// BEGIN lanes tokens', '// END lanes tokens'), 'css': ('/* BEGIN lanes tokens', '/* END lanes tokens */'),
            'sh': ('# BEGIN lanes tokens', '# END lanes tokens'), 'md': ('<!-- BEGIN lanes tokens', '<!-- END lanes tokens -->'),
            'js': ('// BEGIN lanes tokens', '// END lanes tokens'),
-           'ghostty-dark': ('# BEGIN lanes tokens', '# END lanes tokens'), 'ghostty-light': ('# BEGIN lanes tokens', '# END lanes tokens')}
+           'ghostty-dark': ('# BEGIN lanes tokens', '# END lanes tokens'), 'ghostty-light': ('# BEGIN lanes tokens', '# END lanes tokens'),
+           'docs-css': ('/* BEGIN lanes tokens', '/* END lanes tokens */')}
 
 
 def render(kind):
@@ -392,7 +425,7 @@ def main(argv):
         return 0
     kind = argv[0].lstrip('-') if argv else ''
     if kind not in RENDERERS:
-        sys.exit('usage: tokens.py --kdl|--css|--sh|--md|--js|--ghostty-dark|--ghostty-light|--check|--write')
+        sys.exit('usage: tokens.py --kdl|--css|--sh|--md|--js|--ghostty-dark|--ghostty-light|--docs-css|--check|--write')
     sys.stdout.write(render(kind))
     return 0
 

package/payload/lanes/libexec/update.py

@@ -14,19 +14,33 @@ catalog — a failure there leaves the installed release running as it was. comm
 installed. Its steps run in this order, each whatever the ones before it returned, each bounded by STEP_TIMEOUT seconds
 (its whole process group is stopped when it does not finish):
   systemctl --user daemon-reload · lanes sync · systemctl --user restart lanes-statusd.service ·
-  systemctl --user try-restart <unit> for each optional service in TRY_RESTART (restarted only when it runs) ·
-  lanes install-container <name> for each container `lanes sync` recorded with a home volume (containers.json) ·
+  systemctl --user try-restart <unit> for each optional service in TRY_RESTART (restarted only when it runs), and
+  right after lanes-docsd's, `sh install/enable-docs.sh` of the tree (the docs page's pinned Mermaid, plan W10 W8:
+  DOCS_STEP; skipped for a tree that has no such script) ·
+  lanes install-container <name> for each container `lanes sync` recorded with a home volume (containers.json), then
+  for the Throttle daemon's container when sync did not record it (daemon_container: site.conf's
+  LANES_THROTTLE_CONTAINER, else the Throttle tab's; DEF-1961) — not run, a warning with `outcome: skipped`, when sync
+  or docker said that container is gone or has no home volume (daemon_gone) — run by the tree just
+  installed — it re-ships the container contract files, the Throttle pulse among them since 1.4.0 (plan W11 Track D:
+  so the pulse updates with the host; spec §2.1 has where its loop runs), after statusd's restart ·
   lanes reload-views (the viewports; sidebars swap by themselves, W9 U5) · lanes ensure --if-layout-changed (W9 U6).
-Step output goes to the log (`update/last.log`); stdout gets one line per step and a summary.
+Step output goes to the log (`update/last.log`); stdout gets one line per step and a summary, which names the Mermaid
+outcome (`mermaid ok`, `mermaid skipped: <reason>`, …) whenever its step ran.
 
 The record, `<state>/update/last.json` (DM-LANES-UPDATE-RECORD), is one JSON object {checked_at, latest, installed,
-previous, result, steps: [{name, rc[, warning]}], log}. result: `ok` every phase and step exited 0 or only warned;
-`partial` the release is installed but a step after the commit failed (also while the post-commit runs: it is written
-before the first step); `refused` a prerequisite, no installed release, or another install holding the install lock
-said no and nothing changed; `failed` nothing was installed. A warning (WARN_RC) is a step's own report of a condition
-the update neither caused nor can mend — `lanes sync` exiting 1 for a board with an error — recorded with its rc and
-`"warning": true`, never a failure. Keys it does not own (a rollback's mark, plan W9 U3) are kept. host-install.sh
-writes `refused`, `failed` and a `partial` commit through `record`; `post-commit` writes its own.
+previous, result, steps: [{name, rc[, warning][, outcome, reason]}], log}. result: `ok` every phase and step exited 0
+or only warned; `partial` the release is installed but a step after the commit failed (also while the post-commit
+runs: it is written before the first step); `refused` a prerequisite, no installed release, or another install holding
+the install lock said no and nothing changed; `failed` nothing was installed. A warning (WARN_RC) is a step's own
+report of a condition the update neither caused nor can mend — `lanes sync` exiting 1 for a board with an error;
+enable-docs exiting 1 (a prerequisite or the download), 3 (refused: no valid pin, a digest mismatch) or not finishing
+in STEP_TIMEOUT (the download) — recorded with its rc and `"warning": true`, never a failure. A step with outcomes
+(STEP_OUTCOMES: enable-docs) that did not exit 0 also records `outcome` (`skipped`, `refused`, or `failed` for any
+other status, which is a failure) and `reason`, the last line it wrote (else what its status says). The daemon
+container's install-container step, when not run (daemon_gone), records rc 1 (DAEMON_SKIP_RC), `"warning": true`,
+`outcome: skipped` and the reason. Keys it does not
+own (a rollback's mark, plan W9 U3) are kept. host-install.sh writes `refused`, `failed` and a `partial` commit through
+`record`; `post-commit` writes its own.
 
 The run lock, `<state>/update/.lock` (fix cycle 1 of W9 U2): every server install and update takes it before it writes
 anything — the log and the record included — and holds it to its end, so two runs never interleave a post-commit or
@@ -77,8 +91,8 @@ STEP_TIMEOUT = 300          # seconds per post-commit step; then its process gro
 STOP_WAIT = 5               # seconds between SIGTERM and SIGKILL of a step's process group, and after it
 # The optional services a post-commit restarts only when they run (`systemctl try-restart`), in this order. Each keeps
 # its enable state: an update never switches on a unit the operator left off (economy, notify, web: operator gates).
-TRY_RESTART = ('lanes-economy.service', 'lanes-notify.service', 'lanes-enrold.service', 'lanes-mobile.service',
-               'lanes-web.service', 'lanes-studio-host.service')
+TRY_RESTART = ('lanes-economy.service', 'lanes-notify.service', 'lanes-enrold.service', 'lanes-docsd.service',
+               'lanes-mobile.service', 'lanes-web.service', 'lanes-studio-host.service')
 RESULTS = ('ok', 'partial', 'refused', 'failed')
 OWNED = ('checked_at', 'latest', 'installed', 'previous', 'result', 'steps', 'log')   # the keys every record rewrites
 PARTIAL = 4                 # post-commit's exit status when a step failed (host-install.sh --update-only's as well)
@@ -90,7 +104,19 @@ REFUSED = 3                 # `lock`'s exit status when another run holds the ru
 # cmd_sync: `return 1 if failed`); counted as a failure, it would make every update `partial` for as long as such a
 # board exists, and `lanes update` re-run the whole post-commit on every tick (fix cycle 1 of W9 U2). Any other status
 # of the step — 124 no answer, 127 could not start, 128+N a signal — is a failure like any other.
-WARN_RC = {'sync': 1}
+# The docs page's pinned Mermaid (plan W10 W8, LNS-109) is the other: install/enable-docs.sh of the tree just installed,
+# run right after lanes-docsd's try-restart (the full install runs it right after lanes-docsd's restart). Never fatal:
+# Mermaid is optional (without it every fence shows its source), so its exit statuses 1 (a prerequisite is missing or
+# the download failed: skipped), 3 (refused: no valid pin in holders.lock, a digest mismatch; nothing installed) and
+# 124 (the download did not finish in STEP_TIMEOUT: skipped) are warnings; any other status (2 usage, 127 could not
+# start, a signal) is a failure like any other step's. An installed file with the pinned digest is kept: no download.
+DOCS_UNIT = 'lanes-docsd.service'
+DOCS_STEP = 'enable-docs'
+DOCS_SCRIPT = 'install/enable-docs.sh'
+WARN_RC = {'sync': (1,), DOCS_STEP: (1, 3, 124)}
+# The steps whose outcome the record and the summary name (any status not listed: `failed`).
+STEP_OUTCOMES = {DOCS_STEP: {0: 'ok', 1: 'skipped', 3: 'refused', 124: 'skipped'}}
+REASON_LIMIT = 300          # characters of a step's last line kept as its `reason` (a refusal names two digests)
 LOCK = 'update/.lock'       # the run lock, under the state directory
 MODES = ('update', 'install')
 RELEASE = re.compile(r'[0-9]+\.[0-9]+\.[0-9]+(?:[-+][0-9A-Za-z.+-]+)?\Z')
@@ -111,11 +137,14 @@ def utc(at=None):
 
 
 def step_entry(step):
-    """A record's step from (name, rc) or (name, rc, warning): {name, rc}, plus `"warning": true` for a warning."""
+    """A record's step from (name, rc), (name, rc, warning) or (name, rc, warning, extra): {name, rc}, plus
+    `"warning": true` for a warning, plus `extra` ({outcome, reason} of a step with outcomes that did not exit 0)."""
     name, rc, *rest = step
     entry = {'name': name, 'rc': int(rc)}
     if rest and rest[0]:
         entry['warning'] = True
+    if len(rest) > 1 and rest[1]:
+        entry.update(rest[1])
     return entry
 
 
@@ -128,6 +157,44 @@ def warned_steps(steps):
     return [entry['name'] for entry in map(step_entry, steps) if entry.get('warning')]
 
 
+def step_outcome(name, rc, said, timeout):
+    """{} for a step without outcomes (STEP_OUTCOMES) or one that exited 0, else {outcome, reason}: the outcome its
+    status names (`failed` when it names none) and `reason`, the last line `said` (its own output) holds, else what
+    the status says (describe)."""
+    outcomes = STEP_OUTCOMES.get(name)
+    if outcomes is None or rc == 0:
+        return {}
+    lines = [line for line in said.splitlines() if line.strip()]
+    reason = printable(lines[-1], REASON_LIMIT) if lines and rc not in (124, 127) else describe(rc, timeout)
+    return {'outcome': outcomes.get(rc, 'failed'), 'reason': reason}
+
+
+def step_said(log, start):
+    """What a step wrote to the log after byte `start`: run_step's `== argv` line and its `-> …` line left out."""
+    try:
+        with open(log, 'rb') as handle:
+            handle.seek(start)
+            text = handle.read().decode('utf-8', 'replace')
+    except OSError:
+        return ''
+    lines = text.splitlines()
+    if lines and lines[0].startswith('== '):
+        lines = lines[1:]
+    if lines and lines[-1].startswith('-> '):
+        lines = lines[:-1]
+    return '\n'.join(lines)
+
+
+def outcome_clause(steps):
+    """The summary's words for the steps with outcomes that ran: `; mermaid ok`, `; mermaid skipped: <reason>`, …"""
+    words = []
+    for entry in map(step_entry, steps):
+        if entry['name'] == DOCS_STEP:
+            outcome = entry.get('outcome') or ('ok' if entry['rc'] == 0 else 'failed')
+            words.append(f"; mermaid {outcome}" + (f": {entry['reason']}" if entry.get('reason') else ''))
+    return ''.join(words)
+
+
 def installed_tree(home=None):
     """The existing tree the `current` link names now (resolved), else None."""
     try:
@@ -225,6 +292,57 @@ def recorded_containers(state):
                   if L.IDENT.match(name) and isinstance(info, dict) and info.get('home'))
 
 
+THROTTLE_MONITOR = 'tools--throttle-monitor'    # lanes_lib.build_registry's Throttle tab; bin/lanes THROTTLE_MONITOR
+
+
+def daemon_container(state, home=None):
+    """The container the Throttle daemon (and so the Throttle pulse, plan W11) runs in, as bin/lanes throttle_container
+    names it — the one install-container starts the pulse in: LANES_THROTTLE_CONTAINER in
+    `<home>/.config/lanes/site.conf` (L.site_conf), else the container of `<state>/registry.json`'s Throttle tab; None
+    when neither names an identifier. Never this process's environment: a timer's update, a re-run and a rollback carry
+    none of it, and site.conf is where the operator names it. `lanes sync` records only the containers a board's repositories name (refresh_containers), so
+    a daemon container that hosts no board repository is not among recorded_containers (DEF-1961): post_commit adds it,
+    or the pulse there would keep the release it was first installed with."""
+    named = L.site_conf(home).get('LANES_THROTTLE_CONTAINER')
+    if named and L.IDENT.fullmatch(named):
+        return named
+    registry = L.read_json(Path(state) / 'registry.json', {})
+    tools = registry.get('tools') if isinstance(registry, dict) else None
+    named = next((tool.get('container') for tool in tools if isinstance(tool, dict)
+                  and tool.get('id') == THROTTLE_MONITOR and isinstance(tool.get('container'), str)
+                  and L.IDENT.fullmatch(tool['container'])), None) if isinstance(tools, list) else None
+    return named
+
+
+# The rc recorded for the daemon container's install-container step when it is not run (daemon_gone): the status
+# install-container exits with for that container (bin/lanes cmd_install_container: a LanesError, exit 1). Recorded as
+# a warning with `outcome: skipped` and the reason, never a failure.
+DAEMON_SKIP_RC = 1
+
+
+def daemon_gone(state, container, inspect=None):
+    """Why install-container cannot ship to the daemon's `container` (daemon_container) -> a reason, or None when it
+    may: nobody said it cannot (W11 Track D review). A name in site.conf or the Throttle tab outlives the container it
+    named (a `docker rm`, a rename); run, its install-container would exit 1 on every update, timer re-run and rollback,
+    leave each `partial` and the timer re-running the post-commit — the very thing recorded_containers keeps a gone
+    board container out of the steps for. From what `lanes sync` recorded when it recorded that container (no home
+    volume: it said so already), else from ONE docker inspect (`inspect`, default L.containers_info): docker answered it
+    does not exist, or it has no home volume. Docker giving no answer says nothing about it: None, and the step runs and
+    reports for itself, as a recorded container's does."""
+    document = L.read_json(Path(state) / 'containers.json', {})
+    if isinstance(document, dict) and isinstance(document.get(container), dict):
+        return None if document[container].get('home') else 'lanes sync recorded no home volume for it'
+    try:
+        answers = (L.containers_info if inspect is None else inspect)([container])
+    except (L.LanesError, subprocess.SubprocessError, OSError, ValueError):
+        return None
+    if not isinstance(answers, dict) or container not in answers:
+        return None
+    if answers[container] is None:
+        return 'docker has no such container'
+    return None if answers[container].get('home') else 'home volume not found'
+
+
 def describe(rc, timeout):
     return {124: f'no answer in {timeout:g} s', 127: 'could not start'}.get(rc, f'exit {rc}')
 
@@ -238,11 +356,12 @@ def count(names, noun):
 
 
 def post_commit(tree, state, log, steps=(), before=None, started=None, out=None, run=None, timeout=STEP_TIMEOUT,
-                systemctl='systemctl', environ=None, home=None):
+                systemctl='systemctl', environ=None, home=None, inspect=None):
     """Run the post-commit steps from `tree` (whose bin/lanes runs them) -> the record written. `steps` are the phases
     that ran before, [(name, rc)]. The record says `partial` before the first step, so a run killed half-way stays
     `partial`; after the last step (or an interrupt: a SystemExit or KeyboardInterrupt is recorded as the step's rc,
-    then raised again) it says `ok` when every phase and step exited 0 or only warned (WARN_RC), else `partial`."""
+    then raised again) it says `ok` when every phase and step exited 0 or only warned (WARN_RC), else `partial`.
+    `inspect` (default L.containers_info) is how daemon_gone asks docker about the daemon's container."""
     out = sys.stdout if out is None else out
     run = run_step if run is None else run
     steps = list(steps)
@@ -252,40 +371,66 @@ def post_commit(tree, state, log, steps=(), before=None, started=None, out=None,
     Path(log).parent.mkdir(parents=True, exist_ok=True)
     with open(log, 'a') as handle:
         def step(name, argv):
+            handle.flush()
+            start = os.fstat(handle.fileno()).st_size     # where this step's lines begin (O_APPEND: the end)
             try:
                 rc = run(argv, handle, timeout)
             except (KeyboardInterrupt, SystemExit) as error:
                 steps.append((name, interrupted_rc(error)))
                 print(f'FAIL  {name} (interrupted)', file=out, flush=True)
                 raise
-            warning = rc != 0 and WARN_RC.get(name) == rc
-            steps.append((name, rc, warning))
+            warning = rc != 0 and rc in WARN_RC.get(name, ())
+            handle.flush()
+            extra = step_outcome(name, rc, step_said(log, start) if rc and name in STEP_OUTCOMES else '', timeout)
+            steps.append((name, rc, warning, extra))
             print('ok    ' + name if rc == 0 else f"{'WARN' if warning else 'FAIL'}  {name} ({describe(rc, timeout)})",
                   file=out, flush=True)
+
+        def skip(name, reason):
+            # Not run: install-container would exit 1 for it (no such container, no home volume), every run, a
+            # condition the update neither caused nor can mend (DAEMON_SKIP_RC).
+            steps.append((name, DAEMON_SKIP_RC, True, {'outcome': 'skipped', 'reason': reason}))
+            print(f'WARN  {name} (skipped: {reason})', file=out, flush=True)
         try:
             step('daemon-reload', [systemctl, '--user', 'daemon-reload'])
             step('sync', [lanes, 'sync'])
             step('restart lanes-statusd', [systemctl, '--user', 'restart', 'lanes-statusd.service'])
             for unit in TRY_RESTART:
                 step('try-restart ' + unit[:-len('.service')], [systemctl, '--user', 'try-restart', unit])
-            for container in recorded_containers(state):
+                if unit == DOCS_UNIT and (Path(tree) / DOCS_SCRIPT).is_file():
+                    # `sh`, as the RUNBOOK runs it: a tree whose script lost its mode bit still installs Mermaid. A
+                    # tree from before W10 W6 (a rollback's) has no script: nothing to run, no step.
+                    step(DOCS_STEP, ['sh', str(Path(tree) / DOCS_SCRIPT)])
+            containers = recorded_containers(state)
+            for container in containers:
                 step('install-container ' + container, [lanes, 'install-container', container])
+            daemon = daemon_container(state, home)
+            if daemon and daemon not in containers:
+                gone = daemon_gone(state, daemon, inspect)
+                if gone:
+                    skip('install-container ' + daemon, gone)
+                else:
+                    step('install-container ' + daemon, [lanes, 'install-container', daemon])
             step('reload-views', [lanes, 'reload-views'])
             step('ensure', [lanes, 'ensure', '--if-layout-changed'])
             finished = True
         finally:
             ok = finished and not failed_steps(steps)
             document = write_record(state, 'ok' if ok else 'partial', steps, tree, before, log, started, environ, home)
-    failed, warned = failed_steps(steps), warned_steps(steps)
+    # A step with outcomes is named by its own clause (`; mermaid skipped: …`), not again among the warnings.
+    failed, warned = failed_steps(steps), [name for name in warned_steps(steps) if name not in STEP_OUTCOMES]
     was = f" (was {document['previous']})" if document['previous'] else ''
     warnings = f"; {count(warned, 'warning')}: {', '.join(warned)}" if warned else ''
-    if ok and not warned:
-        print(f"ok: lanes {document['installed']} installed{was}; every step ran — {record_path(state)}", file=out)
+    outcomes = outcome_clause(steps)
+    if ok and not warned_steps(steps):
+        print(f"ok: lanes {document['installed']} installed{was}; every step ran{outcomes} — {record_path(state)}",
+              file=out)
     elif ok:
-        print(f"ok: lanes {document['installed']} installed{was}; every step ran{warnings} — log {log}", file=out)
+        print(f"ok: lanes {document['installed']} installed{was}; every step ran{warnings}{outcomes} — log {log}",
+              file=out)
     else:
         print(f"partial: lanes {document['installed']} installed{was}; {count(failed, 'step')} failed: "
-              f"{', '.join(failed)}{warnings} — log {log}", file=out)
+              f"{', '.join(failed)}{warnings}{outcomes} — log {log}", file=out)
     return document
 
 
@@ -850,8 +995,8 @@ def update_main(args, key, out=None, environ=None, home=None, clock=None, output
 
 def timer_enabled(units):
     """Whether lanes-update.timer is enabled in one of the unit folders `units`: `<folder>/timers.target.wants/
-    lanes-update.timer`, the link `systemctl --user enable` makes, names an existing unit. A file read, as every other
-    doctor line is (doctor never asks systemctl)."""
+    lanes-update.timer`, the link `systemctl --user enable` makes, names an existing unit. A file read: this line
+    never asks systemctl (the web and docs lines do, one bounded `systemctl --user show` each)."""
     return any((Path(folder) / TIMER_WANTS / TIMER).exists() for folder in units)