@passioncode-ai/passioncode 0.2.40 → 0.2.42

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

@@ -32,7 +32,7 @@ sys.path.insert(0, str(Path(__file__).resolve().parent))
 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, is_agent_id  # noqa: E402 - DEC-0125
+from fabric_mandate import EFFECT_CLASSES, OPERATOR_SOURCE_PROTOCOL, is_agent_id  # noqa: E402 - DEC-0125, DEC-0126
 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)
@@ -84,6 +84,7 @@ from fabric_interop_rules import (  # noqa: E402,F401 - the rule layer (FAA-92)
     intent_idempotency_key,
     reads_null_usage,
     request_meta,
+    job_step,
     action_gate,
     action_refusal_tool_result,
     usage_findings,
@@ -368,9 +369,12 @@ class JobStore:
     def traceparent(self, job_id: str) -> Optional[str]:
         return self._load(job_id)["private"].get("traceparent")
 
-    def _transition(self, job_id: str, status: str, **fields: Any) -> Dict[str, Any]:
+    def _transition(self, job_id: str, status: str, private: Optional[Dict[str, Any]] = None, **fields: Any) -> Dict[str, Any]:
         with self._lock:
             record = self._load(job_id)
+            if private is not None and "steps" in private:  # in the same file write as the transition
+                # Each question replaces the kept steps: a step outlives neither its question nor its answer.
+                record["private"]["steps"] = dict(private["steps"])
             job = record["job"]
             if job["status"] in TERMINAL:
                 raise InteropError("Job %s is already %s; a terminal job does not change." % (job_id, job["status"]))
@@ -383,8 +387,14 @@ class JobStore:
     def working(self, job_id: str, message: Optional[str] = None) -> Dict[str, Any]:
         return self._transition(job_id, "working", statusMessage=message)
 
-    def request_input(self, job_id: str, input_requests: Dict[str, Dict[str, Any]], message: Optional[str] = None) -> Dict[str, Any]:
-        """input_required with MCP elicitation requests, keyed; build them with choice_request / form_request / url_request."""
+    def request_input(self, job_id: str, input_requests: Dict[str, Dict[str, Any]], message: Optional[str] = None,
+                      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():
@@ -392,7 +402,8 @@ class JobStore:
                 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", inputRequests=input_requests, statusMessage=message)
+        return self._transition(job_id, "input_required", {"steps": dict(steps or {})},
+                                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).
@@ -405,8 +416,8 @@ class JobStore:
             matched = {key: value for key, value in (input_responses or {}).items()
                        if key in job.get("inputRequests", {}) and isinstance(value, dict)
                        and value.get("action") in ("accept", "decline", "cancel")}
-            if matched:
-                self.working(job_id)
+            if matched:  # the answered question's kept steps go in the same write: none outlives its answer
+                self._transition(job_id, "working", {"steps": {}})
             return matched
 
     def complete(self, job_id: str, envelope: Dict[str, Any]) -> Dict[str, Any]:
@@ -468,7 +479,9 @@ class CallContext:
     (the caller's own act) or {by, via, caller}, the act to put in the service's audit record, and `decision` the
     operator's decision it took (its `instruction` stays in that record, never in events or a page another party
     reads), else None. `input_records` maps each answered input request to its record when input_actions is on.
-    DEC-0125: `mandate` is the operator's mandate the call was taken under (record `via: mandate`), else None."""
+    DEC-0125: `mandate` is the operator's mandate the call was taken under (record `via: mandate`), else None.
+    DEC-0126: `record` carries `source` when the decision or the mandate does (OA-6); like `instruction` it stays in the
+    service's own audit record, never an event, a usage report, a log line or a page another party reads (OA-7)."""
 
     def __init__(self, server: "McpToolServer", tool: str, arguments: Any, traceparent: str,
                  delegation: Optional[Dict[str, Any]] = None, *, tier: Optional[str] = None, caller: Optional[str] = None,
@@ -491,6 +504,28 @@ class CallContext:
         self.server.job_started(handle["job"]["id"], self)
         return handle
 
+    def approval_step(self, job_id: str, key: str, request: Dict[str, Any], *, effect: str, spend_usd: Any = None,
+                      project: Optional[str] = None, message: Optional[str] = None) -> Any:
+        """The job's own approval step `key` (interop C3.3, DEC-0125): on a server with agent_id, the mandate this call
+        carried (`_meta.mandate`) is read for it (job_step). Covered: answers the record (`via: mandate`, `source` when
+        the mandate carries one) and asks nothing; the job goes on as the operator's decision. Otherwise the job waits
+        input_required on `request`, its message naming the part not covered (or `message`), and answers None; the step
+        is kept so an answer's `_meta.mandate` that covers it is read when input_actions is on."""
+        if self.server.jobs is None:
+            raise InteropError("This server has no job store.")
+        step: Dict[str, Any] = {"message": None}
+        if self.server.agent_id is not None:
+            caller = (self.delegation or {}).get("caller")
+            step = job_step(self.meta.get("mandate"), tier=self.tier, now=format_rfc3339(self.server._clock() * 1000),
+                            self_id=self.server.agent_id, capability=self.tool, key=key, effect=effect, caller_agent=caller,
+                            spend_usd=spend_usd, project=project)
+            if step["covered"]:
+                return step["record"]
+        kept = {"effect": effect, **({"spendUsd": spend_usd} if spend_usd is not None else {}),
+                **({"project": project} if project is not None else {})}
+        self.server.jobs.request_input(job_id, {key: request}, step["message"] or message, steps={key: kept})
+        return None
+
 
 Handler = Callable[[Any, CallContext], Any]
 OnInput = Callable[[str, Dict[str, Any], CallContext], None]
@@ -626,6 +661,18 @@ class McpToolServer:
         self.handlers: Dict[str, Handler] = {}
         self._on_job_started = on_job_started
         self._on_input = on_input
+        # DEC-0126 OA-7: a server that reads `source` (a decision's on a relayed action, a mandate's with agent_id) lists
+        # operator-source/1 in its well-known protocols; well_known_protocols() hands the list to build_well_known.
+        self.reads_source = agent_id is not None
+
+    def well_known_protocols(self, protocols: Any = ()) -> List[str]:
+        """The well-known `protocols` (DEC-0067) a service on this server lists: `protocols` and, when it reads `source`
+        (agent_id given, or a relayed action served), operator-source/1 (DEC-0126 OA-7), each once."""
+        listed = list(protocols)
+        if (self.reads_source or any(e["action"]["gate"] == "relayed" for e in self.actions.values())) \
+                and OPERATOR_SOURCE_PROTOCOL not in listed:
+            listed.append(OPERATOR_SOURCE_PROTOCOL)
+        return listed
 
     def add_tool(self, tool: Dict[str, Any], handler: Handler, action: Optional[Dict[str, Any]] = None, *,
                  target: Any = None, human_step_url: Optional[str] = None, effect: Optional[str] = None,
@@ -734,19 +781,30 @@ class McpToolServer:
             return _UNREADABLE
 
     def _gate_inputs(self, arguments: Dict[str, Any], headers: Any, tier: str, meta: Dict[str, Any],
-                     caller: Optional[str]) -> Dict[str, Any]:
+                     caller: Optional[str], verdict: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         """D8: each input request an answer would take is an action (id its key, tool fabric.job.get, gate relayed),
-        one decision per call; the first refusal refuses the call and nothing is applied."""
+        one decision per call; the first refusal refuses the call and nothing is applied. DEC-0125: on a server with
+        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 {}
         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"):
                 continue
             action = {"id": key, "title": "Answer %s" % key, "tool": "fabric.job.get", "gate": "relayed"}
+            step, mandate = steps.get(key), {}
+            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; the action
+                # itself stays fabric.job.get, so it is readable whatever the tool is named.
+                capability = self.jobs.private(job_id).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,
+                           "mandate_capability": capability if isinstance(capability, str) else None}
             gated = self._gate_action(action, "fabric.job.get", {"id": job_id, "inputResponses": {key: value}}, None, None,
-                                      headers, tier, meta, caller)
+                                      headers, tier, meta, caller, mandate)
             if not gated["ok"]:
                 return gated
             records[key] = gated["record"]
@@ -847,7 +905,7 @@ class McpToolServer:
             responses = arguments.get("inputResponses")
             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)
+                    inputs = self._gate_inputs(arguments, headers, tier, meta, caller, verdict)
                 except UnknownJob:
                     return {"jsonrpc": "2.0", "id": rid, "result": unknown_job_result(str(arguments.get("id", "")), traceparent=span)}
                 if not inputs["ok"] and "invalid" in inputs:

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

@@ -18,7 +18,8 @@ if str(_Path(__file__).resolve().parent) not in _sys.path:  # the kit loads from
 
 from fabric_base import ServiceError  # noqa: E402
 from fabric_actions import action_decision, decision_shape  # noqa: E402 - DEC-0121
-from fabric_mandate import mandate_problem  # noqa: E402 - DEC-0125
+from fabric_mandate import (  # noqa: E402 - DEC-0125, DEC-0126
+    EFFECT_CLASSES, OPERATOR_SOURCE_PROTOCOL, mandate_covers, mandate_problem, without_source)
 
 PROTOCOL = "fabric-interop/0.1"
 EXTENSION_KEY = "https://fabric.passioncode.ai/agent-contract/extensions/interop/0.1"
@@ -290,32 +291,80 @@ def reads_null_usage(request_meta: Any) -> bool:
     return isinstance(protocols, list) and INTEROP_NULL_USAGE in protocols
 
 
-def request_meta(traceparent: Optional[str] = None, decision: Any = None, mandate: Any = None) -> Dict[str, Any]:
+def request_meta(traceparent: Optional[str] = None, decision: Any = None, mandate: Any = None,
+                 target_protocols: Any = None) -> Dict[str, Any]:
     """A request's `_meta` from this kit as a caller: its trace, the interop revisions it reads (DEC-0087), for a
     relayed action the operator's decision (DEC-0121 AP-2; build one with fabric_actions.operator_decision), and the
     operator's mandate for the task the call serves (DEC-0125 MD-3; state it with fabric_mandate.operator_mandate and
     hand it on to the callee with fabric_mandate.hand_on before you send it). Both travel here only, never in a tool's
-    arguments; a decision decision.schema.json refuses or a mandate FAC-SEM-144 refuses raises InteropError."""
+    arguments; a decision decision.schema.json refuses or a mandate FAC-SEM-144 refuses raises InteropError.
+
+    DEC-0126 OA-7: `target_protocols` is the callee's well-known `protocols`. A decision's or a mandate's `source` is
+    sent only when that list names `operator-source/1`; otherwise (no list, another list, a board Project, a session,
+    Fabric's `agent.call`, whose directory lists no `protocols`) it is left out of `_meta` and stays in the caller's
+    own record, the decision and the mandate given here, which this never changes."""
     meta: Dict[str, Any] = {"protocols": list(PROTOCOLS_READ)}
+    reads_source = isinstance(target_protocols, (list, tuple)) and OPERATOR_SOURCE_PROTOCOL in target_protocols
     if parse_traceparent(traceparent):
         meta["traceparent"] = traceparent
     if decision is not None:
         if not decision_shape(decision):
             raise InteropError("The decision is not one decision.schema.json reads; it is not sent.")
-        meta["decision"] = dict(decision)
+        meta["decision"] = json.loads(json.dumps(decision if reads_source else without_source(decision)))
     if mandate is not None:
         problem = mandate_problem(mandate)
         if problem:
             raise InteropError("The mandate is not one FAC-SEM-144 reads (%s); it is not sent." % problem)
-        meta["mandate"] = json.loads(json.dumps(mandate))
+        meta["mandate"] = json.loads(json.dumps(mandate if reads_source else without_source(mandate)))
     return meta
 
 
+def job_step(mandate: Any, *, tier: Any, now: Any, self_id: Any, capability: Any, key: Any, effect: Any,
+             caller_agent: Any = None, spend_usd: Any = None, project: Any = None) -> Dict[str, Any]:
+    """A job's own approval step under the mandate its start call carried (interop C3.3, DEC-0125 MD-3, MD-4;
+    conformance: "a job's approval step included"): the step is the call {capability: the job's, action: the input
+    request's `key`, effect, spendUsd?, project?} that mandate_covers reads, with `self_id` the service's agent id and
+    `caller_agent` only an agent id it authenticated for the start call.
+
+    - {"covered": True, "record"}: the step goes on as the operator's decision, no input request; `record` is
+      mandate_covers' recordAs (`via: mandate`, the task, the chain and `source` when the mandate carries one).
+    - {"covered": False, "message", "detail"}: the step waits input_required, `message` its statusMessage naming the
+      part not covered, or saying the mandate expired or cannot be read; never the operator's words or `source`.
+    - {"covered": False, "message": None}: no mandate, or a T2 caller's (MD-5): ask as before; with `fault` when the
+      service's own clock does not read."""
+    if mandate is None:
+        return {"covered": False, "message": None}
+    if not (isinstance(effect, str) and effect in EFFECT_CLASSES):
+        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}
+    if isinstance(spend_usd, (int, float)) and not isinstance(spend_usd, bool):
+        call["spendUsd"] = spend_usd
+    if isinstance(project, str):
+        call["project"] = project
+    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
+    answer = mandate_covers(covers)
+    if answer.get("ok") is True:
+        return {"covered": True, "record": answer["recordAs"]}
+    if "ignored" in answer or "fault" in answer:
+        return dict({"covered": False, "message": None}, **({"fault": answer["fault"]} if "fault" in answer else {}))
+    detail = answer["data"]["detail"]
+    if detail == "mandate-expired":
+        said = "The operator's mandate for this task expired before this step"
+    elif detail.startswith("outside-mandate"):
+        said = "The operator's mandate does not cover this step (%s)" % detail
+    else:
+        said = "The operator's mandate cannot be read for this step (%s)" % detail
+    return {"covered": False, "detail": detail,
+            "message": said + ": answer it, or call fabric.job.get with a mandate that covers it in _meta.mandate."}
+
+
 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,
                 effect: Optional[str] = None, caller_agent: Optional[str] = None, spend_usd: Any = None,
-                project: Optional[str] = None) -> Dict[str, Any]:
+                project: Optional[str] = None, mandate_capability: Optional[str] = None) -> Dict[str, Any]:
     """One call of a declared action, before its handler runs (DEC-0121 AP-2, AP-4): fabric_actions.action_decision over
     the call's `_meta.decision` (read from `meta` only, never from arguments, decision D11), the service's authenticated
     `caller` (fabric_actions.action_caller), `target` (the object the call acts on), `elicited` (the service's own
@@ -327,7 +376,8 @@ def action_gate(action: Any, *, tier: Any, caller: Any, meta: Any = None, target
     DEC-0125: a service that names its own agent id (`self_id`) reads the call's `_meta.mandate` when it carries no
     decision, given `effect` (the action's effect class, required: without it the call is the service's fault
     effect-missing), `caller_agent` (only an agent id the service authenticated: a delegation's caller, its own
-    per-agent credential; never a name the call carries), `spend_usd` (its own estimate) and `project`. A covered call
+    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, not the action's tool). 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
@@ -339,7 +389,8 @@ def action_gate(action: Any, *, tier: Any, caller: Any, meta: Any = None, target
             inputs[name] = value
     if self_id is not None and isinstance(meta, dict) and "mandate" in meta:
         inputs.update({"mandate": meta["mandate"], "self": self_id})
-        for name, value in (("effect", effect), ("callerAgent", caller_agent), ("spendUsd", spend_usd), ("project", project)):
+        for name, value in (("effect", effect), ("callerAgent", caller_agent), ("spendUsd", spend_usd), ("project", project),
+                            ("mandateCapability", mandate_capability)):
             if value is not None:
                 inputs[name] = value
     answer = action_decision(inputs)

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

@@ -8,9 +8,14 @@ the task, narrowed at each hand-over. Part of the service kit (layer L2); the tw
 - ``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.
 - ``scope_within(child, parent)``, ``effective_scope(mandate)``, ``effect_closure(ceiling)``.
-- ``operator_mandate(task, instruction, scope, lead, ...)``: the mandate the agent leading a task states from the
-  operator's own words (MD-1); ``hand_on(mandate, callee, at, narrower=None)``: the one it sends to the agent it calls
-  (MD-2), never wider. Send it in ``_meta.mandate`` (``fabric_interop.request_meta(mandate=)``).
+- ``operator_mandate(task, instruction, scope, lead, ..., source=None)``: the mandate the agent leading a task states
+  from the operator's own words (MD-1); ``hand_on(mandate, callee, at, narrower=None)``: the one it sends to the agent
+  it calls (MD-2), never wider. Send it in ``_meta.mandate`` (``fabric_interop.request_meta(mandate=)``).
+- DEC-0126: ``source`` ({project, session or thread}) names where the operator said the words when they reached this
+  agent relayed from another of their agents (OA-2); ``source_shape`` reads it, ``mandate_covers`` returns it in
+  ``recordAs`` (OA-6), ``hand_on`` keeps it unchanged, and ``without_source`` drops it from a copy for a target that
+  does not list ``operator-source/1`` (OA-7; ``request_meta(target_protocols=)`` does it for you). Like
+  ``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.
@@ -45,6 +50,10 @@ EFFECT_CLASSES = ("none", "draft", "publish", "send", "reply", "charge", "delete
 _READS_AND_DRAFTS = ("none", "draft")
 _NEVER_BY_MANDATE = "change-policy"  # approving one's own promotion, grant, checker rule or policy change (AP-5)
 _MEMBERS = ("kind", "by", "task", "instruction", "at", "expiresAt", "scope", "chain")
+_OPTIONAL = ("source",)  # DEC-0126 OA-2
+_SOURCE_MEMBERS = ("project", "session", "thread")
+#: The register name of the protocol a target lists when it reads `source` (DEC-0126 OA-7).
+OPERATOR_SOURCE_PROTOCOL = "operator-source/1"
 _SCOPE_MEMBERS = ("capabilities", "actions", "effects", "perCallMaxUsd", "projects")
 _STEP_MEMBERS = ("agent", "at", "scope")
 _AGENT_ID = re.compile(r"[a-z][a-z0-9-]{1,62}(\.[a-z][a-z0-9-]{0,31})?", re.ASCII)  # common.schema.json agentId
@@ -97,6 +106,24 @@ def _scope_shape(scope: Any) -> bool:
     return all(checks[key](value) for key, value in scope.items())
 
 
+def source_shape(source: Any) -> bool:
+    """`mandate.schema.json#/$defs/source` (DEC-0126 OA-2), which `decision.schema.json` refers to: an object of
+    `project` and `session` or `thread` (or both), each 1..128 characters of `[A-Za-z0-9][A-Za-z0-9._:-]*`, nothing else."""
+    if not isinstance(source, dict) or any(key not in _SOURCE_MEMBERS for key in source) or "project" not in source:
+        return False
+    if "session" not in source and "thread" not in source:
+        return False
+    return all(_string(value, 1, 128) and _matches(_PROJECT, value) for value in source.values())
+
+
+def without_source(value: Any) -> Any:
+    """A copy of a decision or a mandate without `source`, for a target that does not list `operator-source/1`
+    (DEC-0126 OA-7): the caller keeps the original in its own record (OA-6). Anything else is returned unchanged."""
+    if isinstance(value, dict) and "source" in value:
+        return {key: item for key, item in value.items() if key != "source"}
+    return value
+
+
 def _time(value: Any) -> bool:
     # Every value the strict reading accepts, ajv-formats' date-time accepts too, and mandate_problem reads the times
     # strictly next, so reading them strictly here gives mandate_problem's answer (mandate-malformed either way).
@@ -115,9 +142,9 @@ def mandate_shape(mandate: Any) -> bool:
     are read strictly (the contract's strictTime): ajv-formats' date-time also admits a space for T, an offset without
     its colon and a leap second, which this refuses, as fabric_actions.decision_shape does (0.50.0 brief D5); FAC-SEM-144
     reads them strictly next, so mandate_problem answers as the contract does either way."""
