@passioncode-ai/fabric-agent-adapter 0.59.0 → 0.61.0

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

@@ -4,18 +4,26 @@ names. Standard library only, Python 3.9+."""
 from __future__ import annotations
 
 import json
+import math
+import re
+from collections.abc import Mapping
 import threading
 from pathlib import Path
 from typing import Any
 from typing import Callable
 from typing import Dict
+from typing import List
 from typing import Optional
+from typing import Tuple
 
 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_hub as _hub
+import fabric_interop_rules as _rules
+import fabric_mandate as _mandate
+from fabric_time import format_rfc3339 as _format_rfc3339  # noqa: E402 - the core's (FAA-65)
 import fabric_service as _fs
 from fabric_board_shapes import (  # noqa: E402 - the kit (FAA-65)
     BoardError,
@@ -210,3 +218,141 @@ class BoardRequest:
 
     def __repr__(self) -> str:  # never the body
         return "BoardRequest(%r, %r)" % (self.request_id, self.capability)
+
+
+# -- the operator's mandate in a board request (FAA-135; contract project-comms.md, DEC-0125 MD-3) ---------------------
+
+#: `mandate_from` naming every trusted sender of the board the service is installed on: the operator's personal board.
+PERSONAL_BOARD = "personal-board"
+_OPENER = re.compile(r"```json[ \t]*")
+_CLOSER = re.compile(r"```[ \t]*")
+
+
+def _json_blocks(body: str) -> List[str]:
+    """The bodies of the ```json blocks, each fence on its own line: one pass over the lines, so linear in the body
+    (an anchored regex rescanned to the end from every unclosed opener). Lines end at "\\n" alone, one "\\r" before it
+    dropped, as in the Node twin; an unclosed opener ends the scan."""
+    lines = [line[:-1] if line.endswith("\r") else line for line in body.split("\n")]
+    blocks: List[str] = []
+    i = 0
+    while i < len(lines):
+        if _OPENER.fullmatch(lines[i]):
+            j = i + 1
+            while j < len(lines) and not _CLOSER.fullmatch(lines[j]):
+                j += 1
+            if j == len(lines):
+                break
+            blocks.append("\n".join(lines[i + 1:j]))
+            i = j
+        i += 1
+    return blocks
+
+
+def _no_constant(name: str) -> Any:
+    raise ValueError(name)  # NaN and Infinity are not JSON
+
+
+def _bounded_int(literal: str) -> int:
+    """An integer of at most 4300 digits on every Python: 3.9 without int_max_str_digits converts a longer one in
+    quadratic time, and later ones refuse it, so all of them now refuse it alike."""
+    if len(literal) - literal.startswith("-") > 4300:
+        raise ValueError("an integer longer than 4300 digits")
+    return int(literal)
+
+
+def read_mandate(request: "BoardRequest", mandate_from: Any, agent_id: Optional[str]) -> Tuple[Optional[Dict[str, Any]], Optional[str]]:
+    """The mandate a request carries, read only when the service opted in (`agent_id` and `mandate_from` set), the board
+    verified the sender (`provenance: trusted`) and its Project is one `mandate_from` names (or `PERSONAL_BOARD`): a T1
+    caller by project-comms. Answers `(mandate, None)`, `(None, None)` when none is read, or `(None, code)` for a body
+    that carries one the kit will not read: `mandate-blocks` (more than one) or `mandate-unreadable` (a block naming
+    `mandate/1` that is not JSON). A `source` in the block is dropped: a board block carries none (OA-7). Whether it
+    covers a call is `covers`' answer, never this one's."""
+    if agent_id is None or mandate_from is None or not isinstance(request.body, str):
+        return None, None
+    sender = request.sender if isinstance(request.sender, dict) else {}
+    principal = sender.get("principal") if isinstance(sender.get("principal"), dict) else {}
+    if principal.get("provenance") != "trusted":
+        return None, None
+    if not isinstance(sender.get("project"), str) or not sender["project"]:  # comms-message requires it; the caller
+        return None, None
+    if mandate_from != PERSONAL_BOARD and _fold(sender["project"]) not in mandate_from:
+        return None, None
+    found = []
+    for block in _json_blocks(request.body):
+        try:
+            value = json.loads(block, parse_constant=_no_constant, parse_int=_bounded_int)
+        except (ValueError, RecursionError):
+            if "mandate/1" in block:
+                return None, "mandate-unreadable"
+            continue
+        if isinstance(value, dict) and value.get("kind") == "mandate/1":
+            value.pop("source", None)  # a Project declares no protocols: a board block carries no source (OA-7)
+            found.append(value)
+    if len(found) > 1:
+        return None, "mandate-blocks"
+    return (found[0], None) if found else (None, None)
+
+
+CALL_MEMBERS = ("capability", "action", "effect", "spendUsd", "project")  # what mandate_covers reads of a call
+
+
+def covers(mandate: Optional[Dict[str, Any]], call: Any, agent_id: Optional[str], wall: Callable[[], float],
+           caller: Any = None) -> Optional[Dict[str, Any]]:
+    """`mandate_covers` for a call under a board request's mandate, its sender placed as T1 and no caller agent id (the
+    board names a Project's principal, not an agent the chain can bind; the chain's end alone binds it, MD-3). A covered
+    answer's `recordAs` names `caller`, the sender Project the board verified (MD-3 records the caller, as the action
+    path does). None when no mandate travelled: the handler asks the operator as it would without one. The call's
+    `spendUsd` and `project` are read failing closed, as the kit's other mandate readers read them (FAA-139): a spend
+    that is not a finite number is none, which a ceiling refuses; a `project` that is not a string, None included (the
+    contract's mandateCovers refuses a null project), is unreadable, which a mandate limited to projects refuses; a call
+    that names none leaves `project` out. Only the five members `mandate_covers` reads are read, each once, the way the
+    handler's own `call[name]` reads it (a `__getitem__` or a default answers, never the mapping's storage), and the
+    rest of the call is never touched."""
+    if mandate is None or agent_id is None:
+        return None
+    if isinstance(call, Mapping):
+        read: Dict[str, Any] = {}
+        for name in CALL_MEMBERS:
+            try:
+                value = call[name]
+            except KeyError:  # not named; any other error the mapping raises passes to the handler
+                continue
+            if name == "spendUsd":
+                value = _rules.mandate_spend(value)
+                if value is None:
+                    continue
+            elif name == "project":
+                value = value if type(value) is str else _rules.UNREADABLE_PROJECT
+            read[name] = value
+        call = read
+    clock, now = wall(), ""
+    if isinstance(clock, (int, float)) and not isinstance(clock, bool):
+        try:
+            now = _format_rfc3339(clock * 1000) if math.isfinite(clock) else ""
+        except (OverflowError, ValueError):  # finite but outside the dates a clock can name
+            now = ""
+    answer = _mandate.mandate_covers({"mandate": mandate, "tier": "T1", "now": now, "self": agent_id, "call": call})
+    if "recordAs" in answer:
+        answer = {"ok": True, "recordAs": dict(answer["recordAs"], caller=caller)}
+    return answer
+
+
+def mandate_options(agent_id: Any, mandate_from: Any) -> Any:
+    """The responder's opt-in, checked: an agent id the registry accepts, and `mandate_from` either `PERSONAL_BOARD` or
+    a collection of Project ids (strings). Answers `mandate_from` as the responder keeps it (a frozenset or the string)."""
+    if agent_id is not None and not _mandate.is_agent_id(agent_id):
+        raise BoardError("invalid_arguments", "agent_id must be the service's registry agent id.")
+    if mandate_from is None or mandate_from == PERSONAL_BOARD:
+        return mandate_from
+    try:
+        projects = None if isinstance(mandate_from, (str, bytes, Mapping)) else list(mandate_from)
+    except TypeError:
+        projects = None
+    if projects is None or not all(isinstance(p, str) and p for p in projects):
+        raise BoardError("invalid_arguments", "mandate_from is %r or a collection of Project ids." % PERSONAL_BOARD)
+    return frozenset(_fold(p) for p in projects)
+
+
+def _fold(project: str) -> str:
+    """A Project id as Fabric's board compares it: a uuid lower-cased, any other id as written (_hub._project)."""
+    return project.lower() if _hub.UUID.fullmatch(project) else project

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))
@@ -155,6 +166,7 @@ class Responder(SlotKeeper):
         self.wait_until = 0.0
         self.stopping = False
         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._rr = 0
         #: The first pause under an operator's hold (DEC-0079); it doubles to HOLD_RETRY_MAX_SECONDS.
@@ -237,6 +249,7 @@ class Responder(SlotKeeper):
         self.state = "connecting"
         self.slots = {}  # the previous session's slots are not this one's: a refusal now reconnects (FAA-163)
         self._confirmed = {}  # nor its confirmations: a slot may have moved between the two sessions
+        self._probing = set()  # nor its lost move-back claims
         grant = self.hub.join_board(self.project, self.credential_file)
         missing = [c for c in self.capabilities if c not in grant.capabilities]
         session = self.session_factory(grant)
@@ -516,7 +529,11 @@ class Responder(SlotKeeper):
         """Seconds this session's leases still run, by its own clock: the running attempt's, else the oldest held slot's."""
         renewed = [self.current.renewed_at or 0.0] if self.current is not None else \
             [s.get("renewed_at", 0.0) for s in self.slots.values() if s.get("state") == "held"
-             and s.get("renewed_at", 0.0) != float("-inf")]  # a lapsed slot holds no lease (FAA-163)
+             and s.get("renewed_at", 0.0) != float("-inf")] + \
+            [s["probe_at"] for c, s in self.slots.items() if c in self._probing and "probe_at" in s
+             and self.now() - s["probe_at"] < LEASE_SECONDS - LEASE_MARGIN_SECONDS]
+        # a lapsed slot holds no lease (FAA-163); a move-back claim whose answer was lost holds one from its send, while
+        # more than the 10 s margin of that lease is left (FAA-165)
         return min(renewed) + LEASE_SECONDS - self.now() if renewed and self.session is not None else 0.0
 
     def _fault(self, exc: Exception) -> float:
@@ -588,8 +605,10 @@ class Responder(SlotKeeper):
             self._gone(capability)
             self._suspect.discard(capability)
         for capability, slot in list(self.slots.items()):
-            if slot.get("state") == "moved":
-                continue  # never enrolled again on its own, even when the new holder's lease lapses (FAA-155)
+            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)
+                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):
                     self._enroll(capability)  # still held: a longer pause; lifted: the slot is ours again (moved: read first)
@@ -727,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_board_slots.py

@@ -120,22 +120,98 @@ class SlotKeeper:
             self._to_resume = [r for r in self._to_resume if (self.checkpoint.entries.get(r) or {}).get("capability") != capability]
             self.slots[capability] = {"state": "moved", "generation": now, "renewed_at": self.now()}
             self._confirmed.pop(capability, None)
+            self.claim_keys.pop(capability, None)  # the move returned that claim to the queue: its receipt is dead
             if "moved" not in held:
                 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 there and left its "
-                       "accepted work `accepted` (work begun is the new holder's to settle). Its take-back action brings the "
-                       "slot back once the other session lets it go, or at a later restart or reconnect while accepted work "
-                       "waits; a restart alone does not. Without it, ask its maintainer." % capability,
+            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,
                        notify=True, episode=capability, capability=capability, generation=now, held=held["generation"])
         return True
 
+    def _moved_back(self, capability: str) -> 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."""
+        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 {}
+        seen = held.get("moved")
+        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()
+        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
+        key = self.claim_keys.get(capability) if capability in self._probing else None  # read once: take_back may pop it
+        if key is None:
+            key = self.claim_keys[capability] = self._key("claim")  # a fresh key: one from before the move may hold a dead receipt
+            (self.slots.get(capability) or {}).pop("probe_at", None)  # and a send time of its own
+        sent = self.now()
+        try:
+            answer = self._receipt("com.claim", self._call("com.claim", {"idempotency": self._idem(key), "capability": capability}))
+        except BoardError as exc:
+            if exc.code == "unreachable":  # the claim may have landed: asked again under this key, never left to the fault
+                self._probing.add(capability)
+                (self.slots.get(capability) or {}).setdefault("probe_at", sent)  # its lease runs from the first send
+                return
+            self._probing.discard(capability)
+            if exc.code == "held":
+                return  # the operator's hold: asked again at the next renewal
+            if exc.code in ("idempotency_window_expired", "capacity_exceeded"):
+                self.claim_keys.pop(capability, None)
+                return
+            if exc.code == "lease_expired":
+                self.claim_keys.pop(capability, None)  # a dead attempt's receipt may sit under it
+                if self._back(capability, held, now):
+                    self.slots[capability]["renewed_at"] = float("-inf")  # lapsed: the enroll below is recorded first
+                    self._enroll(capability)
+                return
+            if exc.code in SESSION_CODES and exc.code != "not_authorized":
+                raise  # the board session's fault, not this slot's
+            with self._lock:  # fenced, or another refusal of this claim: not this session's slot at this generation
+                if self.checkpoint.slots.get(capability) == held:  # take_back meanwhile wins (FAA-158)
+                    self._note(capability, dict(held, moved=now))
+            return
+        self._probing.discard(capability)
+        attempt = answer.get("attempt") if isinstance(answer.get("attempt"), dict) else {}
+        generation = _whole(attempt.get("generation"))
+        if _is_int(generation, 1) and generation < now:  # a replay from before a later move: dead, asked again fresh
+            self.claim_keys.pop(capability, None)
+            return
+        if not self._back(capability, held, generation if _is_int(generation, 1) else now):
+            return
+        if "request" in answer:
+            self.claim_keys.pop(capability, None)
+            self.slots[capability]["renewed_at"] = self.now()  # the claim just landed: its lease runs (finding 38)
+            self._start(capability, answer)
+        else:
+            self._enroll(capability)  # renewed now: whether an empty com.claim renews the lease is not the contract's to say
+
+    def _back(self, capability: str, held: Dict[str, Any], generation: int) -> bool:
+        """The slot is this session's again at `generation`: held, its record rewritten without the move (FAA-165)."""
+        with self._lock:
+            if self.checkpoint.slots.get(capability) != held:
+                return False  # take_back (an action thread) forgot the record meanwhile; its own next tick enrolls
+            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
+
     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)."""
         if capability not in self.capabilities:
             raise BoardError("invalid_arguments", "This responder does not answer %s." % capability)
         with self._lock:
             self.checkpoint.slot(capability, None)
+            self.claim_keys.pop(capability, None)  # a receipt from before the take-back may be dead
+            self._probing.discard(capability)
             if (self.slots.get(capability) or {}).get("state") == "moved":
                 self.slots[capability] = {"state": "contested", "renewed_at": 0.0}
             self._said.pop("board.slot.moved", None)

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: