@passioncode-ai/fabric-agent-adapter 0.82.0 → 0.83.1

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

@@ -3,7 +3,6 @@ accept the exact digest, effect, progress, complete; stop when fenced). The sess
 in fabric_board_link and are re-exported here. Part of the board connector (FAA-65, layer L4)."""
 from __future__ import annotations
 
-import inspect
 import json
 import random
 import re
@@ -28,6 +27,8 @@ from fabric_board_link import (  # noqa: E402,F401 - re-exported: callers import
     BoardSession,
     Checkpoint,
     PERSONAL_BOARD,
+    notice_subject as _notice_subject,
+    takes_subject as _takes_subject,
 )
 from fabric_board_slots import (  # noqa: E402,F401 - the slot records (FAA-155, FAA-163); the constants re-exported
     HOLD_RETRY_MAX_SECONDS,
@@ -51,6 +52,9 @@ IDLE_LEAVE_SECONDS = 3.0
 
 EVENT_SCHEMA = "urn:fabric:schema:board-responder-event:1"
 
+#: `board.down` is said once per outage window: said again only after the board stayed up this long (FAA-187 (22)).
+DOWN_QUIET_SECONDS = 300.0
+
 #: On these the attempt is no longer ours: stop acting at once (C4).
 STOP_CODES = frozenset(["fenced", "lease_expired", "authority_changed"])
 
@@ -60,8 +64,6 @@ TERMINAL = frozenset(["completed", "failed_known", "cancelled", "expired"])
 NOT_OURS = frozenset(["queued", "claimed", "answered"])
 
 
-
-
 class WorkContext:
     """What a handler may do while it works: `progress(note)` posts a note on the request's thread (and renews the
     lease); `begin_effect(summary)` must be called (and must return) before the handler spends or acts outside
@@ -70,12 +72,12 @@ class WorkContext:
     `mandate_covers(call)` whether it covers a call (`mandate_covers`' answer), None when none travelled."""
 
     def __init__(self, responder: "Responder", entry: Dict[str, Any], mandate: Optional[Dict[str, Any]] = None,
-                 caller: Optional[str] = None):
-        self._responder, self._entry, self.mandate, self._caller = responder, entry, mandate, caller
+                 caller: Optional[str] = None, caller_agent: Optional[str] = None):
+        self._responder, self._entry, self.mandate, self._caller, self._agent = responder, entry, mandate, caller, caller_agent
         self.stopped = threading.Event()
 
     def mandate_covers(self, call: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-        return _link.covers(self.mandate, call, self._responder.agent_id, self._responder.wall, self._caller)
+        return _link.covers(self.mandate, call, self._responder.agent_id, self._responder.wall, self._caller, self._agent)
 
     def progress(self, note: Optional[str] = None) -> None:
         if self.stopped.is_set():
@@ -100,33 +102,6 @@ class _Work:
 Handler = Callable[[BoardRequest, WorkContext], Dict[str, Any]]
 
 
-
-def _notice_subject(value: Dict[str, Any], project: str, episode: Optional[str] = None) -> Dict[str, str]:
-    """A notice's subject (`{type, id}`): its request, else its capability, else its episode (a cause such as a block's
-    code, so two causes are two episodes for a host, seam r31), else the Project."""
-    for kind, given in (("request", value.get("request")), ("capability", value.get("capability")), ("episode", episode)):
-        if isinstance(given, str) and 0 < len(given) <= 128:
-            return {"type": kind, "id": given}
-    return {"type": "project", "id": project}
-
-
-def _takes_subject(emit: Callable[..., Any]) -> bool:
-    """Whether an emit's signature names a `subject` parameter, as JsonlEventLog.append does. Any other emit (one with
-    only **kwargs, which may forward them to a sink without it or set its own, or one whose signature cannot be read)
-    is called as 0.55.0 called it, without one (0.56.0 unit r33). A subject already bound into the emit, as with
-    functools.partial(log.append, subject=...), stands.
-
-    The signature is the emit's own, not a wrapped function's: a functools.wraps forwarder that sets its own subject
-    would otherwise be passed a second one (0.56.0 unit r34). Nothing here raises, so a notice never stops the
-    responder."""
-    try:
-        params = inspect.signature(emit, follow_wrapped=False).parameters.values()
-        return any(p.name == "subject" and p.kind is not inspect.Parameter.VAR_KEYWORD
-                   and (p.default is inspect.Parameter.empty or p.default is None) for p in params)
-    except Exception:  # noqa: BLE001 - an unreadable signature (or a default that raises) is called without one
-        return False
-
-
 class Responder(SlotKeeper):
     """One service's responder for one Project and one or more capabilities, one request at a time.
 
@@ -142,9 +117,11 @@ class Responder(SlotKeeper):
                  emit: Optional[Callable[..., Any]] = None, service: str = "service",
                  now: Callable[[], float] = time.monotonic, rand: Callable[[], float] = random.random,
                  spawn: Optional[Callable[[Callable[[], None]], Any]] = None, session_factory: Optional[Callable[..., BoardSession]] = None,
-                 agent_id: Optional[str] = None, mandate_from: Any = None, wall: Callable[[], float] = time.time):
-        if admit is None or handler is None:
-            raise BoardError("invalid_arguments", "A responder needs the service's own input gate (admit) and a handler.")
+                 agent_id: Optional[str] = None, mandate_from: Any = None, wall: Callable[[], float] = time.time,
+                 identify_agent: Optional[Callable[[Dict[str, Any]], Optional[str]]] = None, links: Any = None):
+        if admit is None or handler is None or not (identify_agent is None or callable(identify_agent)):
+            raise BoardError("invalid_arguments", "A responder needs the service's own input gate (admit) and a handler; "
+                             "identify_agent, when given, is a function of the sender (FAA-135).")
         caps = list(capabilities)
         if not caps or any(not isinstance(c, str) or not _CAPABILITY.fullmatch(c) for c in caps) or len(set(caps)) != len(caps):
             raise BoardError("invalid_arguments", "Name each capability once, [a-z][a-z0-9._-]{1,127}.")
@@ -152,8 +129,10 @@ class Responder(SlotKeeper):
             raise BoardError("invalid_arguments", "%s is a Project's primary responder's, a session's: a service answers "
                              "the capabilities it declares (DEC-0140 PR-1)." % _fs.PRIMARY_CAPABILITY)
         self.hub, self.project = hub, _hub._project(project_id)
-        #: FAA-135: read the operator's mandate from a trusted request of his own Project (opt-in; None reads none).
+        #: FAA-135: read the operator's mandate from a trusted request of his own Project (opt-in; None reads none), and
+        #: bind its chain with the agent id identify_agent names for the sender (asked only when a mandate travelled).
         self.mandate_from, self.agent_id, self.wall = _link.mandate_options(agent_id, mandate_from), agent_id, wall
+        self.identify_agent, self.links = identify_agent, _link.notice_links(links)  # FAA-187 (21): a link per notify kind
         self.capabilities = caps
         self.credential_file, self.handler, self.admit, self.observe = Path(credential_file), handler, admit, observe
         self.checkpoint = Checkpoint(Path(checkpoint_file))
@@ -172,6 +151,7 @@ class Responder(SlotKeeper):
         self.claim_keys: Dict[str, str] = {}
         self._probing: set = set()  # moved slots whose move-back claim lost its answer: asked again under the same key
         self._said: Dict[str, str] = {}
+        self._up_since: Optional[float] = None  # when the board was last seen up after a fault (FAA-187 (22))
         self._rr = 0
         #: The first pause under an operator's hold (DEC-0079); it doubles to HOLD_RETRY_MAX_SECONDS.
         self.hold_delay = POLL_SECONDS
@@ -203,6 +183,8 @@ class Responder(SlotKeeper):
         # goes once, without a subject there (unit r31, seam r31).
         if _takes_subject(self._emit_to):
             extra["subject"] = _notice_subject(value, self.project, episode)
+        if notify and kind in getattr(self, "links", {}):  # the page that resolves it, which the service named (FAA-187 (21))
+            extra["link"] = self.links[kind]
         try:
             self._emit_to(kind, level, text, notify=notify, **extra)
         except Exception:  # noqa: BLE001 - an event that cannot be written never stops the responder
@@ -267,8 +249,8 @@ class Responder(SlotKeeper):
         self.slots = {}
         self._recover(status, [c for c in self.capabilities if c in grant.capabilities])
         self.state = "ready"
-        for kind in ("board.down", "board.blocked") + (() if missing else ("board.access.needed",)):
-            self._said.pop(kind, None)
+        for kind in ("board.blocked",) + (() if missing else ("board.access.needed",)):
+            self._said.pop(kind, None)  # board.down waits for its quiet window (step)
 
     def _enroll(self, capability: str) -> None:
         args = {"idempotency": self._idem(self._key("enroll")), "capability": capability}
@@ -525,6 +507,8 @@ class Responder(SlotKeeper):
             self.backoff.reset()
             if self.state == "down":  # a lost call was sent again and answered: the session held throughout
                 self.state = "ready"
+            self._up_since = now if self._up_since is None else self._up_since
+            if now - self._up_since >= DOWN_QUIET_SECONDS:  # up a whole window: a later outage is said again
                 self._said.pop("board.down", None)
             return self.interval()
         except (BoardError, _hub.HubError) as exc:
@@ -542,7 +526,7 @@ class Responder(SlotKeeper):
         return min(renewed) + LEASE_SECONDS - self.now() if renewed and self.session is not None else 0.0
 
     def _fault(self, exc: Exception) -> float:
-        code, slots = getattr(exc, "code", "unreachable"), self.slots.values()
+        code, slots, self._up_since = getattr(exc, "code", "unreachable"), self.slots.values(), None
         connecting = self.state == "connecting" and not any(s.get("state") == "held" for s in slots)
         wait = self.backoff.next()
         left = self._lease_left() - LEASE_MARGIN_SECONDS
@@ -613,10 +597,11 @@ class Responder(SlotKeeper):
         for capability in list(self._suspect):  # kept until com.status answered, so it is asked before any enroll
             self._gone(capability)
             self._suspect.discard(capability)
+        shared: Dict[str, Any] = {}  # one com.status read a tick for every moved slot (FAA-194 (5))
         for capability, slot in list(self.slots.items()):
             if slot.get("state") == "moved":  # never enrolled again on its own, even when the new holder lapses (FAA-155)
                 if self.now() - slot.get("renewed_at", 0) >= RENEW_SECONDS - 0.5:
-                    self._moved_back(capability)  # unless com.status shows a later generation it may hold (FAA-165)
+                    self._moved_back(capability, shared)  # unless com.status shows a later generation it may hold (FAA-165)
                 continue
             if slot.get("state") == "paused":
                 if capability != held_by_work and self.now() >= slot.get("retry_at", 0.0) and not self._gone(capability):
@@ -699,15 +684,14 @@ class Responder(SlotKeeper):
                  "revision": receipt["request"]["revision"], "step": "claimed", "keys": {}, "effect": False}
         self.checkpoint.put(entry)
         message = self._call("com.get", {"message": entry["message"]})
-        req = message.get("request") if isinstance(message, dict) else None
-        if message.get("digest") != entry["digest"]:
+        problem = _link.read_back_problem(message, entry, self.project)
+        if problem == "digest-mismatch":
             self.checkpoint.drop(entry["request"])
             self._emit("board.request.skipped", "warning", "A claimed request was not accepted: the message read back carries "
                        "another digest than the claim. Nothing was done; the claim lapses.", request=entry["request"],
                        capability=capability, reason="digest-mismatch")
             return
-        if not isinstance(req, dict) or req.get("id") != entry["request"] or req.get("capability") != capability \
-                or req.get("target") != self.project:
+        if problem:
             self.checkpoint.drop(entry["request"])
             self._emit("board.request.skipped", "warning", "A claimed request was not accepted: it is not addressed to this "
                        "Project and capability. Nothing was done; the claim lapses.", request=entry["request"],
@@ -754,12 +738,15 @@ class Responder(SlotKeeper):
         self.checkpoint.put(entry)
         return True
 
-    def _run(self, entry: Dict[str, Any], request: BoardRequest) -> None:
+    def _run(self, entry: Dict[str, Any], request: BoardRequest, problem: Optional[str] = None) -> None:
         mandate, unread = _link.read_mandate(request, self.mandate_from, self.agent_id)
+        if problem and (mandate is not None or unread):  # FAA-196 (1): a resume read back another message than accepted
+            mandate, unread = None, problem
         if unread:  # by its code alone: the block holds the operator's words
             self._emit("board.request.mandate_unread", "warning", "Request %s carries a mandate the kit does not read (%s); "
                        "it is worked without one." % (entry["request"], unread), request=entry["request"], reason=unread)
-        ctx = WorkContext(self, entry, mandate, request.sender.get("project") if isinstance(request.sender, dict) else None)
+        sender = request.sender if isinstance(request.sender, dict) else {}
+        ctx = WorkContext(self, entry, mandate, sender.get("project"), _link.sender_agent(self.identify_agent, sender, mandate))
         work = _Work(entry, request, ctx)
         work.renewed_at = self.now()
         self.current = work
@@ -781,7 +768,7 @@ class Responder(SlotKeeper):
             self._complete(entry)
             return
         message = self._call("com.get", {"message": entry["message"]})
-        self._run(entry, BoardRequest(message, entry["capability"]))
+        self._run(entry, BoardRequest(message, entry["capability"]), _link.read_back_problem(message, entry, self.project))
 
     def _fenced(self, op: str, entry: Dict[str, Any], key: str, extra: Optional[Dict[str, Any]] = None,
                 apply: Optional[Callable[[Dict[str, Any]], None]] = None) -> Optional[Dict[str, Any]]:

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

@@ -125,19 +125,20 @@ class SlotKeeper:
                 self._note(capability, dict(held, moved=now))  # said again at the next start if it cannot be written
         if "moved" not in held:  # once, even across restarts
             self._emit("board.slot.moved", "warning", "The %s slot on this Project moved to another session. This service stopped answering it; accepted "
-                       "work stays `accepted` (work begun is the new holder's). The operator brings it back by take-back (once the "
-                       "other session lets it go, or at a restart with accepted work waiting; a restart alone does not) or, where "
-                       "Fabric offers it, a move back here. Else ask its maintainer." % capability,
+                       "work stays accepted (work begun is the new holder's). The operator brings it back by take-back (once the "
+                       "other session lets it go, or at a restart or reconnect with accepted work waiting; neither alone does) or, "
+                       "where Fabric can, a move back here. Else ask its maintainer." % capability,
                        notify=True, episode=capability, capability=capability, generation=now, held=held["generation"])
         return True
 
-    def _moved_back(self, capability: str) -> None:
+    def _moved_back(self, capability: str, shared: Optional[Dict[str, Any]] = None) -> None:
         """A moved slot asked about once per later generation (FAA-165): the operator may move it back to this session
         (DEC-0140 PR-2), which this client cannot hear, so when com.status shows a generation past the recorded move, one
         `com.claim` asks whether the slot is its own. A claim that lands makes it held again and starts what it handed
         out; a `lease_expired` one (the move reached this session but its lease lapsed) enrolls again; a fenced one is
         another session's, recorded so the same generation is not asked about twice. Never an enroll or a replace on a
-        slot another session holds: a slot moved off stays off unless it is handed back."""
+        slot another session holds: a slot moved off stays off unless it is handed back. `shared` holds the tick's one
+        com.status read, shared by every moved slot (FAA-194 (5))."""
         if self.current is not None or self.stopping:
             return  # a claim now could hand out a second request, or start work while the responder stops
         held = self.checkpoint.slots.get(capability) or {}
@@ -145,7 +146,12 @@ class SlotKeeper:
         if held.get("project") != self.project or not _is_int(seen, 1):
             return
         (self.slots.get(capability) or {})["renewed_at"] = self.now()
-        status = self._status()
+        if shared is not None and "status" in shared:
+            status = shared["status"]
+        else:
+            status = self._status()
+            if shared is not None:
+                shared["status"] = status
         now = _whole(next((r.get("generation") for r in status.get("responders") or [] if isinstance(r, dict) and r.get("capability") == capability), None))
         if not _is_int(now, 1) or now <= seen:
             return
@@ -202,7 +208,9 @@ class SlotKeeper:
             self.slots[capability] = {"state": "held", "generation": generation, "renewed_at": float("-inf")}  # no lease yet
             self._held_at(capability, generation)
             self._said.pop("board.slot.moved", None)  # a later move is said again
-        return True
+        self._emit("board.slot.returned", "info", "The %s slot on this Project is this service's again: the operator moved it "
+                   "back here, and it answers it from now on." % capability, capability=capability, generation=generation)
+        return True  # FAA-194 (8): the feed no longer ends on the move's warning
 
     def take_back(self, capability: str) -> None:
         """The operator's act, never the kit's: forget the move; the next tick enrolls once the slot is free (FAA-155)."""

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

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 import re
 import urllib.parse
-from typing import Any, Dict, Iterable, List, Mapping, Optional, Sequence
+from typing import Any, Dict, Iterable, List, Mapping, Optional, Sequence, Tuple
 
 import sys as _sys  # noqa: E402
 from pathlib import Path as _Path  # noqa: E402
@@ -52,7 +52,8 @@ _KEY_SHAPE = re.compile(
     r"(?:^|[^A-Za-z0-9])(?:sk-(?=[A-Za-z0-9_-]*[0-9])(?:(?=[A-Za-z0-9_-]*[A-Z])[A-Za-z0-9_-]{16,}|[A-Za-z0-9_-]{32,})"
     r"|gh[pousr]_[A-Za-z0-9]{20,}|xox[abposr]-[A-Za-z0-9-]{10,}|AKIA[0-9A-Z]{16}|glpat-[A-Za-z0-9_-]{20,}"
     r"|(?:bot)?[0-9]{6,12}:(?=[A-Za-z0-9_-]*[A-Z])(?=[A-Za-z0-9_-]*[a-z])[A-Za-z0-9_-]{34,35}(?![A-Za-z0-9_-]))")
-_URL_SCHEME = re.compile(r"[a-z][a-z0-9+.-]*://", re.IGNORECASE | re.ASCII)
+_SCHEME_LETTERS = frozenset("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
+_SCHEME_CHARS = _SCHEME_LETTERS | frozenset("0123456789+.-")
 _CLOSING = ")]}>\"'.,;:!?"
 _TRIED_BACK = 1
 
@@ -139,13 +140,33 @@ def _shape_problems(value: Any) -> List[str]:
     return problems
 
 
+def _scheme_spans(piece: str) -> List[Tuple[int, int]]:
+    """The (start, end) of each URL scheme and its `://` in a piece, where `[a-z][a-z0-9+.-]*://` (case-insensitive,
+    ASCII) finds them left to right, read in linear time (FAA-322: the pattern tried every letter of a long run with no
+    `://`). From each `://` the run of scheme characters before it is read back, and the match starts at its first
+    letter at or after where the last match ended."""
+    spans: List[Tuple[int, int]] = []
+    after, at = 0, piece.find("://")
+    while at >= 0:
+        start = at
+        while start > after and piece[start - 1] in _SCHEME_CHARS:
+            start -= 1
+        while start < at and piece[start] not in _SCHEME_LETTERS:
+            start += 1
+        if start < at:
+            spans.append((start, at + 3))
+            after = at + 3
+        at = piece.find("://", at + 1)
+    return spans
+
+
 def _urls_in(value: str) -> List[str]:
     """The URLs a member may hold, from every scheme in each whitespace-delimited piece, without the closing brackets,
     quotes and punctuation that end a sentence, and with _TRIED_BACK of them put back (`]` closes an IPv6 host)."""
     urls: List[str] = []
     for piece in _SPACES.split(value):
-        for match in _URL_SCHEME.finditer(piece):
-            url = piece[match.start():]
+        for start, _end in _scheme_spans(piece):
+            url = piece[start:]
             end = len(url)
             while end > 0 and url[end - 1] in _CLOSING:
                 end -= 1
@@ -160,8 +181,8 @@ def _long_run(value: str) -> bool:
     """A long secret-shaped run in a piece read whole; in a piece that holds a URL, the text before its first scheme's
     `://` (the URL itself is read by secret_url)."""
     for piece in _SPACES.split(value):
-        found = _URL_SCHEME.search(piece)
-        cut = piece.find("://", found.start()) if found else -1
+        found = _scheme_spans(piece)
+        cut = found[0][1] - 3 if found else -1
         if _long_secret(piece if cut < 0 else piece[:cut]):
             return True
     return False

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

@@ -46,6 +46,8 @@ from fabric_jsvalue import (  # noqa: E402 - the core (FAA-65)
 )
 from fabric_paths import atomic_write as _atomic_write  # noqa: E402 - the kit's private writer (FAA-85)
 import fabric_peer_owner as _po  # noqa: E402 - a loopback key set is read from this account's listener only (FAA-255)
+import fabric_secrets  # noqa: E402 - the WHATWG host reading (FAA-98, FAA-309)
+import fabric_socket_proof  # noqa: E402 - the one loopback host rule (FAA-187 (15))
 from fabric_mandate import effect_closure  # noqa: E402,F401 - defined once beside the mandate that reads it too (DEC-0125)
 
 REFUSAL_CODES = (
@@ -621,16 +623,10 @@ def action_digest(action: Any) -> str:
 
 # --- the estate's keys ----------------------------------------------------------------------------------------
 
-def _loopback(host: str) -> bool:
-    if host == "localhost":
-        return True
-    try:
-        address = ipaddress.ip_address(host)
-    except ValueError:
-        return False
-    # A zone (`::1%eth0`) is no loopback: urllib decodes `%3A80` in it into another address (0.56.0 seam r13).
-    # Nor an IPv4-mapped address, which Python 3.13+ counts as loopback and 3.9 and Node do not (0.56.0 seam r14).
-    return address.is_loopback and not getattr(address, "scope_id", None) and not getattr(address, "ipv4_mapped", None)
+#: A key set source's loopback host, the kit's one rule (fabric_socket_proof.loopback_host), shared with fabric_http's
+#: check_url, so a source starts a service on both kits alike (FAA-187 (15); `127.1`, `2130706433`, a name under
+#: `.localhost`). A zone and an IPv4-mapped address stay refused, as before (0.56.0 seam r13, r14).
+_loopback = fabric_socket_proof.loopback_host
 
 
 # fabric_http._URL_ENDS (this module may not import fabric_http; test_fabric_delegation pins them equal).
@@ -663,7 +659,16 @@ def _source_authority_ok(parts: urllib.parse.SplitResult) -> bool:
         parts.port  # noqa: B018 - raises on a port above 65535
     except ValueError:
         return False
-    return bool(parts.hostname)
+    # A host `new URL` refuses for its structure (`a127.0.0.1`, `09`), or one Python's IDNA codec cannot write for
+    # http.client (U+180E), is refused here as check_url refuses it, never read and failed on every call (FAA-187 (14),
+    # (16)).
+    host = parts.hostname or ""
+    try:
+        if not host.isascii():
+            host.encode("idna")
+    except UnicodeError:
+        return False
+    return bool(host) and not fabric_secrets.url_refused(parts.geturl())
 
 
 class _NoRedirect(urllib.request.HTTPRedirectHandler):
@@ -734,7 +739,7 @@ def _fetch(source: str) -> Any:
                     body += chunk
             if deadline["fired"] or time.monotonic() > deadline["end"]:
                 raise TimeoutError("the key set did not arrive within %s s" % JWKS_FETCH_SECONDS)
-            return json.loads(body[:65536])
+            return json.loads(body[:65536], parse_constant=_no_constant)  # NaN is no JSON, as JSON.parse reads it (FAA-194)
         except urllib.error.HTTPError as exc:
             exc.close()
             raise
@@ -745,7 +750,7 @@ def _fetch(source: str) -> Any:
         finally:
             if deadline["timer"] is not None:
                 deadline["timer"].cancel()
-    return json.loads(Path(source).expanduser().read_text())
+    return json.loads(Path(source).expanduser().read_text(), parse_constant=_no_constant)
 
 
 class JwksCache:

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

@@ -55,7 +55,7 @@ from fabric_usage import (
 DASHBOARD_EXTENSION_KEY = "https://fabric.passioncode.ai/agent-contract/extensions/dashboard/0.1"
 
 
-DASHBOARD_KIT = "fabric-dashboard-kit@1.1.7"
+DASHBOARD_KIT = "fabric-dashboard-kit@1.1.8"
 
 
 REFERENCE_THEMES = ("graphite", "fabric", "paper", "forest", "ocean", "ember", "contrast")
@@ -197,9 +197,11 @@ def read_descriptors(directory: Optional[Path] = None) -> List[Tuple[Path, Dict[
         return found
     for path in sorted(root.glob("*.json")):
         try:
-            found.append((path, json.loads(path.read_text(encoding="utf-8"))))
-        except (OSError, ValueError):
+            value = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, ValueError, RecursionError):
             continue
+        if isinstance(value, dict):  # a file that holds no object is no descriptor (FAA-200 (50))
+            found.append((path, value))
     return found
 
 
@@ -222,10 +224,11 @@ def validate_descriptor(descriptor: Dict[str, Any]) -> List[str]:
         return problems
     if descriptor["protocol"] != PROTOCOL:
         problems.append("protocol must be %s" % PROTOCOL)
-    if not _ID.match(str(descriptor["id"])):
-        problems.append("id must match %s" % _ID.pattern)
-    if not _INSTANCE.match(str(descriptor["instance"])):
-        problems.append("instance must match %s" % _INSTANCE.pattern)
+    for key, pattern in (("id", _ID), ("instance", _INSTANCE)):  # a string before its pattern (FAA-200 (9), (36))
+        if not isinstance(descriptor[key], str):
+            problems.append("%s must be a string" % key)
+        elif not pattern.match(descriptor[key]):
+            problems.append("%s must match %s" % (key, pattern.pattern))
     if remote:
         problems.extend(remote_origin_problems(descriptor["origin"]))
     elif "origin" in descriptor and not _ORIGIN.match(str(descriptor["origin"])):
@@ -234,11 +237,11 @@ def validate_descriptor(descriptor: Dict[str, Any]) -> List[str]:
     if "tokenFile" not in auth:
         problems.append("auth.tokenFile is required")
     elif not _LOCAL_PATH.match(str(auth["tokenFile"])):
-        problems.append("auth.tokenFile must be a local path, never a network share")
+        problems.append("auth.tokenFile must be an absolute local path (/, ~/ or a drive letter), never a relative path, never a network share")
     paths = descriptor.get("paths") or {}
     for value in ([paths["data"]] if "data" in paths else []) + list(paths.get("logs") or []):
         if not _LOCAL_PATH.match(str(value)):
-            problems.append("paths must be local paths, never a network share: %r" % value)
+            problems.append("paths must be absolute local paths (/, ~/ or a drive letter), never a relative path, never a network share: %r" % value)
     header = auth.get("header", "Authorization")
     scheme = auth.get("scheme", "Bearer")
     if not (isinstance(header, str) and _AUTH_HEADER.fullmatch(header)):
@@ -405,7 +408,7 @@ def descriptor_member_problems(descriptor: Dict[str, Any]) -> List[str]:
             elif "@" in repository and not _HIERARCHICAL.match(repository):  # 0.62.0 readings 7: never an scp form's user
                 problems.append("source.repository with a user is a URL with an authority (https://user@host/path), never an scp form")
             elif fabric_secrets.repository_credential(repository):  # its name is no key (0.62.0 seam reading 6)
-                problems.append("FAC-SEM-086: /source/repository holds a value shaped like a credential; it names a repository")
+                problems.append("FAC-SEM-086: /source/repository holds a value shaped like a credential; it names a repository: write the repository's name in lower case if it is one")
     if "peer" in descriptor:
         peer = descriptor.get("peer")
         if not isinstance(peer, dict):
@@ -589,8 +592,15 @@ def port_listener_refusal(port: int, reader: Optional[Any] = None) -> Optional[s
             "FAA-225)." % (port, uid))
 
 
+def warn_no_source(descriptor: Dict[str, Any], stacklevel: int = 2) -> None:
+    """The rewrite warning of a descriptor that names no source.repository (FAA-198)."""
+    me = "%s.%s" % (descriptor["id"], descriptor["instance"])
+    warnings.warn("Descriptor %s %s; a new install is refused without it." % (me, NO_SOURCE_REPOSITORY),
+                  NoSourceRepositoryWarning, stacklevel=stacklevel + 1)
+
+
 def write_descriptor(descriptor: Dict[str, Any], directory: Optional[Path] = None, *, _stacklevel: int = 2,
-                     port_owner: Optional[Any] = None) -> Path:
+                     port_owner: Optional[Any] = None, _warned: bool = False) -> Path:
     """Installer-only. Refuses a port or id.instance another descriptor claims (a port is a claim), and a port another
     OS account listens on (FAA-225; ``port_owner(port) -> (kind, uid) | None`` reads it, the kit's own by default).
 
@@ -604,9 +614,8 @@ def write_descriptor(descriptor: Dict[str, Any], directory: Optional[Path] = Non
     refusal = source_refusal(descriptor, root)
     if refusal:
         raise ServiceError(refusal)
-    if not names_repository(descriptor):
-        warnings.warn("Descriptor %s %s; a new install is refused without it." % (me, NO_SOURCE_REPOSITORY),
-                      NoSourceRepositoryWarning, stacklevel=_stacklevel)
+    if not names_repository(descriptor) and not _warned:  # register_remote warns itself, before its token (FAA-200 (1))
+        warn_no_source(descriptor, _stacklevel)
     # DEC-0019: only a local placement claims a port on this computer; DEC-0069: an app's descriptor names none.
     port = None if placement_of(descriptor) == "remote" or "origin" not in descriptor else port_of(descriptor["origin"])
     for path, other in read_descriptors(root):

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

@@ -51,7 +51,9 @@ def make_event(event_id: Any, at: str, kind: str, level: str, text: str, *, subj
                link: Optional[str] = None, notify: bool = False, trace_id: Optional[str] = None,
                span_id: Optional[str] = None, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
     """One activity event: one sentence a person reads, never a machine id. `level` is one of `LEVELS`; `warn`, the
-    dashboard chip's name, is stored as `warning`. `data` (DEC-0070) adds machine-readable
+    dashboard kit's chip for "a person is needed" (`.fd-s-warn`), is stored as `warning`, the feed's name for the same
+    level, so a reader that draws chips shows a stored `warning` as the `warn` chip (FAA-276, FAA-277 (6)). `data`
+    (DEC-0070) adds machine-readable
     fields beside the sentence, `{schema, value}`, never a secret: it is refused here, so no feed carries one.
 
     An event about traced work carries its trace as a pair, `trace_id` and `span_id`

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

@@ -21,7 +21,8 @@ says so three ways:
 
 `HoldBook` keeps one JSON file (0600, written atomically); a ThreadingHTTPServer's handlers share it under the store
 lock. It holds caller names, work labels, reasons and the operator's words, never a credential: `hold` refuses a text
-the contract's detector reads as one.
+the contract's detector reads as one. A record written since 0.83.0 carries `squash: "ecmascript"`; one without it
+(0.81.0, 0.82.0) is matched under both squashes, since 0.81.0's Python twin squashed names with str.split() (FAA-320).
 """
 from __future__ import annotations
 
@@ -65,6 +66,27 @@ def _squash(text: str) -> str:
     return _SPACES.sub(" ", text).strip(" ")
 
 
+#: What a record written since 0.83.0 carries: its names were squashed with ECMAScript's whitespace (FAA-320).
+SQUASH = "ecmascript"
+#: Python's str.isspace() class, the one 0.81.0's Python twin squashed a name with (`" ".join(text.split())`).
+_PY_SPACES = re.compile("[\t\n\x0b\x0c\r\x1c-\x1f \x85\xa0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000]+")
+
+
+def _legacy_squash(text: str) -> str:
+    """A name as 0.81.0's Python twin wrote it (str.split()), written out so both twins read it alike."""
+    return _PY_SPACES.sub(" ", text).strip(" ")
+
+
+def _names(caller: Any, record: Dict[str, Any]) -> tuple:
+    """The stored forms `caller` matches in `record`: the ECMAScript squash, and for a record with no `squash` mark
+    (written before 0.83.0) also the squash 0.81.0's Python twin wrote (FAA-320). None matches only None."""
+    if not isinstance(caller, str):
+        return (caller,)
+    if record.get("squash") == SQUASH:
+        return (_squash(caller),)
+    return (_squash(caller), _legacy_squash(caller))
+
+
 def _instant(value: Any, name: str) -> str:
     if utc_time(value) is None:
         raise ServiceError("%s is a UTC instant (Z, at most 3 fraction digits)." % name)
@@ -197,6 +219,7 @@ class HoldBook:
              job_id: Optional[str] = None, now: Optional[str] = None) -> Dict[str, Any]:
         """Hold `work` for `caller` by `reason`. Returns {hold, statusMessage, push}: `push` is the notify event when this
         call opened the hold, None when the work joined an open one (one push per hold)."""
+        raw_caller = caller
         caller, work = _text(caller, "caller"), _text(work, "work")
         if reason not in HOLD_REASONS:
             raise ServiceError("A hold's reason is one of %s." % ", ".join(HOLD_REASONS))
@@ -207,11 +230,11 @@ class HoldBook:
             data = self._load()
             self._expire(data, utc_time(at))
             hold = next((h for h in data["holds"] if h.get("closed") is None and h["reason"] == reason
-                         and h["caller"] == caller), None)
+                         and h["caller"] in _names(raw_caller, h)), None)
             opened = hold is None
             if opened:
                 hold = {"id": uuid.uuid4().hex, "reason": reason, "caller": caller, "work": work, "since": at,
-                        "until": until, "jobs": [], "closed": None}
+                        "until": until, "jobs": [], "closed": None, "squash": SQUASH}
                 data["holds"].append(hold)
             if job_id is not None and job_id not in hold["jobs"]:
                 hold["jobs"].append(str(job_id))
@@ -229,7 +252,7 @@ class HoldBook:
         with self._lock:
             data = self._load()
             hold = next((h for h in data["holds"] if h.get("closed") is None and h["reason"] == reason
-                         and h["caller"] == caller), None)
+                         and h["caller"] in _names(caller, h)), None)
             if hold is None:
                 return None
             hold["closed"], hold["closedAt"] = "released", at