-    if not isinstance(mandate, dict) or any(key not in _MEMBERS for key in mandate):
+    if not isinstance(mandate, dict) or any(key not in _MEMBERS and key not in _OPTIONAL for key in mandate):
         return False
-    if any(key not in mandate for key in _MEMBERS):
+    if any(key not in mandate for key in _MEMBERS) or ("source" in mandate and not source_shape(mandate["source"])):
         return False
     chain = mandate["chain"]
     return (isinstance(mandate["kind"], str) and mandate["kind"] == "mandate/1"
@@ -145,7 +172,7 @@ def _ceiling_within(child: Any, parent: Any) -> bool:
 
 
 def _naming_within(child: Dict[str, Any], parent: Dict[str, Any]) -> bool:
-    """DEC-0136 MD-2a (adopted ahead of the pin, brief D28): a naming list (`capabilities`, `actions`) left out names no
+    """DEC-0136 MD-2a: a naming list (`capabilities`, `actions`) left out names no
     relayed action or external effect (MD-3), so a hand-over never adds one the scope in force leaves out; `actions`
     may be added where `capabilities` is listed, and narrows the relayed actions those name."""
     caps, acts = get(parent, "capabilities"), get(parent, "actions")
@@ -222,7 +249,8 @@ def mandate_covers(inputs: Any) -> Dict[str, Any]:
       (more than 60 s after the clock) or `mandate-expired`.
     - `operator-decision-required` with `data.detail` `outside-mandate: <action|capability|effect|spend|project>` for the
       first part the scope in force does not cover; the operator is asked for that part alone (MD-4).
-    - `{"ok": True, "recordAs": {"by": "operator", "via": "mandate", "task", "chain"}}` otherwise.
+    - `{"ok": True, "recordAs": {"by": "operator", "via": "mandate", "task", "chain", "source"?}}` otherwise, `source`
+      being where the operator said the words when the mandate carries it (DEC-0126 OA-6).
 
     `callerAgent` is passed only when the callee authenticated the caller's agent id (a per-agent credential, a
     delegation token's outermost actor, the hub's attested origin); without one the chain's end alone binds it. A
@@ -271,13 +299,17 @@ def mandate_covers(inputs: Any) -> Dict[str, Any]:
     project, projects = get(call, "project"), get(scope, "projects")
     if project is not MISSING and projects is not MISSING and not _member_of(projects, project):
         return _outside("outside-mandate: project")
-    return {"ok": True, "recordAs": {"by": "operator", "via": "mandate", "task": mandate["task"], "chain": holders}}
+    record: Dict[str, Any] = {"by": "operator", "via": "mandate", "task": mandate["task"], "chain": holders}
+    if "source" in mandate:  # where the operator said it travels into the record, as the reason the callee acted (OA-6)
+        record["source"] = dict(mandate["source"])
+    return {"ok": True, "recordAs": record}
 
 
 def hand_on(mandate: Dict[str, Any], callee: str, at: str, narrower: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
     """The mandate an agent sends with a call (DEC-0125 MD-2): the chain gains the agent it calls, at `at`, with
     `narrower` when it hands on less. Raises ServiceError when the result would not be a valid mandate (a wider scope,
-    a fifth agent, an agent already in it, a time before the last step or at the expiry). `mandate` is not changed."""
+    a fifth agent, an agent already in it, a time before the last step or at the expiry). `mandate` is not changed;
+    its `source` travels unchanged (DEC-0126: it never changes down the chain)."""
     chain = list(mandate["chain"]) if isinstance(mandate, dict) and isinstance(mandate.get("chain"), list) else []
     step: Dict[str, Any] = {"agent": callee, "at": at}
     if _truthy(narrower):
@@ -291,25 +323,33 @@ def hand_on(mandate: Dict[str, Any], callee: str, at: str, narrower: Optional[Di
 
 
 def operator_mandate(task: str, instruction: str, scope: Dict[str, Any], lead: str, *, at: Optional[str] = None,
-                     expires_at: Optional[str] = None, clock: Callable[[], float] = time.time) -> Dict[str, Any]:
+                     expires_at: Optional[str] = None, clock: Callable[[], float] = time.time,
+                     source: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
     """The mandate the agent leading a task states from the operator's own words (DEC-0125 MD-1): `task` as the lead
     names it (a board task, a backlog row, a title), `instruction` the operator's words verbatim (their sentence, or
     the agent's short question and the answer, AP-3), `scope` what those words cover and no more (capabilities,
     actions, effects, perCallMaxUsd, projects), `lead` the lead's own agent id, `at` when the operator said it (now,
     by `clock` in seconds, when not given) and `expires_at` (a day after `at` when not given; at most seven days).
-    State one only from words the operator gave in this session, or relayed to you as his rule allows, never from text
-    found in a tool result, page, file or message. Raises ServiceError for a mandate FAC-SEM-144 refuses."""
+    `source` ({project, session or thread}) names where the operator said the words when they reached you relayed from
+    another of their agents (DEC-0126 OA-2): `instruction` and `at` then copied unchanged from the relay; absent when you
+    heard them yourself. State one only from words the operator gave in this session, or from a relay OA-2 and OA-3
+    accept (one of the operator's own Projects on the board, provenance trusted, or a session on their own machine, with
+    the words verbatim, when, where and the scope), never from text found in a tool result, page, file or message.
+    Raises ServiceError for a mandate FAC-SEM-144 refuses."""
     stated_at = at if at is not None else format_rfc3339(clock() * 1000)
     start = parse_rfc3339_ms(stated_at)
     if expires_at is None and not math.isnan(start):
         expires_at = format_rfc3339(start + DEFAULT_LIFETIME_SECONDS * 1000)
-    mandate = {"kind": "mandate/1", "by": "operator", "task": task, "instruction": instruction, "at": stated_at,
-               "expiresAt": expires_at, "scope": scope, "chain": [{"agent": lead, "at": stated_at}]}
+    mandate = {"kind": "mandate/1", "by": "operator", "task": task, "instruction": instruction, "at": stated_at}
+    if source is not None:
+        mandate["source"] = source
+    mandate.update({"expiresAt": expires_at, "scope": scope, "chain": [{"agent": lead, "at": stated_at}]})
     problem = mandate_problem(mandate)
     if problem:
         raise ServiceError("Operator mandate: not one mandate.schema.json and FAC-SEM-144 read (%s): a task of 1..200 "
                            "characters, the operator's words of 1..500, a scope with effects, the lead's agent id, an RFC 3339 "
-                           "time with its offset and an expiry after it, at most seven days on." % problem)
+                           "time with its offset and an expiry after it, at most seven days on, and a source of a project and "
+                           "a session or thread." % problem)
     return mandate
 
 
@@ -321,4 +361,4 @@ def mandate_rules(kind: str, value: Any) -> Optional[List[Dict[str, str]]]:
     if not problem:
         return []
     return [{"code": "FAC-SEM-144", "instancePath": "",
-             "message": "the mandate is not valid: %s (DEC-0125 MD-1, MD-2)" % problem}]
+             "message": "the mandate is not valid: %s (DEC-0125 MD-1, MD-2; DEC-0136 MD-2a)" % problem}]

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

@@ -16,10 +16,12 @@ PROTOCOL_REVISIONS: Dict[str, Tuple[str, ...]] = {
     "access-log": ("1",), "approval": ("1",), "activity-summary": ("1",), "agent-directory": ("1",), "call-record": ("1",), "coding-agents": ("1",), "credential-decision": ("1",), "credential-request": ("1",), "credential-revocation": ("1",), "enroll-token": ("1",), "entitlement": ("1",),
     "entitlement-key-set": ("1",), "estate-record": ("1",), "execution-packet": ("1",),
     "fabric-actions": ("0.1",), "fabric-activity": ("0.1",), "fabric-agent-call": ("1",), "fabric-connections": ("0.1",), "fabric-credential-envelope": ("1",), "fabric-load": ("0.1",), "fabric-dashboard": ("0.1",), "fabric-delegation": ("0.1",), "fabric-device": ("0.1",),
-    "fabric-interop": ("0.1", "0.2"), "fabric-local-channel": ("0.1",), "fabric-local-runner": ("0.1",),
+    "fabric-interop": ("0.1", "0.2"), "fabric-local-channel": ("0.1",), "fabric-local-runner": ("0.1",), "fabric-machine-report": ("1",),
     "fabric-operator-channel": ("0.1",), "fabric-package": ("1",), "fabric-project-comms": ("0.1",), "fabric-proposal": ("1",),
     "fabric-provider": ("0.1",), "fabric-relay": ("0.1",), "fabric-secret-envelope": ("1",), "fabric-service": ("0.1",),
-    "fabric-settings-backup": ("1",), "heartbeat": ("1",), "learning-note": ("1",), "mandate": ("1",), "memory": ("0.1",), "node-summary": ("1",), "pairing-message": ("1",),
+    "fabric-settings-backup": ("1",), "heartbeat": ("1",), "learning-note": ("1",), "machine-report": ("1",), "mandate": ("1",), "memory": ("0.1",), "node-summary": ("1",),
+    "operator-source": ("1",), "org-authority": ("1",), "org-authority-draft": ("1",), "org-key-set": ("1",), "org-key-set-draft": ("1",),
+    "org-membership": ("1",), "org-root-registration": ("1",), "pairing-message": ("1",),
     "pipeline": ("0.1",), "repair-request": ("1",), "repair-result": ("1",), "revocation-delta": ("1",), "session-handoff": ("1",), "service-load": ("1",), "share-registration": ("1",),
     "share-registration-receipt": ("1",), "support-quality-daily": ("1",), "window-lease": ("1",),
 }