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

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/fabric-interop.mjs

@@ -41,6 +41,7 @@ export {
   jobStep,
   actionGate,
   mandateSpend,
+  keptStep,
   UNREADABLE_PROJECT,
   actionRefusalToolResult,
   usageFindings,
@@ -49,7 +50,7 @@ export {
   pauseMessage,
   repeatedKeyDecision,
 } from './fabric-interop-rules.mjs';
-import { PROTOCOL, EXTENSION_KEY, MCP_REVISION, TERMINAL, CONTRACT_VERSION, JOB_HANDLE_SCHEMA, InteropError, UnknownJob, parseTraceparent, childTraceparent, traceIds, QUOTA_EXHAUSTED, QUEUE_FULL, OUTCOME_UNKNOWN, LIMIT_REACHED, INTEROP_NULL_USAGE, PROTOCOLS_READ, utcTime, quotaDataOk, readJobPause, jobCallerAction, intentIdempotencyKey, readsNullUsage, requestMeta, usageFindings, usageToward, jobLimitRules, pauseMessage, repeatedKeyDecision, OUTCOMES, ENVELOPE_REQUIRED, JOB_ID, KEY, SECRET_WORDS } from './fabric-interop-rules.mjs'; // the rule layer (FAA-92)
+import { PROTOCOL, EXTENSION_KEY, MCP_REVISION, TERMINAL, CONTRACT_VERSION, JOB_HANDLE_SCHEMA, InteropError, UnknownJob, parseTraceparent, childTraceparent, traceIds, QUOTA_EXHAUSTED, QUEUE_FULL, OUTCOME_UNKNOWN, LIMIT_REACHED, INTEROP_NULL_USAGE, PROTOCOLS_READ, utcTime, quotaDataOk, readJobPause, jobCallerAction, intentIdempotencyKey, readsNullUsage, requestMeta, usageFindings, usageToward, jobLimitRules, pauseMessage, repeatedKeyDecision, keptStep, OUTCOMES, ENVELOPE_REQUIRED, JOB_ID, KEY, SECRET_WORDS } from './fabric-interop-rules.mjs'; // the rule layer (FAA-92)
 
 // --- C3.1 capabilities as tools ----------------------------------------------------------
 export function expectedAnnotations(effect, idempotency) {
@@ -266,23 +267,28 @@ export class JobStore {
 
   // `steps` (DEC-0125) maps a request key to the approval step it asks for, {effect, spendUsd?, project?}, kept in the
   // job's private part (the format fabric_interop.py writes) so a service reads an answer's _meta.mandate for that step.
+  // A step is kept as the gate reads it (keptStep), so a job's start and its answer agree.
   requestInput(jobId, inputRequests, statusMessage, { steps } = {}) {
+    const entries = Object.entries(inputRequests ?? {});
+    if (!entries.length || Array.isArray(inputRequests) || typeof inputRequests !== 'object') throw new InteropError('input_required needs a JSON object of at least one input request.'); // a JSON object of requests, first (unit 38, 40)
+    const kept = Object.create(null); // the value checked is the value kept (seam 34); a key __proto__ stays a key (35)
     for (const [key, step] of Object.entries(steps ?? {})) {
-      if (!Object.hasOwn(inputRequests ?? {}, key) || !EFFECT_CLASSES.includes(step?.effect)) throw new InteropError(`Step ${key}: an input request's key with its effect class (DEC-0125).`);
+      kept[key] = Object.hasOwn(inputRequests, key) && step !== null && step !== undefined ? keptStep(step) : {};
+      if (!EFFECT_CLASSES.includes(kept[key].effect)) throw new InteropError(`Step ${key}: an input request's key with its effect class (DEC-0125).`);
     }
-    const entries = Object.entries(inputRequests ?? {});
-    if (!entries.length) throw new InteropError('input_required needs at least one input request.');
-    for (const [key, request] of entries) if (!KEY.test(key) || request?.method !== 'elicitation/create') throw new InteropError(`Input request ${key} must be a keyed elicitation/create request.`);
+    for (const [key, request] of entries) if (!KEY.test(key) || request === null || typeof request !== 'object' || Array.isArray(request) || request.method !== 'elicitation/create') throw new InteropError(`Input request ${key} must be a keyed elicitation/create request.`);
     const [finding] = inputRequestLinkFindings({ inputRequests }); // FAC-SEM-143 (D12)
     if (finding) throw new InteropError(`${finding.instancePath}: ${finding.message}`);
-    return this.transition(jobId, 'input_required', { inputRequests, statusMessage }, { steps: { ...(steps ?? {}) } });
+    return this.transition(jobId, 'input_required', { inputRequests, statusMessage }, { steps: kept });
   }
 
   answer(jobId, inputResponses) {
     const job = this.get(jobId);
     if (job.status !== 'input_required') return {};
-    const matched = Object.fromEntries(Object.entries(inputResponses ?? {}).filter(([key, value]) =>
-      key in (job.inputRequests ?? {}) && ['accept', 'decline', 'cancel'].includes(value?.action)));
+    const plain = (value) => value !== null && typeof value === 'object' && !Array.isArray(value); // as Python's dict (seam r37)
+    const asked = plain(job.inputRequests) ? job.inputRequests : {};
+    const matched = Object.fromEntries(Object.entries(plain(inputResponses) ? inputResponses : {}).filter(([key, value]) =>
+      Object.hasOwn(asked, key) && ['accept', 'decline', 'cancel'].includes(value?.action))); // an asked key, never an inherited name (seam 36)
     // The answered question's kept steps go in the same write: none outlives its answer.
     if (Object.keys(matched).length) this.transition(jobId, 'working', {}, { steps: {} });
     return matched;

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/fabric-lock.mjs

@@ -43,9 +43,19 @@ export class InstanceLock {
         if (error.code === 'EAGAIN' || error.code === 'EWOULDBLOCK') throw new AlreadyRunning(readPid(this.path), this.path);
         throw error;
       }
-      fs.ftruncateSync(this.fd, 0);
-      fs.writeSync(this.fd, String(process.pid));
-      fs.fsyncSync(this.fd);
+      try {
+        fs.ftruncateSync(this.fd, 0);
+        fs.writeSync(this.fd, String(process.pid));
+        fs.fsyncSync(this.fd);
+      } catch (error) { // a full disk or an I/O error: let the lock go, or nobody can (the caller drops this object)
+        const fd = this.fd;
+        this.fd = null;
+        try {
+          fs.closeSync(fd);
+        } catch { // a deferred write error (NFS) at the close: the lock still goes, the first error stands
+        }
+        throw error;
+      }
       return this;
     }
     // Linux: an abstract unix socket; Windows: a named pipe. Each is exclusive, has no file, and dies
@@ -66,7 +76,17 @@ export class InstanceLock {
       this.server.listen(name, resolve);
     });
     this.server.unref();
-    atomicWrite(this.path, String(process.pid));
+    try {
+      atomicWrite(this.path, String(process.pid));
+    } catch (error) { // as on macOS: the name is let go with the failed write, the first error standing
+      const server = this.server;
+      this.server = null;
+      try {
+        server.close();
+      } catch { // nothing to add to the first error
+      }
+      throw error;
+    }
     return this;
   }
 

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/fabric-mandate.mjs

@@ -45,6 +45,9 @@ export const OPERATOR_SOURCE_PROTOCOL = 'operator-source/1';
 const SCOPE_MEMBERS = new Set(['capabilities', 'actions', 'effects', 'perCallMaxUsd', 'projects']);
 const STEP_MEMBERS = new Set(['agent', 'at', 'scope']);
 const AGENT_ID = /^[a-z][a-z0-9-]{1,62}(\.[a-z][a-z0-9-]{0,31})?$/; // common.schema.json agentId
+
+/** A registry agent id (common.schema.json agentId): a provider or service id, optionally `.instance`. */
+export const isAgentId = (value) => typeof value === 'string' && AGENT_ID.test(value);
 const CAPABILITY = /^[a-z][a-z0-9._-]{1,127}$/; // common.schema.json capabilityName
 const REQUEST_KEY = /^[A-Za-z0-9_.-]{1,64}$/; // interop-common.schema.json requestKey
 const PROJECT = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;

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

@@ -62,6 +62,7 @@ from fabric_board_session import (  # noqa: F401
     _Work,
     Handler,
     Responder,
+    PERSONAL_BOARD,
 )
 from fabric_board_fixture import (  # noqa: F401
     _FIXTURE_PROJECT,

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))
@@ -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_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: