@passioncode-ai/fabric-agent-adapter 0.60.0 → 0.62.0

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

@@ -17,6 +17,7 @@ import sys as _sys  # noqa: E402
 from pathlib import Path as _Path  # noqa: E402
 if str(_Path(__file__).resolve().parent) not in _sys.path:  # the kit loads from any working directory (FAA-65)
     _sys.path.insert(0, str(_Path(__file__).resolve().parent))
+import fabric_board_link as _link
 import fabric_hub as _hub
 import fabric_service as _fs
 from fabric_board_shapes import (  # noqa: E402 - the kit (FAA-65)
@@ -26,6 +27,7 @@ from fabric_board_link import (  # noqa: E402,F401 - re-exported: callers import
     BoardRequest,
     BoardSession,
     Checkpoint,
+    PERSONAL_BOARD,
 )
 from fabric_board_slots import (  # noqa: E402,F401 - the slot records (FAA-155, FAA-163); the constants re-exported
     HOLD_RETRY_MAX_SECONDS,
@@ -63,12 +65,18 @@ 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
-    the service; `stopped` is set when the attempt is no longer this responder's. Both raise `Stopped` then."""
+    the service; `stopped` is set when the attempt is no longer this responder's. Both raise `Stopped` then.
+    `mandate` is the operator's mandate the request carried, when the responder reads one (FAA-135), and
+    `mandate_covers(call)` whether it covers a call (`mandate_covers`' answer), None when none travelled."""
 
-    def __init__(self, responder: "Responder", entry: Dict[str, Any]):
-        self._responder, self._entry = responder, entry
+    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
         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)
+
     def progress(self, note: Optional[str] = None) -> None:
         if self.stopped.is_set():
             raise Stopped()
@@ -133,13 +141,16 @@ class Responder(SlotKeeper):
                  observe: Optional[Callable[[Dict[str, Any]], Optional[Dict[str, Any]]]] = None,
                  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):
+                 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.")
         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}.")
         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).
+        self.mandate_from, self.agent_id, self.wall = _link.mandate_options(agent_id, mandate_from), agent_id, wall
         self.capabilities = caps
         self.credential_file, self.handler, self.admit, self.observe = Path(credential_file), handler, admit, observe
         self.checkpoint = Checkpoint(Path(checkpoint_file))
@@ -735,7 +746,11 @@ class Responder(SlotKeeper):
         return True
 
     def _run(self, entry: Dict[str, Any], request: BoardRequest) -> None:
-        ctx = WorkContext(self, entry)
+        mandate, unread = _link.read_mandate(request, self.mandate_from, self.agent_id)
+        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)
         work = _Work(entry, request, ctx)
         work.renewed_at = self.now()
         self.current = work

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

@@ -9,6 +9,7 @@ import os
 import re
 import socketserver
 import subprocess
+import warnings
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Sequence, Tuple
 
@@ -294,7 +295,9 @@ def descriptor_member_problems(descriptor: Dict[str, Any]) -> List[str]:
             problems.append("runner.credentialKind is subscription, key, platform-metered or none")
         if "kind" in runner and not (isinstance(runner["kind"], str) and _RUNNER_KIND_NAME.match(runner["kind"])):
             problems.append("runner.kind is a runner kind's name")
-        if runner.get("credentialKind") == "subscription" and runner.get("kind") not in SUBSCRIPTION_RUNNERS:
+        # a kind that is no string is no runner's (a list would raise as a key: 0.62.0 unit reading 17)
+        if runner.get("credentialKind") == "subscription" and not (isinstance(runner.get("kind"), str)
+                                                                    and runner["kind"] in SUBSCRIPTION_RUNNERS):
             problems.append("a subscription runs only in its vendor's runner: runner.kind claude-code, kimi-code or codex")
         places += [("/runner/%s" % _pointer(k), v) for k, v in runner.items()]
     if "source" in descriptor:
@@ -311,7 +314,10 @@ def descriptor_member_problems(descriptor: Dict[str, Any]) -> List[str]:
                 problems.append("source.repository carries no password: it names the repository, never a credential")
             elif not _authority_ok(repository):
                 problems.append("source.repository names a host, and a port of digits up to 65535 when it has one")
-            places.append(("/source/repository", repository))
+            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")
     if "peer" in descriptor:
         peer = descriptor.get("peer")
         if not isinstance(peer, dict):
@@ -434,13 +440,58 @@ def port_of(origin: str) -> int:
     return int(match.group(1))
 
 
-def write_descriptor(descriptor: Dict[str, Any], directory: Optional[Path] = None) -> Path:
-    """Installer-only. Refuses a port or id.instance another descriptor claims (a port is a claim)."""
+NO_SOURCE_REPOSITORY = ("names no source.repository, the repository its code is built from "
+                        "(https://github.com/owner/name): it links the agent to its project (FAA-198)")
+PASS_SOURCE = ("Name it in this call: \"source\": {\"repository\": ...} in the descriptor write_descriptor writes, or "
+               "source= to register_remote; one written after the call returns is too late for a new install.")
+
+
+class NoSourceRepositoryWarning(UserWarning):
+    """FAA-198: an installed descriptor rewritten without source.repository (Node: process.emitWarning, code
+    FABRIC_NO_SOURCE_REPOSITORY). A new install without it is refused instead."""
+
+
+def names_repository(descriptor: Any) -> bool:
+    source = descriptor.get("source") if isinstance(descriptor, dict) else None
+    return isinstance(source, dict) and isinstance(source.get("repository"), str) and bool(source["repository"])
+
+
+_HIERARCHICAL = re.compile(r"\A[A-Za-z][A-Za-z0-9+.-]*://")
+
+
+def source_refusal(descriptor: Dict[str, Any], directory: Optional[Path] = None) -> Optional[str]:
+    """FAA-198: why a new install of this descriptor is refused, or None: it names no source.repository and no
+    descriptor of its id.instance is installed yet (a regular file, whatever it holds; a folder, a broken link or a path
+    that cannot be examined is none). An installer may check it before it validates or writes anything else."""
+    if names_repository(descriptor):
+        return None
+    d = descriptor if isinstance(descriptor, dict) else {}
+    instance = d.get("instance") if d.get("instance") is not None else "default"  # as Node's `??` reads it
+    me = "%s.%s" % (d.get("id"), instance)
+    try:  # an id or instance that is no string names no installed file, in both kits (seam reading 3)
+        if isinstance(d.get("id"), str) and isinstance(instance, str) and descriptor_path(d["id"], instance, directory).is_file():
+            return None
+    except (OSError, ValueError):  # an unsearchable folder reads as not installed, as Node's statSync does
+        pass
+    return "Descriptor %s %s. %s" % (me, NO_SOURCE_REPOSITORY, PASS_SOURCE)
+
+
+def write_descriptor(descriptor: Dict[str, Any], directory: Optional[Path] = None, *, _stacklevel: int = 2) -> Path:
+    """Installer-only. Refuses a port or id.instance another descriptor claims (a port is a claim).
+
+    FAA-198: a new descriptor names its ``source.repository``; rewriting one already installed without it only
+    warns (``NoSourceRepositoryWarning``), so an installed agent's update keeps working."""
     problems = validate_descriptor(descriptor)
     if problems:
         raise ServiceError("Descriptor is invalid: %s." % "; ".join(problems))
     root = directory or services_dir()
     me = "%s.%s" % (descriptor["id"], descriptor["instance"])
+    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)
     # 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_http.py

@@ -157,6 +157,11 @@ def redact_url(url: str) -> str:
     # then remove every tab, CR and LF, so ` https://u:pw@h` and `ht\ttps:u:pw@h` lose their password too (0.56.0
     # seam r10; Python 3.9's urlsplit keeps a leading space in the scheme).
     url = re.sub(r"[\t\n\r]", "", str(url).strip("".join(map(chr, range(0x21)))))
+    # The user information as written goes first, as git and urllib read it, where WHATWG reads a backslash as a slash:
+    # `https://h\\u:pw@x/r` would print `pw` in its path (0.62.0 seam reading 11). The Node twin does the same.
+    written = re.match(r"([A-Za-z][A-Za-z0-9+.-]*:[/\\]*)([^/?#]*)", url)  # after any run of slashes (seam reading 13)
+    if written and "@" in written.group(2):
+        url = written.group(1) + written.group(2).rpartition("@")[2] + url[written.end():]
     scheme, colon, rest = url.partition(":")
     if colon and scheme.lower() in ("http", "https", "ws", "wss", "ftp"):
         # A special scheme as WHATWG reads it: the authority starts after every slash or backslash that follows the

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

@@ -33,6 +33,7 @@ import fabric_service as _fs  # noqa: E402
 from fabric_base import store_lock  # noqa: E402 - one lock per store path (R3)
 from fabric_actions import action_caller, readable_action  # noqa: E402 - DEC-0121
 from fabric_mandate import EFFECT_CLASSES, OPERATOR_SOURCE_PROTOCOL, is_agent_id  # noqa: E402 - DEC-0125, DEC-0126
+from fabric_jsvalue import real_number as _real_number  # noqa: E402 - the core's (FAA-65)
 from fabric_time import format_rfc3339  # noqa: E402 - the core's (FAA-65)
 from fabric_page_links import (  # noqa: E402 - DEC-0123
     PageLinkError, dashboards_link, input_request_link_findings, page_link_findings, parse_dashboards_link)
@@ -40,6 +41,7 @@ from fabric_page_links import (  # noqa: E402 - DEC-0123
 from fabric_interop_rules import (  # noqa: E402,F401 - the rule layer (FAA-92)
     _days_from_civil,
     UNREADABLE_PROJECT,
+    kept_step,
     mandate_spend,
     PROTOCOL,
     EXTENSION_KEY,
@@ -393,30 +395,33 @@ class JobStore:
                       steps: Optional[Dict[str, Dict[str, Any]]] = None) -> Dict[str, Any]:
         """input_required with MCP elicitation requests, keyed; build them with choice_request / form_request / url_request.
         `steps` (DEC-0125) maps a request key to the approval step it asks for, {effect, spendUsd?, project?}, kept in the
-        job's private part so an answer's `_meta.mandate` is read for that step (CallContext.approval_step writes it)."""
-        for key, step in (steps or {}).items():
-            if key not in (input_requests or {}) or not isinstance(step, dict) or step.get("effect") not in EFFECT_CLASSES:
-                raise InteropError("Step %r: an input request's key with its effect class (DEC-0125)." % key)
-        if not input_requests:
-            raise InteropError("input_required needs at least one input request.")
-        for key, request in input_requests.items():
-            if not _KEY.match(key) or request.get("method") != "elicitation/create":
-                raise InteropError("Input request %r must be a keyed elicitation/create request." % key)
+        job's private part so an answer's `_meta.mandate` is read for that step (CallContext.approval_step writes it).
+        A step is kept as the gate reads it (kept_step), so a job's start and its answer agree."""
+        if not isinstance(input_requests, dict) or not input_requests:  # a JSON object of requests, first (readings 38, 39)
+            raise InteropError("input_required needs a JSON object of at least one input request.")
+        kept: Dict[str, Dict[str, Any]] = {}
+        for key, step in (steps or {}).items():  # the value checked is the value kept (seam reading 34)
+            kept[key] = kept_step(step) if key in input_requests and isinstance(step, dict) else {}
+            if not (type(kept[key].get("effect")) is str and kept[key]["effect"] in EFFECT_CLASSES):
+                raise InteropError("Step %r: an input request's key with its effect class (DEC-0125)." % (key,))
+        for key, request in input_requests.items():  # each a keyed object, as Node refuses one (product reading 39)
+            if not isinstance(key, str) or not _KEY.match(key) or not isinstance(request, dict) or request.get("method") != "elicitation/create":
+                raise InteropError("Input request %r must be a keyed elicitation/create request." % (key,))
         for finding in input_request_link_findings({"inputRequests": input_requests}):  # FAC-SEM-143 (D12)
             raise InteropError("%s: %s" % (finding["instancePath"], finding["message"]))
-        return self._transition(job_id, "input_required", {"steps": dict(steps or {})},
+        return self._transition(job_id, "input_required", {"steps": kept},
                                 inputRequests=input_requests, statusMessage=message)
 
     def answer(self, job_id: str, input_responses: Dict[str, Any]) -> Dict[str, Any]:
-        """Apply inputResponses to an input_required job; unknown keys are ignored (MCP Tasks rule).
+        """Apply inputResponses (a JSON object, a dict) to an input_required job; unknown keys are ignored (MCP Tasks rule).
 
         Returns the responses that matched; when any did, the job is working again."""
         with self._lock:
             job = self.get(job_id)
             if job["status"] != "input_required":
                 return {}
-            matched = {key: value for key, value in (input_responses or {}).items()
-                       if key in job.get("inputRequests", {}) and isinstance(value, dict)
+            matched = {key: value for key, value in (input_responses if isinstance(input_responses, dict) else {}).items()
+                       if isinstance(job.get("inputRequests"), dict) and key in job["inputRequests"] and isinstance(value, dict)
                        and value.get("action") in ("accept", "decline", "cancel")}
             if matched:  # the answered question's kept steps go in the same write: none outlives its answer
                 self._transition(job_id, "working", {"steps": {}})
@@ -532,9 +537,7 @@ class CallContext:
             if step["covered"]:
                 return step["record"]
             self.server._fault(capability, step)  # the start hears it as the answer does, under the same name (MJ-1)
-        spend = mandate_spend(spend_usd)  # a NaN or infinity reads as no estimate, and json would write a bare NaN
-        kept = {"effect": effect, **({"spendUsd": spend} if spend is not None else {}),
-                **({"project": project if isinstance(project, str) else UNREADABLE_PROJECT} if project is not None else {})}
+        kept = {"effect": effect, "spendUsd": spend_usd, "project": project}  # request_input keeps it as the gate reads it
         self.server.jobs.request_input(job_id, {key: request}, step["message"] or message, steps={key: kept})
         return None
 
@@ -712,9 +715,9 @@ class McpToolServer:
                 raise InteropError("Tool %s: a human step needs its link, an https URL or a path (DEC-0121 AP-4)." % tool["name"])
             if not (target is None or isinstance(target, str) or callable(target)):
                 raise InteropError("Tool %s: target is an argument's name or a function of the arguments." % tool["name"])
-            if self.agent_id is not None and action["gate"] == "relayed" and not (isinstance(effect, str) and effect in EFFECT_CLASSES):
+            if self.agent_id is not None and action["gate"] == "relayed" and not (type(effect) is str and effect in EFFECT_CLASSES):
                 raise InteropError("Tool %s: a relayed action on a server that reads mandates names its effect class (DEC-0125)." % tool["name"])
-            if effect is not None and not (isinstance(effect, str) and effect in EFFECT_CLASSES):
+            if effect is not None and not (type(effect) is str and effect in EFFECT_CLASSES):
                 raise InteropError("Tool %s: effect is one of %s." % (tool["name"], ", ".join(EFFECT_CLASSES)))
             if not (spend is None or callable(spend) or (isinstance(spend, (int, float)) and not isinstance(spend, bool))):
                 raise InteropError("Tool %s: spend is a number of USD or a function of the arguments." % tool["name"])
@@ -772,18 +775,20 @@ class McpToolServer:
         caller_agent = (verdict or {}).get("caller")
         # The estimate is read as a double, as the contract does: an int past the float range is infinite, and an
         # estimate that is not a finite number reads as none, which a mandate's ceiling refuses (fail closed).
+        number = _real_number(spend)  # by what it stores; a bool, a mock or not a number is none (seam reading 18)
         try:
-            double = float(spend) if isinstance(spend, (int, float)) and not isinstance(spend, bool) else math.nan
+            double = float(number) if number is not None else math.nan
         except OverflowError:
             double = math.inf
+        spend = number
         finite = math.isfinite(double)  # the service's own number goes on when it is finite (25 stays 25)
-        if project is _UNREADABLE or not (project is None or isinstance(project, str)):
-            project = _UNREADABLE_PROJECT  # a function that raised or named no string: a scoped mandate refuses
+        if project is _UNREADABLE or not (project is None or type(project) is str):  # an exact str, as the core compares
+            project = _UNREADABLE_PROJECT  # a function that raised or named no exact str: a scoped mandate refuses
         return {"self_id": self.agent_id, "effect": entry.get("effect"),
                 "caller_agent": caller_agent if isinstance(caller_agent, str) and caller_agent else None,
                 # an estimate that raised or is not finite is none: a mandate with a ceiling then refuses (fail closed)
                 "spend_usd": spend if finite else None,
-                "project": project if isinstance(project, str) else None}
+                "project": project}  # None or an exact str, read once above: never re-decided into no project (unit r33)
 
     @staticmethod
     def _read(value: Any, arguments: Dict[str, Any]) -> Any:
@@ -800,8 +805,9 @@ class McpToolServer:
         agent_id, a step approval_step kept is read under the call's `_meta.mandate` too (C3.3)."""
         job_id = str(arguments.get("id", ""))
         job = self.jobs.get(job_id)
-        steps = self.jobs.private(job_id).get("steps") or {}
-        asked = job.get("inputRequests", {}) if job["status"] == "input_required" else {}
+        private = self.jobs.private(job_id)  # one read of the job's private part (unit reading 39)
+        steps = private.get("steps") if isinstance(private.get("steps"), dict) else {}
+        asked = job.get("inputRequests") if job["status"] == "input_required" and isinstance(job.get("inputRequests"), dict) else {}
         records: Dict[str, Any] = {}
         for key, value in arguments["inputResponses"].items():
             if key not in asked or not isinstance(value, dict) or value.get("action") not in ("accept", "decline", "cancel"):
@@ -811,7 +817,7 @@ class McpToolServer:
             if self.agent_id is not None and isinstance(step, dict):
                 # A kept step's mandate is read as approval_step read it, under the job's own capability, which must
                 # be a capability name (MJ-1); the action itself stays fabric.job.get, so it is a readable action.
-                capability = self.jobs.private(job_id).get("capability")
+                capability = private.get("capability")
                 agent = (verdict or {}).get("caller")
                 mandate = {"self_id": self.agent_id, "effect": step.get("effect"), "spend_usd": step.get("spendUsd"),
                            "project": step.get("project"), "caller_agent": agent if isinstance(agent, str) and agent else None,
@@ -917,6 +923,8 @@ class McpToolServer:
                     return {"jsonrpc": "2.0", "id": rid, "result": _fd.refusal_tool_result(verdict, traceparent=span)}
             caller, inputs = self._caller(headers, tier, verdict), None
             responses = arguments.get("inputResponses")
+            if name == "fabric.job.get" and responses is not None and not isinstance(responses, dict):  # seam r37: never a crash
+                return self._error(rid, -32602, "fabric.job.get takes inputResponses as a JSON object (interop C3.3).")
             if name == "fabric.job.get" and self.input_actions and isinstance(responses, dict) and responses:
                 try:
                     inputs = self._gate_inputs(arguments, headers, tier, meta, caller, verdict)

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

@@ -150,6 +150,7 @@ def _own(value: Any, key: str) -> Any:
     return value.get(key, _ABSENT) if isinstance(value, dict) else _ABSENT
 
 
+import fabric_jsvalue as _jsvalue  # noqa: E402 - the core's (FAA-65)
 from fabric_time import days_from_civil as _days_from_civil  # noqa: E402 - the core's (FAA-65)
 
 
@@ -341,14 +342,14 @@ def job_step(mandate: Any, *, tier: Any, now: Any, self_id: Any, capability: Any
       it reads as mandate-malformed here as it does at the answer (FAA-178; McpToolServer does)."""
     if mandate is None:
         return {"covered": False, "message": None}
-    if not (isinstance(effect, str) and effect in EFFECT_CLASSES):
+    if not (type(effect) is str and effect in EFFECT_CLASSES):  # exact, as the core compares it (seam reading 34)
         raise InteropError("A job's approval step names its effect class (one of %s; DEC-0125)." % ", ".join(EFFECT_CLASSES))
     call: Dict[str, Any] = {"capability": capability, "action": key, "effect": effect}
     spend = mandate_spend(spend_usd)  # read as action_gate reads it, so the start and the answer agree (FAA-139)
     if spend is not None:
         call["spendUsd"] = spend
     if project is not None:
-        call["project"] = project if isinstance(project, str) else UNREADABLE_PROJECT
+        call["project"] = project if type(project) is str else UNREADABLE_PROJECT  # exact, as the kept step (seam r32)
     covers: Dict[str, Any] = {"mandate": mandate, "tier": tier, "now": now, "self": self_id, "call": call}
     if isinstance(caller_agent, str) and caller_agent:
         covers["callerAgent"] = caller_agent
@@ -379,8 +380,11 @@ UNREADABLE_PROJECT = "\x00unreadable"
 def mandate_spend(value: Any) -> Any:
     """A spend estimate as a mandate reads it (FAA-139): a number read as a double, as the contract does; one that is
     not a finite double (an int past the float range, NaN, infinity) or not a number is none, which a mandate's
-    ceiling refuses (fail closed). A finite number stays as given (25 stays 25)."""
-    if not isinstance(value, (int, float)) or isinstance(value, bool):
+    ceiling refuses (fail closed). A finite number stays as given (25 stays 25). A subclass of int or float is read by
+    the number it holds, never by an overridden `float()` or `int()` (numpy.float64 3.0 reads 3.0; one whose `float()`
+    answers 0.0 for 100 reads 100); a bool is none."""
+    value = _jsvalue.real_number(value)  # a bool, a mock that claims a number, or not a number: none
+    if value is None:
         return None
     try:
         return value if math.isfinite(float(value)) else None
@@ -388,6 +392,15 @@ def mandate_spend(value: Any) -> Any:
         return None
 
 
+def kept_step(step: Dict[str, Any]) -> Dict[str, Any]:
+    """A job's approval step {effect, spendUsd?, project?} as a job file keeps it: read as the gate reads it, so a job's
+    start and its answer agree (0.61.0 seam reading 32, readings 33 and 34): a spend through mandate_spend (dropped
+    when none), a project as an exact str, else UNREADABLE_PROJECT (dropped when None); each member read once."""
+    effect, spend, project = step.get("effect"), mandate_spend(step.get("spendUsd")), step.get("project")
+    return {"effect": effect, **({"spendUsd": spend} if spend is not None else {}),
+            **({"project": project if type(project) is str else UNREADABLE_PROJECT} if project is not None else {})}
+
+
 def action_gate(action: Any, *, tier: Any, caller: Any, meta: Any = None, target: Optional[str] = None,
                 elicited: bool = False, approval: Any = None, action_digest: Optional[str] = None,
                 human_step_url: Optional[str] = None, now: Any = None, self_id: Optional[str] = None,
@@ -408,7 +421,7 @@ def action_gate(action: Any, *, tier: Any, caller: Any, meta: Any = None, target
     per-agent credential; never a name the call carries), `spend_usd` (its own estimate), `project`, and `mandate_capability` (a job's kept step: the job's capability
     the mandate is read under, DEC-0141 MJ-1; unusable, the refusal is operator-decision-required). Both are read failing
     closed, as McpToolServer reads them (FAA-139): a spend that is not a finite double is none (`mandate_spend`), a
-    project that is not a string is UNREADABLE_PROJECT, which a mandate limited to projects refuses. A covered call
+    project that is not an exact str (a subclass included) is UNREADABLE_PROJECT, which a mandate limited to projects refuses. A covered call
     answers {ok: True, record: {by: operator, via: mandate, task, chain, caller}, decision: None, mandate}; without
     `self_id` the mandate is not read and the call is answered as before it existed."""
     import fabric_delegation as _fd  # noqa: E402 - beside this file: DL-19
@@ -421,7 +434,7 @@ def action_gate(action: Any, *, tier: Any, caller: Any, meta: Any = None, target
     if self_id is not None and isinstance(meta, dict) and "mandate" in meta:
         inputs.update({"mandate": meta["mandate"], "self": self_id})
         spend_usd = mandate_spend(spend_usd)
-        project = project if project is None or isinstance(project, str) else UNREADABLE_PROJECT
+        project = project if project is None or type(project) is str else UNREADABLE_PROJECT
         for name, value in (("effect", effect), ("callerAgent", caller_agent), ("spendUsd", spend_usd), ("project", project),
                             ("mandateCapability", mandate_capability)):
             if value is not None:

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

@@ -145,11 +145,29 @@ def get_string(value: Any, key: str) -> str:
 
 
 def is_number(value: Any) -> bool:
-    return isinstance(value, (int, float)) and not isinstance(value, bool)
+    """An int or a float by its real type, a subclass's included; a bool, or a value that only claims a number through
+    `__class__` (a mock, a proxy), is not one (0.61.0 seam reading 19)."""
+    kind = type(value)
+    return kind is not bool and issubclass(kind, (int, float))
+
+
+def real_number(value: Any) -> Any:
+    """The plain int or float a number holds (is_number), read by what it stores, never by its own float(), int() or
+    comparisons; None for anything else (0.61.0 seam reading 18, unit and product readings 19)."""
+    if not is_number(value):
+        return None
+    return float.__float__(value) if issubclass(type(value), float) else int.__int__(value)
+
+
+def held(value: Any) -> Any:
+    """A number by what it stores (real_number); any other value as given, so it reads as it did before."""
+    number = real_number(value)
+    return value if number is None else number
 
 
 def double(value: Any) -> float:
     """A JSON number as JavaScript holds it: the nearest double, and an integer beyond the double range ±Infinity."""
+    value = held(value)
     try:
         return float(value)
     except OverflowError:
@@ -184,7 +202,8 @@ def set_has(items: List[Any], value: Any) -> bool:
 _JS_SPACE = "\t\n\v\f\r              

  　"
 
 
-_JS_DECIMAL = re.compile(r"[+-]?(?:(?:[0-9]+\.?[0-9]*|\.[0-9]+)(?:[eE][+-]?[0-9]+)?|Infinity)", re.ASCII)
+# One way to split the digits, so a long string that fails to match costs its length (0.61.0 seam reading 22).
+_JS_DECIMAL = re.compile(r"[+-]?(?:(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?|Infinity)", re.ASCII)
 
 
 _JS_RADIX = re.compile(r"0(?:[xX](?P<x>[0-9a-fA-F]+)|[oO](?P<o>[0-7]+)|[bB](?P<b>[01]+))", re.ASCII)
@@ -196,9 +215,10 @@ def js_to_number(value: Any) -> float:
         return math.nan
     if value is None:
         return 0.0
-    if isinstance(value, bool):
+    if value is True or value is False:  # by identity: isinstance asks a number subclass's own __class__ (unit reading 30)
         return 1.0 if value else 0.0
     if is_number(value):
+        value = held(value)  # by the number it holds: a subclass's own float() or comparison is never asked
         try:
             return float(value)
         except OverflowError:

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

@@ -97,9 +97,23 @@ class InstanceLock:
         except BaseException:
             os.close(fd)
             raise
-        os.ftruncate(fd, 0)
-        os.write(fd, str(os.getpid()).encode())
-        os.fsync(fd)
+        try:
+            os.ftruncate(fd, 0)
+            os.write(fd, str(os.getpid()).encode())
+            os.fsync(fd)
+        except BaseException:  # a full disk or an I/O error: let the lock go, or release() frees nothing
+            try:
+                os.close(fd)
+            except OSError:  # a deferred write error (NFS) at the close: the name still goes, the first error stands
+                pass
+            finally:
+                name, self._name = self._name, None
+                if name is not None:
+                    try:
+                        _drop_lock_name(name)
+                    except OSError:  # as with the close: nothing to add to the first error
+                        pass
+            raise
         self._fd = fd
         return self
 

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

@@ -2,8 +2,11 @@
 the task, narrowed at each hand-over. Part of the service kit (layer L2); the twin of fabric-mandate.mjs.
 
 - ``mandate_covers(inputs)``: whether a callee takes one call as the operator's decision under a mandate (MD-3 to
-  MD-5), exactly as the contract's ``mandateCovers`` answers. ``inputs`` holds ``mandate``, ``tier``, ``now``, ``self``
-  (the callee's own agent id), ``callerAgent`` (only when the callee authenticated one) and ``call`` ({capability,
+  MD-5), as the contract's ``mandateCovers`` answers, but for a spend that is no JSON data a ``json.loads`` gives
+  (shared or cyclic), whose lists nest in lists more than MAX_SPEND_DEPTH deep, or that holds a dict with an own
+  ``toString`` at its top or through lists alone: the core refuses all three, where the contract reads the first,
+  reads or throws on the second and throws on the third (FAA-196 (22)). ``inputs`` holds ``mandate``, ``tier``, ``now``,
+  ``self`` (the callee's own agent id), ``callerAgent`` (only when the callee authenticated one) and ``call`` ({capability,
   action?, effect, spendUsd?, project?}).
 - ``mandate_problem(mandate)``: ``mandate-malformed``, ``mandate-widened`` or None (FAC-SEM-144);
   ``mandate_shape(mandate)``: ``mandate.schema.json`` alone; ``mandate_rules(kind, value)``: the findings.
@@ -18,7 +21,9 @@ the task, narrowed at each hand-over. Part of the service kit (layer L2); the tw
   ``instruction`` it stays in the receiver's own record: never an event, a usage report, a log line or a page.
 
 The kit has no JSON Schema validator: the shape is written here from the schema, lengths in code points and patterns
-over the whole string, as the contract's validator reads them. Never raises on what it reads. Standard library only.
+over the whole string, as the contract's validator reads them. Never raises on JSON as json.loads gives it (a direct
+caller's key or value that is not exactly the JSON type, with its own methods (__eq__, __hash__, __len__, __class__, a
+dict subclass's get), in the input, the call, the mandate or its scope, is used as given: FAA-196 (21), (22)). Standard library only.
 """
 from __future__ import annotations
 
@@ -33,7 +38,7 @@ if str(_Path(__file__).resolve().parent) not in _sys.path:  # the kit loads from
     _sys.path.insert(0, str(_Path(__file__).resolve().parent))
 
 from fabric_base import ServiceError  # noqa: E402
-from fabric_jsvalue import MISSING, get, is_number, js_to_number, same, set_has  # noqa: E402
+from fabric_jsvalue import MISSING, get, is_number, js_string, js_to_number, real_number, same, set_has  # noqa: E402
 from fabric_time import format_rfc3339, parse_rfc3339_ms  # noqa: E402
 
 #: The longest a mandate stands after the operator gave it (FAC-SEM-144).
@@ -238,6 +243,66 @@ def _member_of(items: Any, value: Any) -> bool:
     return set_has(items, value)
 
 
+#: A spend whose lists nest in one another more deeply than this, with no dict between them, is no estimate: that
+#: nesting is what JavaScript's String() of a list recurses through (Node and the contract throw RangeError a few
+#: thousand deep, 0.60.0 raised RecursionError a few hundred deep), and the spend a refusal carries as estimateUsd is
+#: then one a serialiser writes. Under a dict there is no bound: Number() never descends a dict, which is NaN at any
+#: depth in all three, but for one with an own toString at the top or through lists alone, on which Node and the
+#: contract throw (0.60.0 read it as NaN; the core refuses it, see _json_data). Stricter than all three between 100
+#: and their limit: FAA-196 (22); no JSON reader of the kit reaches it (0.61.0 readings 25 to 30).
+MAX_SPEND_DEPTH = 100
+
+
+def _json_data(value: Any) -> bool:
+    """Whether a value is JSON data as json.loads gives it, by exact type all the way down (never `==` or isinstance,
+    which a metaclass or `__class__` can answer), walked without recursion in one pass, its lists nested in lists at
+    most MAX_SPEND_DEPTH deep (a dict ends the count: its members are walked at any depth), and no dict at its top or
+    reached through lists alone with an own toString, on which Number() throws, as strict_string reads it (0.61.0 seam
+    reading 28). json.loads never shares a list or dict, so a structure that meets one twice (shared or cyclic) is not
+    JSON data (0.61.0 unit reading 21, seam reading 22, readings 25 to 27)."""
+    stack, seen = [(value, 0)], set()
+    while stack:
+        item, depth = stack.pop()
+        kind = type(item)
+        if item is None or kind is bool or kind is str or kind is int or kind is float:
+            continue
+        if kind is not list and kind is not dict:
+            return False
+        if id(item) in seen:
+            return False
+        seen.add(id(item))
+        if kind is list:
+            if depth is not None:
+                depth += 1
+                if depth > MAX_SPEND_DEPTH:
+                    return False
+            stack.extend((sub, depth) for sub in item)
+            continue
+        for key, sub in item.items():
+            if type(key) is not str:  # before any comparison: a key's own __eq__ never runs (unit reading 29)
+                return False
+            if depth is not None and key == "toString":  # Number() reaches it: a member of data is never callable
+                return False
+            stack.append((sub, None))
+    return True
+
+
+def _spend_number(spend: Any) -> float:
+    """Number(spend) for JSON data, without the join JavaScript builds for a list: [] is 0, a list of two or more items
+    is NaN (the comma never reads as a number), one item is read for itself, all in one descent (0.61.0 seam
+    reading 24: a list repeating one long string cost its length times its references)."""
+    value = spend
+    while type(value) is list:
+        if not value:
+            return 0.0
+        if len(value) > 1:
+            return math.nan
+        value = value[0]
+    if value is spend:
+        return js_to_number(value)
+    return 0.0 if value is None else js_to_number(js_string(value))
+
+
 def mandate_covers(inputs: Any) -> Dict[str, Any]:
     """Whether a callee takes one call as the operator's decision under a mandate (DEC-0125 MD-3 to MD-5), after it has
     placed the caller's tier (DL-25), as the contract's mandateCovers answers.
@@ -290,10 +355,24 @@ def mandate_covers(inputs: Any) -> Dict[str, Any]:
     if not set_has(list(_READS_AND_DRAFTS), effect) and capabilities is MISSING and (action is MISSING or actions is MISSING):
         return _outside("outside-mandate: capability")
     ceiling, spend = get(scope, "perCallMaxUsd"), get(call, "spendUsd")
-    if ceiling is not MISSING and (spend is MISSING or js_to_number(spend) > ceiling):
+    # A spend is read as the contract reads it only when it is JSON data as json.loads gives it, by exact type all the
+    # way down, or an int or float (a subclass read by the number it stores); anything else (a mock or proxy, a
+    # Decimal, a numpy.int64, a tuple, bytes, a str, list or dict subclass, a list holding one) is no estimate, which a
+    # ceiling refuses (0.61.0 seam readings 19 and 20), as is JSON data the core does not read as Number() does: lists
+    # nested more than MAX_SPEND_DEPTH deep (stricter than Number() between 100 and its limit), or a dict with an own
+    # toString Number() reaches, on which it throws (readings 25 to 29).
+    readable = over = False
+    if ceiling is not MISSING and spend is not MISSING:  # read only when a ceiling asks (no walk without one)
+        readable = is_number(spend) or _json_data(spend)
+    if readable:
+        try:
+            over = _spend_number(spend) > ceiling
+        except RecursionError:  # the number's read at the stack's edge: no estimate, never a raise (seam reading 21)
+            readable = False
+    if ceiling is not MISSING and (spend is MISSING or not readable or over):
         data: Dict[str, Any] = {"detail": "outside-mandate: spend"}
-        if spend is not MISSING:
-            data["estimateUsd"] = spend
+        if spend is not MISSING and readable:
+            data["estimateUsd"] = real_number(spend) if is_number(spend) else spend
         data["perCallMaxUsd"] = ceiling
         return {"ok": False, "code": OUTSIDE_MANDATE, "data": data}
     project, projects = get(call, "project"), get(scope, "projects")