@passioncode-ai/passioncode 0.2.38 → 0.2.40

package/payload/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/check_service.py

@@ -6,6 +6,7 @@
   options: --services-dir DIR  --json  --skip-login
            --ca-file PEM  --connect HOST:PORT     (remote placement: trust a test CA; dial another address)
            --board-kit PATH                       (board.responder: the service's own fabric_board.py or fabric-board.mjs)
+           --repo PATH                            (dashboard.opens-in-host: the service's checkout)
 
 A remote placement (DEC-0019 — an online agent or dashboard at an https origin) is probed over
 TLS with the certificate verified: the well-known document must refuse a request without the
@@ -26,6 +27,16 @@ well-known `protocols` declares that it answers board requests. The rule checks
 runs the kit's fixture conversation (`fabric_board.self_check`, or `selfCheck` of a Node copy given with --board-kit):
 the whole conversation, a fenced accept and a board session without an epoch, with no Fabric. A live board is never
 touched; that smoke needs a disposable Fabric and is reported separately.
+
+Actions (fabric-actions/0.1, DEC-0121): `well-known.actions` holds a declared extensions/actions/0.1 to FAC-SEM-142,
+`interop.action-tools` fails a declared action whose tool tools/list does not serve (and a local service that declares
+actions with no MCP surface; a remote one there is NOT_RUN, its twin may be on A2A), and `dashboard.actions-declared`
+is NOT_RUN, never FAIL, for a dashboard that declares none (a read-only dashboard cannot declare an empty list).
+
+dashboard.opens-in-host (FAA-118, the operator rule of 2026-10-24): the service's checkout (--repo, else the one of
+the descriptor's source.repository that holds its commands, manifest or launchd job) opens the service's pages only
+through Fabric Dashboards. Tracked text files only, within a time budget; a browser opener aimed at its pages outside
+the confirmed not_installed fallback is a FAIL (the matcher: check_service_rules.py, "dashboard.opens-in-host").
 """
 
 from __future__ import annotations
@@ -69,6 +80,10 @@ from check_service_rules import _semver  # noqa: E402,F401 - moved (FAA-65)
 from check_service_rules import usage_problems  # noqa: E402,F401 - moved (FAA-65)
 from check_service_rules import same_repository  # noqa: E402,F401 - moved (FAA-65)
 from check_service_rules import merge_headers, session_cookie  # noqa: E402,F401 - FAA-115
+from check_service_rules import well_known_actions_verdict, action_tools_verdict, actions_declared_verdict  # noqa: E402 - DEC-0121
+from check_service_rules import opens_in_host_verdict, service_checkout  # noqa: E402 - FAA-118
+from check_service_rules import well_known_a2a_verdict, a2a_card_verdict  # noqa: E402 - DEC-0122
+import fabric_a2a as fa2  # noqa: E402 - DEC-0122
 
 
 class _PinnedHTTPS(http.client.HTTPSConnection):
@@ -85,9 +100,13 @@ class _PinnedHTTPS(http.client.HTTPSConnection):
 
 
 class Probe:
+    remote = False  # a probe built without __init__ (the tests' Probe.__new__) reads as local
+
     def __init__(self, descriptor_path: Path, descriptor: Dict[str, Any], services_dir: Path, skip_login: bool,
-                 ca_file: Optional[str] = None, connect: Optional[str] = None, board_kit: Optional[str] = None):
+                 ca_file: Optional[str] = None, connect: Optional[str] = None, board_kit: Optional[str] = None,
+                 repo: Optional[str] = None):
         self.board_kit = board_kit
+        self.repo = repo
         self.remote = fs.placement_of(descriptor) == "remote"
         self.ca_file = ca_file
         self.connect = connect
@@ -256,6 +275,10 @@ class Probe:
             self.add("well-known.connections", "FAIL" if view["reported"] else "PASS",
                      "; ".join(f["message"] for f in fcn.connections_rules(wk)[:5]) or
                      "%d connection(s), %d named in degraded[]" % (len(view["connections"]), failing))
+        # DEC-0121, FAC-SEM-142: every button's agent twin, declared; no declaration is NOT_RUN (D10).
+        self.add("well-known.actions", *well_known_actions_verdict(wk))
+        # DEC-0122: where the public Agent Card is; no member is NOT_RUN.
+        self.add("well-known.a2a", *well_known_a2a_verdict(wk))
         self.configuration_rule()
         svc = wk.get("service") or {}
         answered = "%s.%s" % (svc.get("id"), svc.get("instance"))
@@ -403,6 +426,23 @@ class Probe:
         self.add("usage.report", "FAIL" if problems else "PASS",
                  "; ".join(problems[:5]) if problems else "%d day(s), unknown cost kept null" % len(days or []))
 
+    # A2A (DEC-0122) ---------------------------------------------------------------
+    def a2a_rules(self) -> None:
+        """`a2a.card`: the public card read with no Authorization header and never the descriptor's token (D5); its
+        interfaces are never called. The verdict is check_service_rules.a2a_card_verdict."""
+        view = fa2.a2a_view(self.wk)
+        status, body, error = 0, b"", None
+        if view["valid"]:
+            # Non-ASCII and control characters the schema's path admits are sent percent-encoded.
+            target = urllib.parse.quote(view["path"], safe="".join(chr(c) for c in range(0x21, 0x7F)))
+            try:
+                status, _, body = self.request("GET", target)  # Host only: no token header is added here
+            except (OSError, ssl.SSLError, http.client.HTTPException) as exc:
+                error = str(exc) or type(exc).__name__
+        header, _ = fs.token_header(self.d.get("auth"), "")
+        self.add("a2a.card", *a2a_card_verdict(self.wk, status, body, remote=self.remote, origin=str(self.d.get("origin") or ""),
+                                               descriptor_header=header, error=error))
+
     # dashboard (fabric-dashboard/0.1, DEC-0036) --------------------------------
     def dashboard_rules(self) -> None:
         wk = self.wk or {}
@@ -428,6 +468,24 @@ class Probe:
                 note += " (kit %s is current: dashboard_kit.py status)" % current
         self.add("dashboard.declared", "PASS", note + "; the page itself: check_dashboard_layout.mjs")
 
+    def dashboard_page_rules(self) -> None:
+        """DEC-0121 and FAA-118: what a person can do on the dashboard, and where its pages open."""
+        self.add("dashboard.actions-declared", *actions_declared_verdict(self.wk or {}))  # D10: never a FAIL for absence
+        self.opens_in_host_rule()
+
+    def opens_in_host_rule(self) -> None:
+        """FAA-118: the checkout opens the service's pages only through Fabric Dashboards (decision D13)."""
+        dashboard = ((self.wk or {}).get("surfaces") or {}).get("dashboard")
+        if not isinstance(dashboard, dict):
+            self.add("dashboard.opens-in-host", "NOT_RUN", "no surfaces.dashboard: no page to open")
+            return
+        checkout, why = service_checkout(self.d, self.repo)
+        if checkout is None:
+            self.add("dashboard.opens-in-host", "NOT_RUN", why)
+            return
+        self.add("dashboard.opens-in-host", *opens_in_host_verdict(checkout, 0 if self.remote else self.port,
+                                                                   str(self.d.get("origin") or ""), str(dashboard.get("path") or "/")))
+
     def login_rules(self) -> None:
         dashboard = ((self.wk or {}).get("surfaces") or {}).get("dashboard")
         if not dashboard or not dashboard.get("login"):
@@ -544,11 +602,14 @@ class Probe:
                       else "no readable token")
             for rule in ("interop.output-schema-object", "interop.tools-match", "interop.job-tools", "interop.unknown-job", "interop.trace-propagation"):
                 self.add(rule, "NOT_RUN", reason)
+            self.add("interop.action-tools", *action_tools_verdict(self.wk, None, reason, no_surface=not mcp_surface,
+                                                                    remote=self.remote))
         else:
             try:
                 listing = self.mcp_call("tools/list", {})
             except (OSError, ValueError) as exc:
                 self.add("interop.tools-match", "FAIL", "tools/list failed: %s" % exc)
+                self.add("interop.action-tools", *action_tools_verdict(self.wk, None, "tools/list failed: %s" % exc))
                 listing = None
             if listing is not None:
                 sent = self.sent_traceparent
@@ -556,6 +617,7 @@ class Probe:
                 self.object_root_rule(tools)
                 self.tools_match_rule(capabilities, manifest_path, tools)
                 self.job_tools_rule(capabilities, tools)
+                self.add("interop.action-tools", *action_tools_verdict(self.wk, tools))  # DEC-0121 AP-1: the live twin
                 self.unknown_job_rule(list(tools))
                 self.trace_rule(listing, sent)
         self.events_trace_rule(self.events)
@@ -810,7 +872,9 @@ class Probe:
             self.network_rules()
             self.auth_rules()
             self.usage_rules()
+            self.a2a_rules()
             self.dashboard_rules()
+            self.dashboard_page_rules()
             self.login_rules()
             self.interop_rules()
             verdict, evidence = board_responder_verdict(self.wk, self.board_kit)
@@ -838,6 +902,7 @@ def main(argv: Optional[List[str]] = None) -> int:
     parser.add_argument("--ca-file", help="remote placement: trust this CA bundle instead of the system store (tests)")
     parser.add_argument("--connect", help="remote placement: dial HOST:PORT while speaking TLS to the origin's name (tests)")
     parser.add_argument("--board-kit", help="board.responder: the service's own fabric_board.py or fabric-board.mjs")
+    parser.add_argument("--repo", help="dashboard.opens-in-host: the service's checkout (default: found by source.repository)")
     args = parser.parse_args(argv)
     if not args.target and not args.descriptor:
         parser.print_usage(sys.stderr)
@@ -849,7 +914,7 @@ def main(argv: Optional[List[str]] = None) -> int:
     except (OSError, ValueError) as exc:
         print("No readable descriptor at %s: %s" % (path, exc), file=sys.stderr)
         return 1
-    results = Probe(path, descriptor, services_dir, args.skip_login, args.ca_file, args.connect, args.board_kit).run()
+    results = Probe(path, descriptor, services_dir, args.skip_login, args.ca_file, args.connect, args.board_kit, args.repo).run()
     failed = sum(r["verdict"] == "FAIL" for r in results)
     if args.json:
         print(json.dumps({"descriptor": str(path), "results": results, "failed": failed}, indent=2))

package/payload/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/check_service_rules.py

@@ -1,6 +1,7 @@
 """The probe's rules that read one thing and need no running service (FAA-65): a plist's marker and priority, the
-network guard's verdict, the board responder's fixture conversation, a session cookie's lifetime, a usage report, and
-whether two repository URLs name one repository. ``check_service.py`` runs them against a live service.
+network guard's verdict, the board responder's fixture conversation, a session cookie's lifetime, a usage report,
+whether two repository URLs name one repository, a service's actions declaration (DEC-0121) and whether its checkout
+opens its pages in a browser (FAA-118), and its A2A member and public Agent Card (DEC-0122). ``check_service.py`` runs them against a live service.
 Standard library only, Python 3.9+."""
 from __future__ import annotations
 
@@ -17,6 +18,8 @@ from typing import Any, Dict, Iterable, List, Optional, Tuple
 
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 import fabric_service as fs  # noqa: E402 - beside this file
+import fabric_actions as fa  # noqa: E402 - beside this file (DEC-0121)
+import fabric_a2a as fa2  # noqa: E402 - beside this file (DEC-0122)
 
 
 def plist_problems(plist: dict, label: object, token: object = None) -> list:
@@ -291,3 +294,369 @@ def same_repository(a: str, b: str) -> bool:
         u = re.sub(r"^[^@/]+@", "", u)
         return re.sub(r"\.git$", "", u).rstrip("/")
     return bool(a and b) and norm(a) == norm(b)
+
+
+# actions (fabric-actions/0.1, DEC-0121, FAC-SEM-142) ----------------------------------------
+_ACTIONS_KEY_PATH = "/extensions/" + fa.ACTIONS_EXTENSION_KEY.replace("~", "~0").replace("/", "~1")
+
+
+def _actions_place(instance_path: str) -> str:
+    """A finding's place inside the declaration (`/actions/1/id`), or the declaration itself."""
+    inner = instance_path[len(_ACTIONS_KEY_PATH):] if instance_path.startswith(_ACTIONS_KEY_PATH) else instance_path
+    return inner or "extensions/actions/0.1"
+
+
+def well_known_actions_verdict(wk: Any) -> Tuple[str, str]:
+    """`well-known.actions`: a declared extensions/actions/0.1 is FAC-SEM-142's (the kit's actions_extension_rules, the
+    contract's reader): its schema's, each id once, humanStep exactly when gate is human, every tool in a present
+    surfaces.mcp.capabilities. No declaration is NOT_RUN: dashboard.actions-declared says what that means."""
+    view = fa.actions_view(wk)
+    if not view["declared"]:
+        return "NOT_RUN", "no extensions/actions/0.1 declaration (DEC-0121 AP-1)"
+    findings = fa.actions_extension_rules(wk)
+    if findings:
+        return "FAIL", "; ".join("FAC-SEM-142 %s: %s" % (_actions_place(f["instancePath"]), f["message"]) for f in findings[:5])
+    gates: Dict[str, int] = {}
+    for action in view["actions"]:
+        gates[action["gate"]] = gates.get(action["gate"], 0) + 1
+    return "PASS", "%d action(s) (%s), FAC-SEM-142 holds" % (
+        len(view["actions"]), ", ".join("%d %s" % (n, g) for g, n in sorted(gates.items())))
+
+
+def action_tools_verdict(wk: Any, tools: Optional[Dict[str, Any]], why_not: str = "tools/list was not read",
+                         no_surface: bool = False, remote: bool = False) -> Tuple[str, str]:
+    """`interop.action-tools`: every declared action's tool is served by tools/list, the live surface (FAC-SEM-142
+    checks only the list the document names). `tools` None means no listing was read; `why_not` says why. A local
+    service that declares actions and has no MCP surface fails: every action has a tool on its agent surface
+    (DEC-0121 AP-1), and a local service's is MCP. A remote agent's surface may be A2A or MCP behind a gateway (the
+    contract's surfaces table), so there it is NOT_RUN. This goes beyond FAC-SEM-142, which reads only a present list."""
+    view = fa.actions_view(wk)
+    if not view["declared"]:
+        return "NOT_RUN", "no extensions/actions/0.1 declaration"
+    if not view["valid"]:
+        return "NOT_RUN", "the actions declaration is not readable (well-known.actions): a reader treats it as not declared"
+    if no_surface and remote:
+        return "NOT_RUN", ("%d action(s) declared and no MCP surface: a remote agent's twin may be on A2A or behind a "
+                           "gateway, which this probe does not read" % len(view["actions"]))
+    if no_surface:
+        return "FAIL", ("%d action(s) declared but the service has no MCP surface: buttons without an agent twin "
+                        "(DEC-0121 AP-1)" % len(view["actions"]))
+    if tools is None:
+        return "NOT_RUN", why_not
+    missing = ["%s (%s)" % (a["tool"], a["id"]) for a in view["actions"] if a["tool"] not in tools]
+    if missing:
+        return "FAIL", ("tools/list does not serve %s: a button without an agent twin (DEC-0121 AP-1)" % ", ".join(missing))
+    return "PASS", "%d declared action(s), every tool served by tools/list" % len(view["actions"])
+
+
+def actions_declared_verdict(wk: Any) -> Tuple[str, str]:
+    """`dashboard.actions-declared` (decision D10): a dashboard whose declaration FAC-SEM-142 accepts passes, one it
+    finds (unreadable, a repeated id, a step that disagrees with the gate, a tool the surface does not list) fails,
+    and one with none is NOT_RUN, never FAIL: a read-only dashboard cannot declare an empty list
+    (minItems 1), so absence proves no page-only button. Fabric Dashboards reports it (CT-126)."""
+    surfaces = wk.get("surfaces") if isinstance(wk, dict) else None
+    if not (isinstance(surfaces, dict) and surfaces.get("dashboard")):
+        return "NOT_RUN", "no surfaces.dashboard"
+    view = fa.actions_view(wk)
+    if not view["declared"]:
+        return "NOT_RUN", ("a dashboard with no extensions/actions/0.1 declaration: a read-only dashboard declares none "
+                           "(the list needs minItems 1), so its absence proves no page-only button; a dashboard with a "
+                           "button declares it and its agent twin (DEC-0121 AP-1). Fabric Dashboards reports it (CT-126)")
+    if not view["valid"]:
+        return "FAIL", "the dashboard's actions declaration is not readable, so a host treats it as not declared (well-known.actions)"
+    findings = fa.actions_extension_rules(wk)
+    if findings:
+        return "FAIL", "the dashboard's actions declaration breaks FAC-SEM-142 in %d place(s) (well-known.actions)" % len(findings)
+    return "PASS", "the dashboard declares %d action(s) with their tools (DEC-0121 AP-1)" % len(view["actions"])
+
+
+
+# A2A (DEC-0122; decisions D4 to D6 of the 0.51.0 brief) -------------------------------------------------------------
+def well_known_a2a_verdict(wk: Any) -> Tuple[str, str]:
+    """`well-known.a2a`: a present `surfaces.a2a` is the schema's (`{path, protocolVersion: "1.0"}`, nothing else). No
+    member is NOT_RUN: the member is a SHOULD for a service that serves a card, and nothing says this one does."""
+    view = fa2.a2a_view(wk)
+    if not view["declared"]:
+        return "NOT_RUN", "no surfaces.a2a: the service names no A2A Agent Card (DEC-0122)"
+    if not view["valid"]:
+        return "FAIL", "; ".join("%s %s: %s" % (f["instancePath"], f["keyword"], f["message"]) for f in view["findings"][:5])
+    return "PASS", "the public Agent Card at %s, A2A %s" % (view["path"], view["protocolVersion"])
+
+
+def a2a_card_verdict(wk: Any, status: int, body: bytes, *, remote: bool, origin: str, descriptor_header: str,
+                     error: Optional[str] = None) -> Tuple[str, str]:
+    """`a2a.card`: the public card, fetched at `surfaces.a2a.path` with no Authorization header and no descriptor
+    token (D5; the caller sends none). On a local placement it answers 200 with a JSON card; on a remote one 401 or
+    403 is a card that is not open, NOT_RUN, never a failure (DEC-0122 item 2: a host and a probe never report a
+    refusal as nonconformance). A card read is judged by fabric_a2a.agent_card_findings (D5, D6). The card's interfaces
+    are never called."""
+    view = fa2.a2a_view(wk)
+    if not view["declared"]:
+        return "NOT_RUN", "no surfaces.a2a: no card to read"
+    if not view["valid"]:
+        return "NOT_RUN", "surfaces.a2a is not readable (well-known.a2a): a host does not know where the card is"
+    where = "%s without the token" % view["path"]
+    if error is not None:
+        return "FAIL", "no answer at %s: %s" % (where, error)
+    if remote and status in (401, 403):
+        return "NOT_RUN", ("HTTP %d at %s: a card that is not open, gated by the service's own credentials or an "
+                           "identity proxy; a refusal is not nonconformance (DEC-0122 item 2)" % (status, where))
+    if status != 200:
+        return "FAIL", ("HTTP %d at %s: %s" % (status, where, "the public card answers 200" if remote else
+                        "on a local placement the public card answers without authentication (DEC-0122 item 2)"))
+    try:
+        card = json.loads(body)
+    except (ValueError, RecursionError):
+        return "FAIL", "the answer at %s is not JSON" % where
+    findings = fa2.agent_card_findings(card, origin=origin or None, remote=remote, descriptor_header=descriptor_header)
+    if findings:
+        return "FAIL", "; ".join("%s: %s" % (f["code"], f["message"]) for f in findings[:5]) + (
+            " (%d more)" % (len(findings) - 5) if len(findings) > 5 else "")
+    return "PASS", "%d interface(s), A2A %s, read at %s; no process member, secret or descriptor token scheme" % (
+        len(card["supportedInterfaces"]), fa2.A2A_PROTOCOL_VERSION, where)
+
+# dashboard.opens-in-host (FAA-118; the operator rule of 2026-10-24; decision D13) ----------------------------------
+# A service's own pages open only through Fabric Dashboards: the `open_link` of the fabric-dashboards MCP `link` tool,
+# opened with the host's `open` and `fallback=never`; a browser only on a confirmed `not_installed` host. The rule reads
+# the service's checkout, tracked text files only (`git grep -I`, no untracked file, no binary), within a time budget,
+# and reports a line that opens a browser at the service's pages. The matcher, kept precise on purpose:
+#
+# 1. An opener (`_OPENERS`): macOS `open -a <browser>` / `open -b <browser bundle id>` / `open <http(s) URL>` /
+#    `open $<...url|link|origin|dashboard|page...>`; `xdg-open`, `gio open`, `sensible-browser`, `x-www-browser`,
+#    `wslview`; Windows `start [""] <URL>`, `explorer <URL>`, `url.dll,FileProtocolHandler`; Python
+#    `webbrowser.open|open_new|open_new_tab|get(`; Electron `openExternal(`; a process call whose argv starts with one
+#    of those programs (`subprocess.run(["open", ...])`, `spawn("xdg-open", ...)`); and in a JavaScript or TypeScript
+#    file that imports the npm package `open`, a call of the name it was bound to (`open(...)`, never `x.open(...)`).
+#    Python's builtin `open(` and a page's `window.open(` are files and tabs, never an opener.
+# 2. Aimed at the service's pages: in code, the opener's line or one of the 5 lines before it (where a URL is built)
+#    names a loopback host (127.0.0.1, localhost, [::1], 0.0.0.0), the service's port as a whole number, its origin's
+#    host, its dashboard path (when it is not just "/") or its login path; or the opener's line names an identifier
+#    built on "dashboard" (`dashboard_url`, `openDashboard`; never the host app's name "Fabric Dashboards"). In prose
+#    the aim is on the opener's own line. An opener with no such aim (a docs site, a report file) is not this rule's.
+# 3. In prose (Markdown and the like) only code counts: a fenced block, or an inline code span (`open -a Safari ...`);
+#    "then open `http://localhost:3000`" is a sentence for a person. A prose line that forbids it (never, not, avoid,
+#    instead of, ...) is not a finding either.
+# 4. Not a finding: the host's own route (`fabric-dashboards://`, the "Fabric Dashboards" app, `open_link`,
+#    `native_link` on the line); the allowed fallback (`not_installed` on the line or the 5 before, or the gate's
+#    `browser_link` on the line); a comment line in code; and test, spec and fixture files, which plant raw opens on
+#    purpose.
+_BROWSERS = (r"(?:Safari(?: Technology Preview)?|Google Chrome(?: Canary| Dev| Beta)?|Chrome|Chromium|"
+             r"Firefox(?: Developer Edition| Nightly)?|Arc|Dia|Brave Browser|Brave|Microsoft Edge|Opera|Vivaldi|Orion|Zen)")
+_BUNDLES = (r"(?:com\.apple\.Safari\w*|com\.google\.Chrome\w*|org\.chromium\.Chromium|org\.mozilla\.firefox\w*|"
+            r"company\.thebrowser\.\w+|com\.brave\.Browser\w*|com\.microsoft\.edgemac\w*|com\.operasoftware\.Opera\w*|"
+            r"com\.vivaldi\.Vivaldi|com\.kagi\.kagimacOS)")
+_PROGRAMS = r"(?:open|xdg-open|wslview|sensible-browser|x-www-browser|gio|start|explorer(?:\.exe)?)"
+#: Where a shell command starts: a line, a separator, `$(`, a Makefile's `@`, `then`, `do`, `else` or cmd's `/c`, or
+#: right after an opening quote or backtick (a string a process call runs). `playwright-cli open <url>` is that tool's
+#: own subcommand, and `--proxy "http://..." open` an argument after a closing quote.
+_CMD = r"(?:(?:^|[;&|({@]|\$\(|\bthen\b|\bdo\b|\belse\b|/[cC]\b)\s*|[`'\"])"
+_OPENERS = re.compile("|".join((
+    _CMD + r"open\s+(?:-[a-zA-Z]+\s+)*-a\s+[\"']?" + _BROWSERS + r"(?![\w-])",
+    _CMD + r"open\s+(?:-[a-zA-Z]+\s+)*-b\s+[\"']?" + _BUNDLES,
+    _CMD + r"open\s+(?:-[gnF]\s+)*[\"'`]?(?:https?://|\$\{?\w*(?i:url|link|origin|dashboard|page)\w*)",
+    r"(?<![\w.$/-])(?:xdg-open|gio\s+open|sensible-browser|x-www-browser|wslview)(?![\w-])",
+    _CMD + r"start\s+(?:\"\"\s+)?[\"']?https?://",
+    _CMD + r"explorer(?:\.exe)?\s+[\"']?https?://",
+    r"url\.dll,\s*FileProtocolHandler",
+    r"\bwebbrowser\.(?:open|open_new|open_new_tab|get)\(",  # a call, never "webbrowser.open (the default)" in prose
+    r"\bopenExternal\(",
+    r"(?:spawn|spawnSync|execFile|execFileSync|exec|execSync|Popen|run|call|check_call|check_output)\s*\(\s*\[?\s*"
+    r"[\"'`]" + _PROGRAMS + r"[\"'`]\s*[,)\]]",
+)))
+_OPEN_PACKAGE = re.compile(r"""import\s+(\w+)\s+from\s+["']open["']|(?:const|let|var)\s+(\w+)\s*=\s*require\(\s*["']open["']\s*\)""")
+_JS_FILES = (".js", ".mjs", ".cjs", ".jsx", ".ts", ".mts", ".cts", ".tsx")
+_PROSE_FILES = (".md", ".markdown", ".mdx", ".rst", ".txt", ".adoc", ".org")
+_LOOPBACK = re.compile(r"(?:127\.0\.0\.1|\blocalhost\b|\[::1\]|0\.0\.0\.0)(?::(\d{1,5}))?")
+_HOST_ROUTE = re.compile(r"fabric-dashboards://|Fabric Dashboards|\b(?:open_link|openLink|native_link|nativeLink)\b")
+_FALLBACK = re.compile(r"\bnot[_-]installed\b|\bnotInstalled\b|\bNOT_INSTALLED\b")
+_GATE_LINK = re.compile(r"\b(?:browser_link|browserLink)\b")
+_NEGATION = re.compile(r"(?i)\b(?:never|not|don't|doesn't|avoid|instead of|forbidden|refused?|wrong|no longer|nonconformant)\b")
+_COMMENT = re.compile(r"\s*(?:#(?!!)|//|/\*|\*|<!--|REM\s|::)")
+_TEST_PATH = re.compile(r"(?:^|/)(?:tests?|__tests__|specs?|fixtures|testdata|e2e)/|(?:^|/)(?:test_[^/]*\.py|[^/]*_test\.\w+|"
+                        r"[^/]*\.(?:test|spec)\.\w+|conftest\.py)\Z")
+_WINDOW = 5  # lines before an opener that may hold its aim or the not_installed branch
+OPENS_IN_HOST_BUDGET = 3.0  # seconds for git and reading, as the session-start notice budgets its own git calls
+_MAX_CANDIDATES = 2000
+_MAX_FILE_BYTES = 1 << 20
+_COARSE = (r"open[[:space:]]+-[ab][[:space:]]|open[[:space:]]+[\"'`]?(https?://|\$)|xdg-open|gio[[:space:]]+open|"
+           r"sensible-browser|x-www-browser|wslview|start[[:space:]]+(\"\"[[:space:]]+)?[\"']?https?://|"
+           r"explorer(\.exe)?[[:space:]]+[\"']?https?://|FileProtocolHandler|webbrowser\.|openExternal|"
+           r"[\"'`](open|xdg-open|wslview|start|explorer)[\"'`]")
+
+
+def _aims(lines: List[str], port: int, host: str, dashboard_path: str) -> bool:
+    text = "\n".join(lines)
+    if "/fabric/v1/login" in text:
+        return True
+    # A loopback address is this service's only with its port or with none: another port is another local tool.
+    if any(m.group(1) is None or not port or int(m.group(1)) == port for m in _LOOPBACK.finditer(text)):
+        return True
+    if port and re.search(r"(?<!\d)%d(?!\d)" % port, text):
+        return True
+    if host and host in text:
+        return True
+    return bool(dashboard_path and dashboard_path != "/" and re.search(re.escape(dashboard_path) + r"(?![\w-])", text))
+
+
+#: Text before an opener that makes it a message for a person: `echo "... open http://..."`, print, a log call.
+_MESSAGE = re.compile(r"\b(?:echo|printf|print|puts|say)\b|\bconsole\.\w+\s*\(|\blog(?:ger)?\.\w+\s*\(|\blog\s*\(")
+_IDENTIFIER = re.compile(r"[A-Za-z_][A-Za-z0-9_]*")
+_FENCE = re.compile(r"\s*(?:```|~~~)")
+
+
+def _names_dashboard(line: str) -> bool:
+    """An identifier built on "dashboard" (dashboard_url, openDashboard), never the word alone or the host's name."""
+    return any("dashboard" in word.lower() and word.lower() not in ("dashboard", "dashboards")
+               for word in _IDENTIFIER.findall(line.split("://", 1)[0]))
+
+
+def _prose_code(lines: List[str]) -> List[str]:
+    """Each line of a prose file reduced to its code: whole inside a fenced block, else its inline code spans."""
+    out, fenced = [], False
+    for line in lines:
+        if _FENCE.match(line):
+            fenced = not fenced
+            out.append("")
+        elif fenced:
+            out.append(line)
+        else:
+            out.append(" ; ".join(re.findall(r"`([^`]+)`", line)))  # each span its own command
+    return out
+
+
+def opener_findings(path: str, text: str, port: int, origin: Optional[str], dashboard_path: Optional[str]) -> List[Tuple[int, str]]:
+    """The lines of one file (repository-relative `path`, its `text`) that open a browser at the service's pages, as
+    (line number, line); the matcher is described above. Never raises on what it reads."""
+    path = (path or "").replace("\\", "/")
+    if not isinstance(text, str) or _TEST_PATH.search(path):
+        return []
+    prose = path.lower().endswith(_PROSE_FILES)
+    calls = None
+    if path.lower().endswith(_JS_FILES):
+        names = [a or b for a, b in _OPEN_PACKAGE.findall(text)]
+        if names:
+            calls = re.compile(r"(?<![\w.$])(?:%s)\s*\(" % "|".join(re.escape(n) for n in names))
+    host = ""
+    if isinstance(origin, str) and "://" in origin:
+        host = origin.split("://", 1)[1].split("/", 1)[0].rsplit("@", 1)[-1]
+        if _LOOPBACK.fullmatch(host.rsplit(":", 1)[0]):
+            host = ""  # a loopback origin is covered by the loopback hosts and the port
+    original = text.splitlines()
+    lines = _prose_code(original) if prose else original
+    out: List[Tuple[int, str]] = []
+    for index, line in enumerate(lines):
+        match = _OPENERS.search(line) or (calls.search(line) if calls is not None and not _OPEN_PACKAGE.search(line) else None)
+        if match is None or _MESSAGE.search(line[:match.start()]):
+            continue
+        if _HOST_ROUTE.search(line) or _GATE_LINK.search(line):
+            continue
+        if (prose and _NEGATION.search(original[index])) or _COMMENT.match(line):
+            continue
+        window = lines[max(0, index - _WINDOW):index + 1]
+        if any(_FALLBACK.search(w) for w in window):
+            continue
+        aim = [line] if prose else window
+        if _aims(aim, port, host, str(dashboard_path or "")) or _names_dashboard(line):
+            out.append((index + 1, original[index].strip()))
+    return out
+
+
+def opens_in_host_verdict(repo: Path, port: int, origin: Optional[str], dashboard_path: Optional[str],
+                          budget: float = OPENS_IN_HOST_BUDGET) -> Tuple[str, str]:
+    """`dashboard.opens-in-host` over one checkout: FAIL with the places a tracked text file opens a browser at the
+    service's pages, PASS when none does, NOT_RUN when the checkout or git cannot be read or the budget runs out."""
+    until = time.monotonic() + max(0.0, budget)
+    if not shutil.which("git"):
+        return "NOT_RUN", "git is not installed"
+
+    def left() -> float:
+        return until - time.monotonic()
+
+    if left() <= 0:
+        return "NOT_RUN", "the %.1f s budget ran out before the checkout was read" % budget
+    try:
+        top = subprocess.run(["git", "-C", str(repo), "rev-parse", "--show-toplevel"], capture_output=True, text=True,
+                             timeout=max(0.05, left()))
+        if top.returncode != 0 or not top.stdout.strip():
+            return "NOT_RUN", "%s is not a Git checkout" % repo
+        root = Path(top.stdout.strip())
+        if left() <= 0:
+            return "NOT_RUN", "the %.1f s budget ran out before the checkout was read" % budget
+        listed = subprocess.run(["git", "-C", str(root), "grep", "-I", "-l", "-z", "-E", _COARSE], capture_output=True,
+                                timeout=max(0.05, left()))
+    except subprocess.TimeoutExpired:
+        return "NOT_RUN", "the %.1f s budget ran out while git read %s" % (budget, repo)
+    except OSError as exc:
+        return "NOT_RUN", "git could not read %s: %s" % (repo, exc)
+    if listed.returncode not in (0, 1):  # 1: nothing matched
+        return "NOT_RUN", "git grep could not read %s" % root
+    candidates = [p for p in listed.stdout.decode("utf-8", "surrogateescape").split("\0") if p]
+    if len(candidates) > _MAX_CANDIDATES:
+        return "NOT_RUN", "%d candidate files in %s, more than the %d this rule reads" % (len(candidates), root, _MAX_CANDIDATES)
+    found: List[str] = []
+    for name in candidates:
+        if left() <= 0:
+            return "NOT_RUN", "the %.1f s budget ran out after reading part of %s" % (budget, root)
+        try:
+            with open(root / name, "rb") as handle:
+                text = handle.read(_MAX_FILE_BYTES).decode("utf-8", "replace")
+        except OSError:
+            continue
+        found += ["%s:%d %s" % (name, line, snippet[:100]) for line, snippet in opener_findings(name, text, port, origin, dashboard_path)]
+    if found:
+        return "FAIL", ("%s. Open the service's pages through Fabric Dashboards: the open_link of the fabric-dashboards MCP "
+                        "link tool, opened with fallback=never; a browser only on a confirmed not_installed host "
+                        "(operator rule of 2026-10-24)" % "; ".join(found[:5] + (["and %d more" % (len(found) - 5)] if len(found) > 5 else [])))
+    return "PASS", ("%d tracked text file(s) in %s name a possible opener; none opens a browser at the service's pages: "
+                    "they open through Fabric Dashboards" % (len(candidates), root))
+
+
+def _git_out(cwd: Path, *args: str) -> Optional[str]:
+    try:
+        done = subprocess.run(["git", "-C", str(cwd)] + list(args), capture_output=True, text=True, timeout=2.0)
+    except (OSError, subprocess.SubprocessError):
+        return None
+    return done.stdout.strip() if done.returncode == 0 and done.stdout.strip() else None
+
+
+def service_checkout(descriptor: Any, repo: Optional[str]) -> Tuple[Optional[Path], str]:
+    """The service's checkout: `repo` (the probe's --repo) when given, else the checkout holding one of the
+    descriptor's paths (its commands, its fabricManifest, its launchd job's program and working directory) whose origin
+    is the descriptor's `source.repository`. (None, why) when there is none."""
+    if repo:
+        top = _git_out(Path(repo).expanduser(), "rev-parse", "--show-toplevel")
+        return (Path(top), "--repo") if top else (None, "--repo %s is not a Git checkout" % repo)
+    d = descriptor if isinstance(descriptor, dict) else {}
+    own = d.get("source")
+    source = own.get("repository") if isinstance(own, dict) else None
+    if not isinstance(source, str) or not source:
+        return None, "the descriptor names no source.repository to find the service's checkout by; pass --repo"
+    places: List[str] = []
+    commands = d.get("commands")
+    for argv in (commands.values() if isinstance(commands, dict) else []):
+        places += [a for a in argv if isinstance(a, str)] if isinstance(argv, list) else []
+    if isinstance(d.get("fabricManifest"), str):
+        places.append(d["fabricManifest"])
+    life = d.get("lifecycle") if isinstance(d.get("lifecycle"), dict) else {}
+    if isinstance(life.get("plist"), str):
+        try:
+            import plistlib
+            plist = plistlib.loads(Path(life["plist"]).expanduser().read_bytes())
+            places += [a for a in (plist.get("ProgramArguments") or []) if isinstance(a, str)]
+            places += [plist["WorkingDirectory"]] if isinstance(plist.get("WorkingDirectory"), str) else []
+        except (OSError, ValueError, AttributeError, TypeError, plistlib.InvalidFileException):
+            pass
+    seen = set()
+    for place in places:
+        if not (place.startswith(("/", "~")) or re.match(r"[A-Za-z]:[\\/]", place)):
+            continue
+        start = Path(os.path.expanduser(place))
+        while not start.is_dir() and start != start.parent:
+            start = start.parent
+        top = _git_out(start, "rev-parse", "--show-toplevel")
+        if not top or top in seen:
+            continue
+        seen.add(top)
+        if same_repository(_git_out(Path(top), "remote", "get-url", "origin") or "", source):
+            return Path(top), "the checkout of %s that holds %s" % (source, place)
+    return None, "no checkout of %s holds the descriptor's commands, manifest or launchd job; pass --repo" % source