@@ -269,14 +292,15 @@ class HoldBook:
             raise ServiceError("A raised limit needs its window's end (until): it falls back when the window ends.")
         record: Dict[str, Any] = {"id": uuid.uuid4().hex, "reason": reason, "caller": None if caller is None else _text(caller, "caller"),
                                   "job": None if job_id is None else str(job_id), "from": at, "until": until,
-                                  given[0]: size, "decision": dict(decision), "at": at}
+                                  given[0]: size, "decision": dict(decision), "at": at, "squash": SQUASH}
         if given[0] != "limit":
             record["left"] = size
         with self._lock:
             data = self._load()
             self._expire(data, utc_time(at))
             for hold in data["holds"]:
-                if hold.get("closed") is None and hold["reason"] == reason and record["caller"] in (None, hold["caller"]) and (
+                if hold.get("closed") is None and hold["reason"] == reason and (
+                        caller is None or hold["caller"] in _names(caller, hold)) and (
                         job_id is None or str(job_id) in hold["jobs"]):
                     hold["closed"], hold["closedAt"], hold["lift"] = "lifted", at, record["id"]
             data["lifts"].append(record)
@@ -291,7 +315,7 @@ class HoldBook:
     def _matching(self, data: Dict[str, Any], reason: str, caller: Optional[str], job_id: Optional[str], at: int,
                   kind: str) -> List[Dict[str, Any]]:
         return [l for l in data["lifts"] if l["reason"] == reason and kind in l and self._live(l, at)
-                and l.get("caller") in (None, caller) and l.get("job") in (None, job_id)]
+                and (l.get("caller") is None or l["caller"] in _names(caller, l)) and l.get("job") in (None, job_id)]
 
     def admit(self, *, reason: str, caller: str, job_id: Optional[str] = None, cost_usd: Optional[float] = None,
               now: Optional[str] = None) -> Dict[str, Any]: