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

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

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+# SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 """``fabric-package/1`` (contract DEC-0050, DEC-0051, DEC-0071, DEC-0074; FAA-27a): pack an agent or a skill set as one
 folder with ``fabric.package.json``, sign it, and verify it. The twin of ``fabric-package.mjs``.
 
@@ -390,12 +391,24 @@ def package_findings(pkg: Dict[str, Any]) -> List[Dict[str, str]]:
 
 # --- the folder check and the verifier ------------------------------------------------------------------
 
+def _json_int(text: str) -> Any:
+    """An integer literal as JSON.parse reads it: one longer than a Python with `int_max_str_digits` reads is a float,
+    as a JavaScript number is (FAA-194 (36))."""
+    return int(text) if len(text) <= 4000 else float(text)
+
+
 def _parsed(data: Optional[bytes]) -> Optional[Dict[str, Any]]:
+    """A plugin or provider manifest as the contract's checkPackageFolder reads it: decoded with replacement characters
+    (`Buffer.toString`, FAA-194 (29)); NaN or Infinity, or nesting past MAX_NESTING (the limit both kits share, FAA-194
+    (27)), is no manifest."""
     if data is None:
         return None
+    text = data.decode("utf-8", "replace")
+    if _nesting(text) > MAX_NESTING:
+        return None
     try:
-        value = json.loads(data.decode("utf-8"), parse_constant=fd._no_constant)
-    except (ValueError, RecursionError):  # invalid UTF-8, NaN or Infinity is no manifest, in both kits
+        value = json.loads(text, parse_constant=fd._no_constant, parse_int=_json_int)
+    except (ValueError, RecursionError):
         return None
     return value if isinstance(value, dict) else None
 
@@ -419,7 +432,7 @@ def check_package_folder(pkg: Dict[str, Any], files: Dict[str, bytes]) -> List[D
             problems.append({"problem": "file-unlisted", "path": path})
     if PLUGIN_MANIFEST in files:
         plugin = _parsed(files.get(PLUGIN_MANIFEST))
-        if not plugin or not _same_member(plugin, "name", pkg.get("id", _UNDEFINED)) or not _same_member(plugin, "version", pkg.get("version", _UNDEFINED)):
+        if plugin is None or not _same_member(plugin, "name", pkg.get("id", _UNDEFINED)) or not _same_member(plugin, "version", pkg.get("version", _UNDEFINED)):
             problems.append({"problem": "plugin-manifest", "path": PLUGIN_MANIFEST})
     provider = pkg.get("provider")
     if isinstance(provider, str) and provider in files:
@@ -615,7 +628,7 @@ def read_folder(folder: Any) -> Dict[str, bytes]:
         if _BY_FOLDER:
             os.close(top)  # type: ignore[arg-type]
     if refused:
-        raise PackageError("Not packed: remove these or pack a clean copy: " + "; ".join(sorted(refused)))
+        raise PackageError("Not packed: pack a clean copy (what Git would commit, references/package.md); delete only litter and credential files in place: " + "; ".join(sorted(refused)))
     return files
 
 

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

@@ -1,3 +1,4 @@
+# SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 """fabric-package/1, the schema reading: the package schema bundled from the contract at the pin, read by a JSON Schema
 2020-12 subset with JavaScript's patterns, lengths in code points and the formats the contract uses, as
 fabric-package.mjs reads it. fabric_package checks, packs, signs and verifies on it and re-exports these names. Part of

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

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+# SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 """A service's pages as Fabric Dashboards' open_link (Fabric Agent Contract DEC-0123, PL-1 to PL-4, FAC-SEM-143;
 `src/page-link-rules.ts` at the pin): build and read the open_link, tell a raw local address, and the findings on a
 link a document hands a person and on a URL-mode input request. A port held to the contract's answers by

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

@@ -1,3 +1,4 @@
+# SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 """Where a service's things live (fabric-service/0.1): the services directory, a service's data, config, logs and run
 directories per OS, private directories and atomic writes. Part of the service kit (FAA-65, layer L1)."""
 from __future__ import annotations
@@ -38,23 +39,35 @@ def services_dir() -> Path:
     return Path(base) / "passioncode-fabric/services"
 
 
+def _durable(service_id: str, dirs: Dict[str, Path]) -> Dict[str, Path]:
+    """FABRIC_DATA_HOME (FAA-192): an absolute folder on a durable volume holds the data folder, `<home>/<id>`, on a host
+    whose own disk does not persist; logs and cache stay where the OS puts them. A relative value is refused."""
+    value = os.environ.get("FABRIC_DATA_HOME")
+    if not value:
+        return dirs
+    if not os.path.isabs(value):
+        raise ServiceError("FABRIC_DATA_HOME is an absolute folder on a durable volume.")
+    return dict(dirs, data=Path(value) / service_id)
+
+
 def service_dirs(service_id: str) -> Dict[str, Path]:
-    """State lives outside code: data+config, logs and cache in per-user OS directories."""
+    """State lives outside code: data+config, logs and cache in per-user OS directories (the data folder under
+    FABRIC_DATA_HOME when it is set)."""
     _require_id(service_id)
     home = Path.home()
     if sys.platform == "darwin":
-        return {
+        return _durable(service_id, {
             "data": home / "Library/Application Support" / service_id,
             "logs": home / "Library/Logs" / service_id,
             "cache": home / "Library/Caches" / service_id,
-        }
+        })
     if sys.platform == "win32":
         data = _local_app_data() / service_id
-        return {"data": data, "logs": data / "Logs", "cache": data / "Cache"}
+        return _durable(service_id, {"data": data, "logs": data / "Logs", "cache": data / "Cache"})
     data = Path(os.environ.get("XDG_DATA_HOME") or home / ".local/share") / service_id
     state = Path(os.environ.get("XDG_STATE_HOME") or home / ".local/state") / service_id
     cache = Path(os.environ.get("XDG_CACHE_HOME") or home / ".cache") / service_id
-    return {"data": data, "logs": state / "logs", "cache": cache}
+    return _durable(service_id, {"data": data, "logs": state / "logs", "cache": cache})
 
 
 def instance_dirs(service_id: str, instance: str = "default") -> Dict[str, Path]:
@@ -69,6 +82,9 @@ def instance_dirs(service_id: str, instance: str = "default") -> Dict[str, Path]
     folder, personal = "%s.%s" % (service_id, instance), service_dirs(service_id)
     if sys.platform == "win32":
         data = personal["data"].parent / folder
+        if os.environ.get("FABRIC_DATA_HOME"):  # logs and cache stay on the local disk, beside the default's
+            local = personal["logs"].parent.parent / folder
+            return {"data": data, "logs": local / "Logs", "cache": local / "Cache"}
         return {"data": data, "logs": data / "Logs", "cache": data / "Cache"}
     if sys.platform == "darwin":
         return {key: path.parent / folder for key, path in personal.items()}

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

@@ -1,45 +1,38 @@
+# SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 """peer_owner: which OS account owns each end of a loopback TCP connection.
 
-    peer_owner 1.2.0+kit.6: Observatory's peer_owner 1.2.0 (passioncode-ai/project-observatory-dashboard,
-    `observatory/engine/peer_owner.py`, first vendored at f86f0622, read against 2180235c; the same licence), the kit's
-    `fabric_peer_owner` (layer L0; DEC-0154 HA-2, FAA-226, FAA-258). Observatory's 1.3.x (this account's own sockets
-    through libproc, DEC-0155 RT-2) is not in it (FAA-292). The kit's differences: `Owner` and `Row` are NamedTuples
-    (a dataclass with postponed annotations needs its module in sys.modules, and a service may load a kit file by
-    path); `Optional[X]` for `X | None` (the kit's floor is Python 3.9); `classify` / `classify_sid` ask for this
-    process's own uid or SID first (a client running as root or SYSTEM owns root's listener); on Linux `server_end`
-    reads an accepted connection's own row and, for one not accept()ed yet (uid 0, inode 0), the listener on its local
-    address (CT-254; reasons `not-accepted`, `several-rows`, `closed`), `peer` reads a client row with inode 0 as
-    unknown, several rows of one owner are that owner, a row printed twice counts once, and a `/proc` question that
-    finds no row or several reads once more; ctypes is imported where used. On macOS (kit.2 to kit.4, FAA-267,
-    FAA-273): the sysctl calibration also requires a child process's listener, an empty or header-only netstat is
-    `TABLE_RESTRICTED`, a caller may vouch for a listener with a pid it started (`pid_listens`,
-    `CheckedHTTPConnection(vouch_pid=...)`), the child's port is read under one deadline with `selectors`, a number is
-    ASCII digits only. DEC-0155 (kit.6, FAA-312): a netstat that fails, a table with no row of another uid (sysctl) or process
+    peer_owner 1.3.1+kit.8: Observatory's peer_owner (passioncode-ai/project-observatory-dashboard,
+    `observatory/engine/peer_owner.py`, vendored at f86f0622, read against 2180235c for 1.2.0 and a69c6fee for 1.3.1),
+    kit layer L0 (DEC-0154 HA-2, FAA-226, FAA-258). 1.3.1's proof from this account's own sockets (DEC-0155 RT-2) is the
+    kit's `fabric_socket_proof`, asked when it sits beside this file (FAA-292, FAA-327); else this file
+    stands alone. Kit differences: NamedTuples (a service may load a kit file by path); the Python 3.9 floor; `classify`
+    / `classify_sid` ask for this process's uid or SID first (a client running as root owns root's listener); on Linux
+    `server_end` reads an accepted connection's own row and, for one not accept()ed yet (uid 0, inode 0), the listener
+    on its local address (CT-254), several rows of one owner are that owner, a row printed twice counts once, and a
+    `/proc` question that finds no row or several reads once more. On macOS (FAA-267, FAA-273): the sysctl calibration
+    also requires a child's listener, read under one deadline with `selectors`; a number is ASCII digits only; a caller
+    may vouch for a listener with a pid it started (`pid_listens`, `CheckedHTTPConnection(vouch_pid=...)`, RT-3, after
+    RT-2). DEC-0155 (FAA-312): a netstat that fails or is empty, a table with no row of another uid (sysctl) or process
     (netstat) and a missing connection row read as `table-restricted` (RT-1); a restricted table's listener is this
-    account's only on exactly 127.0.0.1 (RT-4); the vouch takes exactly 127.0.0.1 (RT-3), never from a set-uid
-    reader. `main` is the CLI, `listener <port>` (FAA-315). /proc carries a socket's creator, so a listener root created
-    and handed to another account (systemd socket activation, User=) reads as root's. Standard library only, no other
-    kit module. Tests: `test/test_fabric_peer_owner.py`; the Node twin is `fabric-peer-owner.mjs` (no ctypes).
+    account's only on exactly 127.0.0.1 (RT-4); no proof is taken from a set-uid reader. `main` is the CLI, `listener
+    <port>` (FAA-315). /proc carries a socket's creator, so a listener root created and handed to another account
+    (socket activation) reads as root's. Tests: `test/test_fabric_peer_owner.py`; Node twin: `fabric-peer-owner.mjs`.
 
-WHY. Loopback is one per machine, not one per OS account. On a host with several accounts, every account's processes
-reach every service any account listens with on 127.0.0.1, and a loopback socket proves nothing about who is on the
-other end. This module answers that question from the host's socket table, read without privileges:
+WHY. Loopback is one per machine, not per OS account: every account's processes reach every 127.0.0.1 service, and a
+loopback socket proves nothing about the other end. This module reads the host's socket table, without privileges:
 
     listener(port) -> Owner       who listens on 127.0.0.1:<port> (also 0.0.0.0, ::1, ::)
     server_end(sock) -> Owner     for a client's connected socket: who accepted it
     peer(sock) -> Owner           for a server's accepted socket: who connected
     peer_at(server, client)       the same as `peer`, from two (host, port) addresses
-    own_connection(port, ...)     a CheckedHTTPConnection, connected: every connect, the first and
-                                  any reconnect http.client makes after `Connection: close`, checks
-                                  that the server end is this account's, or raises ListenerRefused
-                                  before a byte of the request is sent
+    own_connection(port, ...)     a CheckedHTTPConnection, connected: every connect (the first, and any reconnect
+                                  http.client makes) checks the server end is this account's before a byte is sent
 
 `Owner.kind` is one of:
 
     this-account      the socket belongs to the account running this process
     another-account   another OS account's
-    system            uid 0, pid 1 (launchd holds the sockets of socket-activated jobs) or, on
-                      Windows, the system's own accounts and processes
+    system            uid 0, pid 1 (launchd's socket-activated jobs) or, on Windows, the system's accounts and processes
     unknown           the owner could not be told; `reason` says why
     none              `listener` only: nothing listens on that port
 
@@ -52,40 +45,32 @@ answer; two live rows with the same addresses are `unknown` (`several-rows`), ne
 
 - macOS, primary (`sysctl`): `sysctl net.inet.tcp.pcblist_n` through ctypes, the record list `netstat` itself reads.
   Each connection is an `xinpcb_n` (addresses and ports) followed by an `xsocket_n` that carries `so_uid` and
-  `so_last_pid` (XNU `bsd/netinet/in_pcb.h` and `bsd/sys/socketvar.h`, both under `#pragma pack(4)`); the two are
-  paired by the pcb handle (`xi_inpp` equals `so_pcb`). Measured on macOS 26: about 4 ms for 770 sockets, every pid
-  equal to the one `netstat` printed. The `xtcpcb_n` record that follows gives the TCP state (`t_state`), so listeners
-  and TIME_WAIT rows are told apart. The layout is not an API, so the first read in a process calibrates it: it opens
-  a connected pair of its own (listen, connect, accept) and the listener and both ends of the pair must read back with
-  their exact addresses, this process's uid and its pid. A layout that fails calibration is not used again in that
-  process.
-- macOS 27.2 shows an ad-hoc-signed interpreter (a Homebrew Python) only its own sockets: the calibration also
-  requires a child's listener, and a restricted table (DEC-0155 RT-1) is `unknown` with a reason beginning
-  `table-restricted`, never another account's. A caller that started the server (an installer, its launchd job) may
-  vouch with that pid: `lsof -p PID` asks the process, which the restriction leaves readable (RT-3).
+  `so_last_pid` (XNU `bsd/netinet/in_pcb.h` and `bsd/sys/socketvar.h`, both under `#pragma pack(4)`), paired by the pcb
+  handle (`xi_inpp` equals `so_pcb`); the `xtcpcb_n` that follows gives the TCP state. Measured on macOS 26: about 4 ms
+  for 770 sockets. The layout is not an API, so the first read in a process calibrates it on a connected pair of its
+  own (the listener and both ends must read back with their exact addresses, this uid and this pid); a layout that
+  fails is not used again in that process.
+- macOS 27.2 shows an ad-hoc-signed interpreter (a Homebrew Python) only its own sockets: the calibration also requires
+  a child's listener, and a restricted table (DEC-0155 RT-1) is `unknown` with a reason beginning `table-restricted`,
+  never another account's, unless `fabric_socket_proof` finds the socket in this account's own processes (RT-2) or a
+  caller that started the server vouches with its pid, which `lsof -p PID` asks the process itself about (RT-3).
 - macOS, fallback (`netstat`): `/usr/sbin/netstat -anv -p tcp`, its `process:pid` column, then `ps -o uid= -p PID` for
-  the owner of the one row a question needs. Measured: about 20 ms over 846 sockets, and it names the pids of root's
-  listeners, which `lsof` run by an ordinary account cannot see. Another local service implemented the same check this
-  way; it is kept as the documented fallback for a macOS whose record layout the calibration refuses.
+  the one row a question needs; about 20 ms over 846 sockets, and it names the pids of root's listeners, which `lsof`
+  run by an ordinary account cannot see. Kept for a macOS whose record layout the calibration refuses.
 - Linux (`proc`): `/proc/net/tcp` and `/proc/net/tcp6`, whose `uid` column every account may read (also under
-  `hidepid=2`, which hides `/proc/<pid>` and not this file). No pid: that is only readable for this account's own
-  processes, and the decision needs the uid alone.
-- Windows (`iphlpapi`): `GetExtendedTcpTable(TCP_TABLE_OWNER_PID_ALL)` gives each row's owning pid;
-  `OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION)`, `OpenProcessToken(TOKEN_QUERY)` and
-  `GetTokenInformation(TokenUser)` give its account SID, compared with this process's. A process that cannot be opened
-  (another account's, usually) is `unknown`, never `another-account`: the caller refuses either way, and the reason
-  says which it was. `Owner.uid` is None there.
+  `hidepid=2`). No pid: that is only readable for this account's own processes, and the decision needs the uid alone.
+- Windows (`iphlpapi`): `GetExtendedTcpTable(TCP_TABLE_OWNER_PID_ALL)` gives each row's owning pid; `OpenProcess`,
+  `OpenProcessToken` and `GetTokenInformation(TokenUser)` its account SID, compared with this process's. A process that
+  cannot be opened (another account's, usually) is `unknown`, never `another-account`. `Owner.uid` is None there.
 - Anything else: `unknown`, reason `unsupported-platform`.
 
-`LOCAL_PEERCRED`, `getpeereid` and Linux `SO_PEERCRED` answer this question for Unix-domain sockets only, not for TCP,
-which is why a socket table is read here at all.
-
-WHAT IT NEVER DOES. It never reads a byte from the socket it is asked about, never resolves a name, never sends
-anything, and never needs a privilege. It reports the process names `netstat` prints only as far as the pid behind them.
+`LOCAL_PEERCRED`, `getpeereid` and `SO_PEERCRED` cover Unix-domain sockets only, hence a socket table. It never reads
+from the asked socket, resolves a name, sends anything or needs a privilege; of `netstat`'s names, only the pid.
 """
 from __future__ import annotations
 
 import http.client
+import importlib.util
 import ipaddress
 import json
 import os
@@ -97,8 +82,7 @@ import threading
 import time
 from typing import NamedTuple, Optional, Tuple
 
-# This file's own version, for projects that copy it; not the engine's (that is configuration.VERSION).
-PEER_OWNER_VERSION = "1.2.0+kit.6"  # Observatory's 1.2.0 with the kit's differences above
+PEER_OWNER_VERSION = "1.3.1+kit.8"  # this file's own, for projects that copy it: 1.3.1 with the kit's differences above
 
 THIS_ACCOUNT = "this-account"
 ANOTHER_ACCOUNT = "another-account"
@@ -107,8 +91,7 @@ UNKNOWN = "unknown"
 NONE = "none"
 KINDS = (THIS_ACCOUNT, ANOTHER_ACCOUNT, SYSTEM, UNKNOWN, NONE)
 
-#: The most table bytes one read accepts: 1 MB held about 1,200 sockets at `pcblist_n`'s 860 bytes each, which a busy
-#: developer machine passes; 4 MiB holds about 6,800 at 616 bytes measured on macOS 26 (FAA-260).
+#: The most table bytes one read accepts: about 6,800 sockets at 616 bytes each, measured on macOS 26 (FAA-260).
 MAX_TABLE_BYTES = 4 * 1024 * 1024
 #: Every subprocess this module starts is stopped after this many seconds.
 TIMEOUT_SECONDS = 2.0
@@ -119,8 +102,7 @@ NETSTAT = "/usr/sbin/netstat"
 PS = "/bin/ps"
 LSOF = "/usr/sbin/lsof"
 
-#: The reason a socket table hides other processes' sockets from this one (FAA-267: macOS 27.2 shows an ad-hoc-signed
-#: interpreter, such as a Homebrew Python, only its own sockets through sysctl and nothing through netstat).
+#: Why a table hides other processes' sockets (FAA-267: macOS 27.2 shows an ad-hoc-signed Python only its own).
 TABLE_RESTRICTED = "table-restricted"
 #: A macOS table that lists sockets but not the reader's own connection (DEC-0155 RT-1, FAA-312).
 NO_ROW_RESTRICTED = TABLE_RESTRICTED + ": no row for this connection"
@@ -131,8 +113,7 @@ SERVER_UNVERIFIED = "server-unverified"
 SERVER_NOT_THIS_WORKSPACE = "server-not-this-workspace"
 
 
-# The fields carry real types, not postponed strings: a NamedTuple's generated __new__ resolves its annotations in a
-# namespace without builtins, where `int | None` as a string is unresolvable (and a TypeError on Python 3.9).
+# Real types, not postponed strings: a NamedTuple's __new__ cannot resolve `int | None` as a string (3.9: TypeError).
 _OwnerFields = NamedTuple("_OwnerFields", [("kind", str), ("uid", Optional[int]), ("pid", Optional[int]),
                                            ("method", str), ("reason", Optional[str])])
 _OwnerFields.__new__.__defaults__ = (None, None, "none", None)
@@ -201,11 +182,6 @@ def _posix_uid() -> Optional[int]:
     return os.getuid() if hasattr(os, "getuid") else None
 
 
-def _own_pid() -> int:
-    """This process's pid: a netstat that shows no other process's row is a restricted table (DEC-0155 RT-1)."""
-    return os.getpid()
-
-
 def _set_uid() -> bool:
     """Real and effective uid differ: such a reader uses none of DEC-0155's proofs (RT-2 to RT-5), the vouch included."""
     return hasattr(os, "geteuid") and os.geteuid() != _posix_uid()
@@ -248,8 +224,7 @@ def parse_netstat(text: str) -> list[Row]:
     leading = at - sum(1 for w in names[:at] if w == "Address")
     trailing = len(names) - at - 1
     if not any(line.split()[:1] and line.split()[0].startswith("tcp") for line in lines[header + 1:]):
-        # The caller's own connection is in any table it can see: a header and no tcp row is the restricted table
-        # (FAA-273 item 3), not `no-row`.
+        # A header and no tcp row is the restricted table, not `no-row`: the caller's own row is in any table (FAA-273)
         raise TableUnreadable(f"{TABLE_RESTRICTED}: netstat printed only its header to this process")
     rows: list[Row] = []
     for line in lines[header + 1:]:
@@ -529,10 +504,9 @@ def _child_line(child: "subprocess.Popen[bytes]", deadline: float) -> Optional[b
 
 
 def _child_listener_seen(rows_of) -> Optional[bool]:
-    """Whether the table shows a listener of a child process of this one: False when it does not (the table shows
-    this process alone, FAA-267), None when no child could be started (a frozen or embedded host has no interpreter to
-    start), or it gave no port line within TIMEOUT_SECONDS (silence, a partial or non-numeric line, an early exit, a
-    pipe that cannot be read). The calibration trusts only True."""
+    """Whether the table shows a listener of a child process of this one: False when not (it shows this process alone,
+    FAA-267), None when no child could be started (a frozen or embedded host) or it gave no port line within
+    TIMEOUT_SECONDS (silence, a partial line, an early exit, an unreadable pipe). The calibration trusts only True."""
     if not sys.executable or getattr(sys, "frozen", False):
         return None
     try:
@@ -552,8 +526,7 @@ def _child_listener_seen(rows_of) -> Optional[bool]:
         except (TableUnreadable, OSError, struct.error, ValueError):
             return False
     finally:
-        # One deadline for the whole check: a child that gave no port is killed at once, and one that did gets what is
-        # left of the deadline to exit on its closed stdin before it is killed.
+        # One deadline: a child that gave no port is killed at once; one that did has the rest to exit on a closed stdin
         try:
             child.stdin.close()
             if port is None:
@@ -780,7 +753,7 @@ def restricted(rows: list[Row], how: str, *, own_uid: Optional[int] = None, own_
         own = _posix_uid() if own_uid is None else own_uid
         return not any(row.uid is not None and row.uid != own for row in rows)
     if how == "netstat":
-        own = _own_pid() if own_pid is None else own_pid
+        own = os.getpid() if own_pid is None else own_pid
         return not any(row.pid is not None and row.pid != own for row in rows)
     return False
 
@@ -810,10 +783,8 @@ def _owner_of(local: tuple[str, int], remote: tuple[str, int], server: bool = Fa
     if len(found) > 1:
         return Owner(UNKNOWN, None, None, how, "several-rows")
     if how == "proc" and server and found[0].uid is None:
-        # Linux: a connection not accept()ed yet (uid 0, inode 0) belongs to the listener on its local address (exact,
-        # else the wildcard) and dies with it (inet_csk_listen_stop); an accepted one's own row carries the accepting
-        # process's uid (sock_graft), so a listener swapped after another account accepted cannot pass (Observatory's
-        # 1.2.0, board thread ced00f6e; CT-254). An orphaned server row reads so too: nothing sent to it reaches anyone.
+        # Linux: an unaccepted connection (uid 0, inode 0) or an orphaned server row is the listener's on its local address
+        # (exact, else wildcard); an accepted row holds the acceptor's uid (sock_graft): no listener swap passes (CT-254).
         return _one_owner(_listeners_of(rows, found[0].local), how, "not-accepted")
     if how == "proc" and found[0].uid is None:
         # A client's socket with inode 0 has already closed (0.74.0 unit reading 4): never another socket's owner.
@@ -842,10 +813,40 @@ def _one_owner(found: list[Row], how: str, none_reason: Optional[str] = None) ->
     return Owner(UNKNOWN, None, None, how, "several-rows")
 
 
+_PROOF: list = [None]  # fabric_socket_proof once looked for: None not yet, False not beside this file (FAA-292)
+
+
+def _proved(ask: str, *args, fallback: Owner, **kwargs) -> Owner:
+    """`fallback`, unless it is a restricted macOS table's `unknown` and `fabric_socket_proof` beside this file finds the
+    socket (`accepted`) or the 127.0.0.1 listener (`own_listener`, FAA-272) in this account's processes: else it stands."""
+    if fallback.kind != UNKNOWN or not (fallback.reason or "").startswith(TABLE_RESTRICTED) or sys.platform != "darwin":
+        return fallback
+    try:
+        if _PROOF[0] is None:  # the file beside this one; sys.path stays the host's (FAA-327); alone, the table stands
+            here = os.path.realpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "fabric_socket_proof.py"))
+            if not os.path.isfile(here):
+                raise ImportError(here)
+            try:  # the host's imported copy if it is that file (one calibration); the statement keeps it in the closure
+                import fabric_socket_proof as module
+            except ImportError:
+                module = None
+            if os.path.realpath(getattr(module, "__file__", None) or "-") != here:  # else that file, by its path
+                spec = importlib.util.spec_from_file_location("fabric_socket_proof", here)
+                spec.loader.exec_module(module := importlib.util.module_from_spec(spec))
+            _PROOF[0] = module
+        proof = getattr(_PROOF[0], ask)(*args, **kwargs) if _PROOF[0] else None
+    except ImportError:
+        _PROOF[0], proof = False, None
+    except Exception:  # noqa: BLE001 - a proof that fails proves nothing; the table's answer stands (fail closed)
+        proof = None
+    return Owner(THIS_ACCOUNT, _posix_uid(), proof.pid, proof.method, proof.reason) if proof and proof.proved else fallback
+
+
 def peer_at(server: tuple, client: tuple) -> Owner:
     """The owner of the CLIENT socket of the connection between `server` and `client`, as a server sees them (its own
     address, the peer's): the row whose local address is the client's and whose remote address is the server's."""
-    return _owner_of(_address(client), _address(server))
+    client, server = _address(client), _address(server)
+    return _proved("accepted", client, server, wait=False, fallback=_owner_of(client, server))
 
 
 def peer(sock: socket.socket) -> Owner:
@@ -859,14 +860,14 @@ def peer(sock: socket.socket) -> Owner:
 
 def server_end(sock: socket.socket) -> Owner:
     """For a client's connected socket: who accepted it. The row whose local address is the server's and whose remote
-    address is this socket's own, which is the server process's accepted socket, so a listener swapped after `listen`
-    cannot pass for the one that answers. On Linux a connection not yet accept()ed has no owner of its own (inode 0):
-    its listener answers (the contract's CT-254, HA-2's Linux source)."""
+    address is this socket's own, the server process's accepted socket, so a listener swapped after `listen` cannot
+    pass; on Linux a connection not accept()ed yet answers through its listener (CT-254); RT-2 under a restricted table."""
     try:
         own, server = sock.getsockname(), sock.getpeername()
     except OSError as exc:
         return Owner(UNKNOWN, None, None, "none", f"socket: {type(exc).__name__}")
-    return _owner_of(_address(server), _address(own), server=True)
+    server, own = _address(server), _address(own)
+    return _proved("accepted", server, own, wait=True, fallback=_owner_of(server, own, server=True))
 
 
 #: port -> (time.monotonic() of the read, the Owner)
@@ -899,6 +900,7 @@ def listener(port: int) -> Owner:
         owner = Owner(UNKNOWN, None, None, method(), str(exc))
     else:
         owner = _restricted_listener(rows, port, how) if restricted(rows, how) else _one_owner(pick_listener(rows, port), how)
+    owner = _proved("own_listener", port, fallback=owner)
     _LISTENERS[port] = (now, owner)
     return owner
 
@@ -922,17 +924,21 @@ def refusal(owner: Owner, port: int, expect_pid: Optional[int] = None) -> Option
     return None
 
 
-def pid_listens(pid: int, port: int) -> bool:
-    """macOS, when the socket table is restricted (FAA-267, DEC-0155 RT-3): whether process `pid`, this account's,
-    listens on exactly 127.0.0.1:<port> (never the IPv4 wildcard, which `lsof` prints as it prints an IPv6-only one, nor
-    ::1; FAA-312). `lsof -p` asks the process itself (libproc), which the restriction does not hide. Only a caller that
-    started `pid` itself (a launchd job it installed) may vouch with it, and never a set-uid one."""
-    if sys.platform != "darwin" or not isinstance(pid, int) or isinstance(pid, bool) or pid <= 1 or _set_uid():
+def pid_listens(pid: int, port: int, owner: object = THIS_ACCOUNT) -> bool:
+    """macOS, a restricted table (FAA-267, DEC-0155 RT-3): whether process `pid` listens on exactly 127.0.0.1:<port>
+    (never the IPv4 wildcard, which `lsof` prints as an IPv6-only one, nor ::1), asked of the process (`lsof -p`). Only
+    a caller that started `pid` (a launchd job it installed) vouches with it, never a set-uid one for this account. `owner`:
+    the uid `pid` runs as, this account's by default, or None when the caller checks it (a LaunchDaemon's UserName)."""
+    if owner is not None and owner != THIS_ACCOUNT and (not isinstance(owner, int) or isinstance(owner, bool) or owner < 0):
+        raise ValueError("owner is this-account, a uid or None")
+    if sys.platform != "darwin" or not isinstance(pid, int) or isinstance(pid, bool) or pid <= 1 or (
+            owner == THIS_ACCOUNT and _set_uid()):
         return False
     try:
-        uid = parse_ps_uid(_run([PS, "-o", "uid=", "-p", str(pid)]))
-        if uid is None or uid != _posix_uid():
-            return False
+        if owner is not None:
+            uid = parse_ps_uid(_run([PS, "-o", "uid=", "-p", str(pid)]))
+            if uid is None or uid != (_posix_uid() if owner == THIS_ACCOUNT else owner):
+                return False
         out = _run([LSOF, "-nP", "-a", "-p", str(pid), "-i4TCP", "-sTCP:LISTEN", "-Fn"])
     except TableUnreadable:
         return False
@@ -940,9 +946,8 @@ def pid_listens(pid: int, port: int) -> bool:
 
 
 class CheckedHTTPConnection(http.client.HTTPConnection):
-    """An `http.client.HTTPConnection` whose every `connect()` checks the server end before returning: `http.client`
-    connects again by itself (`auto_open`) after `Connection: close` or a close, and that connection may reach another
-    listener. A refused connect closes the socket and raises ListenerRefused before any byte of a request is sent."""
+    """An `http.client.HTTPConnection` whose every `connect()` (the reconnect `auto_open` makes too, which may reach
+    another listener) checks the server end: refused, it closes the socket and raises ListenerRefused before a byte."""
 
     def __init__(self, host: str, port: int, *, expect_pid: Optional[int] = None, timeout: float = 10.0,
                  vouch_pid: Optional[int] = None) -> None:
@@ -957,7 +962,7 @@ class CheckedHTTPConnection(http.client.HTTPConnection):
         super().connect()
         owner = server_end(self.sock)
         if (owner.kind == UNKNOWN and (owner.reason or "").startswith(TABLE_RESTRICTED) and getattr(self, "vouch_pid", None)
-                and pid_listens(self.vouch_pid, self.port)):
+                and _address(self.sock.getpeername())[0] == "127.0.0.1" and pid_listens(self.vouch_pid, self.port)):
             # The table hides other processes (FAA-267); the process this caller started holds the listener.
             owner = Owner(THIS_ACCOUNT, _posix_uid(), self.vouch_pid, "lsof-pid")
         refused = refusal(owner, self.port, self.expect_pid)
@@ -968,16 +973,11 @@ class CheckedHTTPConnection(http.client.HTTPConnection):
 
 def own_connection(port: int, *, expect_pid: Optional[int] = None, timeout: float = 10.0,
                    host: str = "127.0.0.1", vouch_pid: Optional[int] = None) -> CheckedHTTPConnection:
-    """A `CheckedHTTPConnection` to `host:port`, connected, whose server end is this account's (and, with `expect_pid`,
-    that process's). The check runs on the very connection the caller then sends on, so no listener can change between
-    the check and the request, and again on every reconnect `http.client` makes. No proxy is consulted. Raises
-    ListenerRefused after closing the connection:
-
-        server-not-own             another account's or the system's process accepted it
-        server-unverified          its owner could not be told (nothing is sent: fail closed)
-        server-not-this-workspace  this account's process, but not the pid expected
-
-    `vouch_pid`, as on `CheckedHTTPConnection` and the Node twin's `checkedSocket`: a pid the caller started (FAA-267)."""
+    """A `CheckedHTTPConnection` to `host:port`, connected, whose server end is this account's (with `expect_pid`, that
+    process's), checked on the connection the caller sends on and on every reconnect; no proxy is consulted.
+    ListenerRefused, closed: `server-not-own` (another account's or the system's process), `server-unverified` (owner
+    not told: fail closed), `server-not-this-workspace` (not the pid expected). `vouch_pid`: a pid the caller started
+    (FAA-267), as on `CheckedHTTPConnection` and the Node twin's `checkedSocket`."""
     conn = CheckedHTTPConnection(host, port, expect_pid=expect_pid, timeout=timeout, vouch_pid=vouch_pid)
     conn.connect()
     return conn

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

@@ -1,3 +1,4 @@
+# SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 """Windows, where the kit needs it (DEC-0032): named pipes that hold one copy, protecting a file to its owner, and
 reading a file's ACL to refuse a token file others can read. On other systems the same names exist and do nothing
 or answer "absent". Part of the service kit (FAA-65, layer L1)."""

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

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+# SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 """Runner and model profiles in the kit (Fabric Agent Contract DEC-0046, Fabric ADR-0147). A port of the contract's
 `src/profile-rules.ts` at the pin — `resolve_model_profile` and the FAC-SEM-058…060 checks — held to the contract's own
 answers by test/fixtures/contract/profile-vectors.json; plus what a service does with them: the doctor's runner and

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

@@ -1,3 +1,4 @@
+# SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 """Protocol revisions (DEC-0067) and an event's machine-readable data (DEC-0070, the feed-data protocols): parse,
 accept, negotiate and check them. Part of the service kit (FAA-65, layer L3)."""
 from __future__ import annotations