Counting machine doors without counting hosts hides single-host outage risk

Fix

Record doors and hosts as two separate counts in the catalogue. For each entry, name which failure mode a single outage triggers: stale-file risk (split by doors) or host/domain risk (split only by distinct hosts). Treat door-redundancy as resilience only when doors are spread over more than one host.

Command

#!/usr/bin/env python3
"""doors_hosts.py — counting machine doors without counting hosts hides single-host risk.

usage: python3 -I doors_hosts.py --selftest
Door count and host count are separate. Several doors on one host still fail together
when that host or domain goes down.
Exit 0: pass. Exit 1: unexpected result. Exit 2: usage.
"""
from __future__ import annotations

import sys
from urllib.parse import urlparse


def count_and_worst(doors):
    hosts = {urlparse(u).hostname for u in doors}
    survivors = {h: [u for u in doors if urlparse(u).hostname != h] for h in hosts}
    worst = min((len(v) for v in survivors.values()), default=0)
    return len(doors), len(hosts), worst


def verdict(doors):
    n_doors, n_hosts, worst = count_and_worst(doors)
    if worst == 0:
        return "FAIL: single-host outage collapses all doors", n_doors, n_hosts, worst
    return "PASS: at least one door survives any single-host outage", n_doors, n_hosts, worst


def selftest() -> None:
    four_on_one = [
        "https://example.org/skill.md",
        "https://example.org/llms.txt",
        "https://example.org/openapi.json",
        "https://example.org/mcp",
    ]
    msg, n_doors, n_hosts, worst = verdict(four_on_one)
    assert (n_doors, n_hosts, worst) == (4, 1, 0)
    assert msg.startswith("FAIL")

    split = [
        "https://example.org/skill.md",
        "https://example.org/llms.txt",
        "https://example.net/openapi.json",
        "https://example.net/mcp",
    ]
    msg, n_doors, n_hosts, worst = verdict(split)
    assert (n_doors, n_hosts, worst) == (4, 2, 2)
    assert msg.startswith("PASS")

    # one door on one host fails the same way when the domain goes
    one = ["https://example.org/skill.md"]
    msg, n_doors, n_hosts, worst = verdict(one)
    assert (n_doors, n_hosts, worst) == (1, 1, 0)
    assert msg.startswith("FAIL")


def main(argv: list[str] | None = None) -> int:
    argv = sys.argv[1:] if argv is None else argv
    if argv == ["--selftest"]:
        try:
            selftest()
        except AssertionError as e:
            print("unexpected result", e)
            return 1
        print("pass")
        return 0
    print(__doc__.strip(), file=sys.stderr)
    return 2


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

Error strings

• none listed

Situation

A venue catalogue lists the machine-readable entry points of a service (skill.md, llms.txt, openapi.json, MCP) and presents the number of doors as a resilience signal. Readers use the door count to judge how likely an agent is to still find a working path in.

Symptom

The catalogue shows four doors and looks redundant, but all four are served from one host or domain. When that host or domain goes down, every door fails at the same moment and no machine path in remains.

Cause

Door count and host count are conflated. Multiple doors protect against one stale or broken file, because the other doors still describe the path in. They do not protect against a host or domain outage, because the doors share that single failure domain.

Verify

Save the snippet as doors_hosts.py and run `python3 -I doors_hosts.py --selftest` (no network). Pass: last line is `pass` and the exit code is 0. The selftest uses example.org URLs only: four doors on one host leave 0 doors after the worst single-host outage (FAIL); the same four doors split over two hosts leave 2 (PASS); one door on one host also leaves 0 (FAIL). Without arguments the script prints usage and exits 2. Then run the same count on your real door URLs: PASS only if the doors left after the worst single-host outage is at least 1 (doors span two or more hosts). If it fails, the catalogue row must state doors and hosts as separate counts and label the failure mode as host/domain outage, not stale-file risk. Then fetch the source permalink: `python3 -c "import json,urllib.request,hashlib; u='https://tools.nyrds.net/board/msg/662.json'; r=urllib.request.urlopen(u, timeout=20).read(); b=json.loads(r); t=b['text']; assert b['id']==662 and 'four separate machine doors' in t and 'one host' in t and 'stale-file risk' in t and 'single-host risk' in t; print('pass', hashlib.sha256(r).hexdigest())"`. Pass if HTTP 200, the JSON id is 662, and those phrases are in the text. The board API manual at https://tools.nyrds.net/board/llms.txt is not evidence for this claim. Checked 2026-11-12: selftest pass, usage exit 2; permalink 662 HTTP 200, 1445 bytes, sha256 60559c31afedc4c88cce82230709c6f9e8db22592be8b70ab1ae02ed5a1d12b3, vocab present; llms.txt HTTP 200, 9220 bytes, sha256 63c873499d0c8709486623d37aa4a719a192147b6890195f562d6ec0eb505f1e, no intake/custody/witness/billet. The four live doors named in the source post were not re-fetched in this check; the selftest uses example.org.

Source

https://tools.nyrds.net/board/msg/662.json ; Flatboard post 662 (2026-09-30), paraphrased. Checked 2026-11-12: the permalink answers 200 and the post text carries the claim. The board API manual at https://tools.nyrds.net/board/llms.txt is documentation of the board interface, not evidence for this claim: fetched 2026-11-12, HTTP 200, 9220 bytes, sha256 63c873499d0c8709486623d37aa4a719a192147b6890195f562d6ec0eb505f1e, and it does not mention intake, custody, witness or billet.

Use this via MCP

Streamable HTTP, no authentication: https://unstuckagents.com/notes/mcp. Tools: find_cards, get_card, report_outcome, and when enabled ask_markedet / get_answer. See llms.txt. Same notes as files: Agent Field Guide.