@passioncode-ai/passioncode 0.2.38 → 0.2.39

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

@@ -24,11 +24,14 @@ from pathlib import Path
 import re
 import secrets
 import sys
+import time
 from typing import Any, Callable, Dict, List, Optional
 
 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_time import format_rfc3339  # noqa: E402 - the core's (FAA-65)
 
 from fabric_interop_rules import (  # noqa: E402,F401 - the rule layer (FAA-92)
     _days_from_civil,
@@ -77,6 +80,8 @@ from fabric_interop_rules import (  # noqa: E402,F401 - the rule layer (FAA-92)
     intent_idempotency_key,
     reads_null_usage,
     request_meta,
+    action_gate,
+    action_refusal_tool_result,
     usage_findings,
     usage_toward,
     _job_findings,
@@ -430,16 +435,26 @@ class JobStore:
 # --- a minimal MCP tool server (streamable HTTP, JSON responses) ------------------------
 
 class CallContext:
-    """What a tool handler gets: the child span it runs in, and a way to start a job."""
+    """What a tool handler gets: the child span it runs in, and a way to start a job.
+
+    DEC-0121: `tier` is the caller's (DL-25), `caller` the identity the service authenticated (decision D9), `meta`
+    the request's `_meta`. For a tool registered with an action, `record` is action_decision's recordAs: "caller"
+    (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."""
 
     def __init__(self, server: "McpToolServer", tool: str, arguments: Any, traceparent: str,
-                 delegation: Optional[Dict[str, Any]] = None):
+                 delegation: Optional[Dict[str, Any]] = None, *, tier: Optional[str] = None, caller: Optional[str] = None,
+                 meta: Optional[Dict[str, Any]] = None, record: Any = None, decision: Optional[Dict[str, Any]] = None,
+                 input_records: Optional[Dict[str, Any]] = None):
         self.server = server
         self.tool = tool
         self.arguments = arguments
         self.traceparent = traceparent
         # DEC-0039: the accepted delegation (principal, caller, chain, claims) when the server has a gate.
         self.delegation = delegation
+        self.tier, self.caller, self.meta = tier, caller, {} if meta is None else meta
+        self.record, self.decision, self.input_records = record, decision, input_records
 
     def start_job(self, poll_interval_ms: Optional[int] = None) -> Dict[str, Any]:
         if self.server.jobs is None:
@@ -547,11 +562,26 @@ class McpToolServer:
     def __init__(self, name: str, version: str, jobs: Optional[JobStore] = None,
                  on_job_started: Optional[Callable[[str, CallContext], None]] = None,
                  on_input: Optional[OnInput] = None,
-                 authorize: Optional[Callable[[str, Any], Dict[str, Any]]] = None):
+                 authorize: Optional[Callable[[str, Any], Dict[str, Any]]] = None, *,
+                 identify: Optional[Callable[[Any, str], Optional[str]]] = None,
+                 approve: Optional[Callable[[str, Dict[str, Any], Any, str], Optional[Dict[str, Any]]]] = None,
+                 elicited: Optional[Callable[[str, Dict[str, Any], Optional[str]], bool]] = None,
+                 input_actions: bool = False, clock: Callable[[], float] = time.time,
+                 on_fault: Optional[Callable[[str, str], None]] = None):
         # authorize(tool, headers, tier=) runs before every handler (fabric_delegation.delegation_gate, DEC-0039):
         # a refusal is answered in the DL-19 shape and the handler never runs. The built-in job tools are
         # gated by the job's own capability, and answered only for the principal and caller that started it.
+        # DEC-0121: a tool added with an action runs action_gate after authorize and before its handler.
+        # identify(headers, tier) names the caller the service authenticated when no delegation did (D9; else
+        # local:T0 / local:T1); approve(tool, arguments, headers, digest) answers verify_approval's outcome for an
+        # approval the call presented, or None; elicited(tool, arguments, caller) is True only on the service's own
+        # record of an accepted elicitation. input_actions=True gates each answered input request as an action (D8).
+        # on_fault(tool, fault) hears a service fault the caller only sees as unknown-state (e.g. caller-missing: an
+        # action-gated server needs a tier, identify or authorize that names who calls).
         self._authorize = authorize
+        self._identify, self._approve, self._elicited = identify, approve, elicited
+        self.input_actions, self._clock, self._on_fault = input_actions is True, clock, on_fault
+        self.actions: Dict[str, Dict[str, Any]] = {}
         self.info = {"name": name, "version": version}
         self.jobs = jobs
         self.tools: List[Dict[str, Any]] = []
@@ -559,14 +589,101 @@ class McpToolServer:
         self._on_job_started = on_job_started
         self._on_input = on_input
 
-    def add_tool(self, tool: Dict[str, Any], handler: Handler) -> None:
+    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) -> None:
+        """Serve a tool. `action` (DEC-0121 AP-1) is the declared action this tool performs, {id, title, tool, gate,
+        humanStep?}, its `tool` this tool's name: the server runs action_gate before the handler. `target` names the
+        object a call acts on: an argument's name, or a function of the arguments; `human_step_url` is the link of a
+        `human` action's step (an https URL or a path on the service's origin, AP-4)."""
         if tool["name"] in self.handlers:
             raise InteropError("Tool %s is served twice." % tool["name"])
         if "outputSchema" in tool:
             require_object_root(tool["name"], tool["outputSchema"])
+        if action is not None:
+            if not readable_action(action) or action["tool"] != tool["name"]:
+                raise InteropError("Tool %s: its action is not a declared action of this tool (DEC-0121)." % tool["name"])
+            if action["id"] in {a["action"]["id"] for a in self.actions.values()}:
+                raise InteropError("Action %s is declared twice." % action["id"])
+            if action["gate"] == "human" and not (isinstance(human_step_url, str) and re.match(r"https://|/", human_step_url)):
+                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"])
+            self.actions[tool["name"]] = {"action": dict(action), "target": target, "url": human_step_url}
         self.tools.append(tool)
         self.handlers[tool["name"]] = handler
 
+    def action_table(self) -> List[Dict[str, Any]]:
+        """The declared actions in the order they were added: build_well_known(actions=) writes them (DEC-0121 AP-1)."""
+        return [dict(entry["action"]) for entry in self.actions.values()]
+
+    def _caller(self, headers: Any, tier: str, verdict: Optional[Dict[str, Any]]) -> Optional[str]:
+        """D9: the delegation's caller when a gate accepted a token, else identify(headers, tier), else the local floor."""
+        authenticated = (verdict or {}).get("caller")
+        if not authenticated and self._identify is not None:
+            authenticated = self._identify(headers, tier)
+        return action_caller(tier, authenticated)
+
+    def _gate_action(self, action: Dict[str, Any], name: str, arguments: Dict[str, Any], target: Any, url: Any,
+                     headers: Any, tier: str, meta: Dict[str, Any], caller: Optional[str]) -> Dict[str, Any]:
+        """action_gate for one call: the approval the call presented, the digest of {tool, arguments}, the clock."""
+        digest, approval = None, None
+        if action["gate"] == "relayed":
+            import fabric_delegation as _fd  # noqa: E402 - only an action-gated server needs it
+            try:
+                digest = _fd.action_digest({"tool": name, "arguments": arguments})
+            except (TypeError, ValueError, RecursionError):  # no canonical form (a lone surrogate, a non-finite number,
+                # nesting past the recursion limit), as intent_digest reads it: no digest to bind
+                return {"ok": False, "invalid": "Invalid params: the arguments have no canonical form."}
+            outcome = self._approve(name, arguments, headers, digest) if self._approve is not None else None
+            if isinstance(outcome, dict) and outcome.get("ok") is True:
+                approval = outcome
+            elif isinstance(outcome, dict) and outcome.get("code") not in (None, "approval-required"):
+                # DL-18: the presented approval's own refusal; an outcome that is not verify_approval's is the service's.
+                readable = outcome.get("code") in _fd.REFUSAL_CODES and isinstance(outcome.get("detail"), str) and outcome["detail"]
+                if readable:
+                    return {"ok": False, "refusal": outcome}
+                return {"ok": False, "refusal": {"ok": False, "code": "unknown-state", "detail": "service-fault"},
+                        "fault": "approval-outcome-unreadable"}
+        elicited = action["gate"] == "relayed" and self._elicited is not None and self._elicited(name, arguments, caller) is True
+        return action_gate(action, tier=tier, caller=caller, meta=meta, target=target, elicited=elicited, approval=approval,
+                           action_digest=digest, human_step_url=url, now=format_rfc3339(self._clock() * 1000))
+
+    def _gate_inputs(self, arguments: Dict[str, Any], headers: Any, tier: str, meta: Dict[str, Any],
+                     caller: Optional[str]) -> 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."""
+        job_id = str(arguments.get("id", ""))
+        job = self.jobs.get(job_id)
+        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"}
+            gated = self._gate_action(action, "fabric.job.get", {"id": job_id, "inputResponses": {key: value}}, None, None,
+                                      headers, tier, meta, caller)
+            if not gated["ok"]:
+                return gated
+            records[key] = gated["record"]
+        return {"ok": True, "records": records}
+
+    def _fault(self, tool: str, gated: Dict[str, Any]) -> None:
+        """Hand a service fault to on_fault; the caller saw only unknown-state. A hook that raises is the service's."""
+        if gated.get("fault") and self._on_fault is not None:
+            try:
+                self._on_fault(tool, str(gated["fault"]))
+            except Exception:  # noqa: BLE001 - logging must not change the answer
+                pass
+
+    @staticmethod
+    def _target(target: Any, arguments: Dict[str, Any]) -> Optional[str]:
+        """The object a call acts on: the named argument, or what the service's function answers; a string or None."""
+        try:
+            value = target(arguments) if callable(target) else arguments.get(target) if isinstance(target, str) else None
+        except Exception:  # noqa: BLE001 - a function that cannot read this call names no object
+            return None
+        return value if isinstance(value, str) else None
+
     def job_started(self, job_id: str, ctx: CallContext) -> None:
         if self._on_job_started:
             self._on_job_started(job_id, ctx)
@@ -641,7 +758,21 @@ class McpToolServer:
                 if not verdict.get("ok"):
                     import fabric_delegation as _fd  # noqa: E402 - only a gated server needs it
                     return {"jsonrpc": "2.0", "id": rid, "result": _fd.refusal_tool_result(verdict, traceparent=span)}
-            return {"jsonrpc": "2.0", "id": rid, "result": self._job_call(name, arguments, span, verdict)}
+            caller, inputs = self._caller(headers, tier, verdict), None
+            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)
+                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:
+                    return self._error(rid, -32602, inputs["invalid"])
+                if not inputs["ok"]:
+                    self._fault(name, inputs)
+                    import fabric_delegation as _fd  # noqa: E402 - DL-19
+                    return {"jsonrpc": "2.0", "id": rid, "result": _fd.refusal_tool_result(inputs["refusal"], traceparent=span)}
+            context = {"tier": tier, "caller": caller, "meta": meta, "input_records": inputs["records"] if inputs else None}
+            return {"jsonrpc": "2.0", "id": rid, "result": self._job_call(name, arguments, span, verdict, context)}
         handler = self.handlers.get(name)
         if handler is None:
             return self._error(rid, -32602, "Unknown tool: %s." % name)
@@ -652,14 +783,26 @@ class McpToolServer:
                 import fabric_delegation as _fd  # noqa: E402 - only a gated server needs it
                 return {"jsonrpc": "2.0", "id": rid, "result": _fd.refusal_tool_result(verdict, traceparent=span)}
             delegation = verdict
+        caller, gated, entry = self._caller(headers, tier, delegation), {"record": None, "decision": None}, self.actions.get(name)
+        if entry is not None:  # DEC-0121: after the authorize gate, before the handler
+            gated = self._gate_action(entry["action"], name, arguments, self._target(entry["target"], arguments), entry["url"],
+                                      headers, tier, meta, caller)
+            if not gated["ok"] and "invalid" in gated:
+                return self._error(rid, -32602, gated["invalid"])
+            if not gated["ok"]:
+                self._fault(name, gated)
+                import fabric_delegation as _fd  # noqa: E402 - DL-19
+                return {"jsonrpc": "2.0", "id": rid, "result": _fd.refusal_tool_result(gated["refusal"], traceparent=span)}
+        context = CallContext(self, name, arguments, span, delegation, tier=tier, caller=caller, meta=meta,
+                              record=gated["record"], decision=gated["decision"])
         try:
-            structured = handler(arguments, CallContext(self, name, arguments, span, delegation))
+            structured = handler(arguments, context)
         except InteropError as exc:
             return {"jsonrpc": "2.0", "id": rid, "result": tool_result({"error": {"code": "tool-error", "message": str(exc)}}, is_error=True, traceparent=span)}
         return {"jsonrpc": "2.0", "id": rid, "result": tool_result(structured, traceparent=span)}
 
     def _job_call(self, name: str, arguments: Dict[str, Any], span: str,
-                  delegation: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+                  delegation: Optional[Dict[str, Any]] = None, context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         job_id = str(arguments.get("id", ""))
         try:
             job_span = self.jobs.traceparent(job_id) or span
@@ -674,11 +817,14 @@ class McpToolServer:
                         state = self.jobs.get(job_id)
                 return tool_result({"job": state}, traceparent=job_span)
             responses = arguments.get("inputResponses")
+            context = context or {}
+            if responses and context.get("input_records") is not None:  # D8: only the keys the action gate took
+                responses = {key: responses[key] for key in context["input_records"]}
             if responses:
                 matched = self.jobs.answer(job_id, responses)
                 if matched and self._on_input:
                     private = self.jobs.private(job_id)
-                    self._on_input(job_id, matched, CallContext(self, private["capability"], private["input"], job_span, delegation))
+                    self._on_input(job_id, matched, CallContext(self, private["capability"], private["input"], job_span, delegation, **context))
             return tool_result({"job": self.jobs.get(job_id)}, traceparent=job_span)
         except UnknownJob:
             return unknown_job_result(job_id, traceparent=span)

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

@@ -17,6 +17,7 @@ if str(_Path(__file__).resolve().parent) not in _sys.path:  # the kit loads from
     _sys.path.insert(0, str(_Path(__file__).resolve().parent))
 
 from fabric_base import ServiceError  # noqa: E402
+from fabric_actions import action_decision, decision_shape  # noqa: E402 - DEC-0121
 
 PROTOCOL = "fabric-interop/0.1"
 EXTENSION_KEY = "https://fabric.passioncode.ai/agent-contract/extensions/interop/0.1"
@@ -288,14 +289,56 @@ 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) -> Dict[str, Any]:
-    """A request's `_meta` from this kit as a caller: its trace, and the interop revisions it reads (DEC-0087)."""
+def request_meta(traceparent: Optional[str] = None, decision: Any = None) -> Dict[str, Any]:
+    """A request's `_meta` from this kit as a caller: its trace, the interop revisions it reads (DEC-0087) and, for a
+    relayed action, the operator's decision (DEC-0121 AP-2; build one with fabric_actions.operator_decision). A
+    decision travels here only, never in a tool's arguments; one decision.schema.json refuses raises InteropError."""
     meta: Dict[str, Any] = {"protocols": list(PROTOCOLS_READ)}
     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)
     return meta
 
 
+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) -> 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
+    record of an accepted elicitation), `approval` (verify_approval's accepted outcome), `action_digest`,
+    `human_step_url` and `now` (RFC 3339). Answers {ok: True, record, decision}, `decision` being the one taken as the
+    operator's (None otherwise), or {ok: False, refusal} in the DL-19 form (fabric_delegation.refusal_tool_result
+    sends it); a service's own fault is the refusal unknown-state with `fault` beside it for the service's log."""
+    import fabric_delegation as _fd  # noqa: E402 - beside this file: DL-19
+    inputs: Dict[str, Any] = {"action": action, "tier": tier, "caller": caller, "elicited": elicited is True, "now": now}
+    if isinstance(meta, dict) and "decision" in meta:
+        inputs["decision"] = meta["decision"]
+    for name, value in (("target", target), ("approval", approval), ("actionDigest", action_digest), ("humanStepUrl", human_step_url)):
+        if value is not None:
+            inputs[name] = value
+    answer = action_decision(inputs)
+    if answer.get("ok") is True:
+        record = answer["recordAs"]
+        taken = isinstance(record, dict) and record.get("via") == "relayed-instruction"
+        return {"ok": True, "record": record, "decision": inputs["decision"] if taken else None}
+    out: Dict[str, Any] = {"ok": False, "refusal": _fd.refusal_from_action(answer)}
+    if "fault" in answer:
+        out["fault"] = answer["fault"]
+    return out
+
+
+def action_refusal_tool_result(answer: Any, traceparent: Optional[str] = None) -> Optional[Dict[str, Any]]:
+    """The tools/call result a service's own MCP server answers for an action_decision answer: None when the action
+    takes the call, else DL-19's refusal as structuredContent with isError true (DEC-0121)."""
+    import fabric_delegation as _fd  # noqa: E402 - beside this file: DL-19
+    refusal = _fd.refusal_from_action(answer)
+    return None if refusal is None else _fd.refusal_tool_result(refusal, traceparent=traceparent)
+
+
 def usage_findings(usage: Any, at: str) -> List[Dict[str, str]]:
     """FAC-SEM-119 on a usage: partial false asserts every number known, so it stands beside no null."""
     if not isinstance(usage, dict) or usage.get("partial", _ABSENT) is not False:

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

@@ -15,7 +15,7 @@ if str(_Path(__file__).resolve().parent) not in _sys.path:  # the kit loads from
 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-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-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-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",),

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

@@ -181,6 +181,15 @@ from fabric_backups import (  # noqa: F401
     newest_intact_backup,
     restore_plan,
 )
+from fabric_actions import (  # noqa: F401
+    ACTIONS_EXTENSION_KEY,
+    action_decision,
+    action_rules,
+    actions_extension,
+    actions_extension_rules,
+    actions_view,
+    decision_shape,
+)
 from fabric_connections import (  # noqa: F401
     CONNECTIONS_EXTENSION_KEY,
     connections_extension,

package/payload/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/kit.json

@@ -1,6 +1,6 @@
 {
  "name": "fabric-service-kit",
- "version": "0.49.3",
+ "version": "0.50.0",
  "about": "The service kit's modules in dependency order: a module imports only modules listed before it. Written by fabric_kit.py build; edit the order and layers by hand, never the digests.",
  "python": [
   {
@@ -89,7 +89,7 @@
     "fabric_jsvalue",
     "fabric_paths"
    ],
-   "sha256": "6638a6039befe3b43f59018bab292e050931af21b544df1044cd5059572ded36"
+   "sha256": "f6c135126d2b9f6ff0c93f2947be1aa03d99460cb759495f51fe86f3edf481b3"
   },
   {
    "module": "fabric_share",
@@ -150,7 +150,18 @@
    "imports": [
     "fabric_secrets"
    ],
-   "sha256": "28e693282cddff8e4396ae39ce6fa935e875e8ddac7375bea2c189dd6fb04970"
+   "sha256": "4e78c4004d5d8eb26d1a6e40d6ab75f68af2a7f9165d386f9a62e79e69dcae19"
+  },
+  {
+   "module": "fabric_actions",
+   "file": "fabric_actions.py",
+   "layer": "L3",
+   "imports": [
+    "fabric_base",
+    "fabric_jsvalue",
+    "fabric_time"
+   ],
+   "sha256": "44feb5e70bd9894c5ed1fa23bf8df55989ec99acb934b24bf97ddd7295891251"
   },
   {
    "module": "fabric_connections",
@@ -195,13 +206,14 @@
     "fabric_paths",
     "fabric_usage"
    ],
-   "sha256": "02dc5eb66ec956723d3ddba07b6dd15f6a9726d901f4d60edfd02eee57880ceb"
+   "sha256": "1f3f0d7ecf361b29e9101e07f1c53e5dc304d598bf26fd59ec89f16b9fed2420"
   },
   {
    "module": "fabric_descriptor",
    "file": "fabric_descriptor.py",
    "layer": "L3",
    "imports": [
+    "fabric_actions",
     "fabric_base",
     "fabric_connections",
     "fabric_paths",
@@ -209,7 +221,7 @@
     "fabric_secrets",
     "fabric_usage"
    ],
-   "sha256": "ffb573c485f8b4d3c7b0a94ccc53472cd71d9800daf63b5f3f7ff53f2ac38026"
+   "sha256": "361610f7c5bc94642a26a6dd7e4b6a5849efa0bd2aa814a8e2034eaed30368b6"
   },
   {
    "module": "fabric_auth",
@@ -261,6 +273,7 @@
    "file": "fabric_service.py",
    "layer": "L3",
    "imports": [
+    "fabric_actions",
     "fabric_auth",
     "fabric_backups",
     "fabric_base",
@@ -277,7 +290,7 @@
     "fabric_time",
     "fabric_usage"
    ],
-   "sha256": "103ab4026f96e127c01cd91e4ad44f6b0ce2424ff33f078ed106b39e773a10e3"
+   "sha256": "a2e813469a47d4d3eea996628635c8903007498bdb6a1ae032a7a5ce6f49fe2f"
   },
   {
    "module": "fabric_profiles",
@@ -297,23 +310,26 @@
    "file": "fabric_interop_rules.py",
    "layer": "L3",
    "imports": [
+    "fabric_actions",
     "fabric_base",
     "fabric_delegation",
     "fabric_time"
    ],
-   "sha256": "b5f0ecb1791b4c50c5ac151f987f692ed7001bc74841a8a161125ec775145e09"
+   "sha256": "33dfb0841077df5379df425e288c1e01ae03c22344e6870024b5f4231ad89e75"
   },
   {
    "module": "fabric_interop",
    "file": "fabric_interop.py",
    "layer": "L3",
    "imports": [
+    "fabric_actions",
     "fabric_base",
     "fabric_delegation",
     "fabric_interop_rules",
-    "fabric_service"
+    "fabric_service",
+    "fabric_time"
    ],
-   "sha256": "f92fa111328fe3811438f733d8f0eb5295e6941c774123a78e26318bdcb35fc3"
+   "sha256": "0999ded29d908c8a55d13061f0b501887a5ea259dbf7d2251a90c04018761fbb"
   },
   {
    "module": "fabric_hub",
@@ -485,7 +501,7 @@
     "fabric-jsvalue",
     "fabric-paths"
    ],
-   "sha256": "dafde9ea327c88d92dc73d1400282b43dc6f84dd345a2d2b9b154304f65fc9d7"
+   "sha256": "fab1efdc1a9a0a9a00768905dded538fe185ca1b63c115dc4273717efc8e81f6"
   },
   {
    "module": "fabric-share",
@@ -544,7 +560,18 @@
    "imports": [
     "fabric-secrets"
    ],
-   "sha256": "dc039ec3612d0090c9ba6a3a949b0b7df54712bead300dcb6cc8b9bc305cd183"
+   "sha256": "acd32d9d05cf1a0319e84ad77cede479ef9b6337011e2cf7726e0e8aa590a9e0"
+  },
+  {
+   "module": "fabric-actions",
+   "file": "fabric-actions.mjs",
+   "layer": "L3",
+   "imports": [
+    "fabric-base",
+    "fabric-jsvalue",
+    "fabric-time"
+   ],
+   "sha256": "66f9ca7d1da31c89eeedffe7b78ff2230361d375d44c3aa90d9c60b66dfe5cbe"
   },
   {
    "module": "fabric-connections",
@@ -590,13 +617,14 @@
     "fabric-protocols",
     "fabric-usage"
    ],
-   "sha256": "849acdc6eba0fff648c8158e61f6b68cccd7bedf0880f7d5ec03a6a20f1e7005"
+   "sha256": "cfd8c9085e3d597a783099c2bd2ffe2f3faa0daaadab46dedd30523894cfeb06"
   },
   {
    "module": "fabric-descriptor",
    "file": "fabric-descriptor.mjs",
    "layer": "L3",
    "imports": [
+    "fabric-actions",
     "fabric-base",
     "fabric-connections",
     "fabric-paths",
@@ -604,7 +632,7 @@
     "fabric-secrets",
     "fabric-usage"
    ],
-   "sha256": "673bff656b403c3ef77a93878eaf4eda91c859df4b4275028fe303fcc153dd64"
+   "sha256": "c1ccaa9dff5edf90b82d6d77e2e5189a5d0f677fd48cc0aed3cccb83ad2a1f12"
   },
   {
    "module": "fabric-auth",
@@ -657,6 +685,7 @@
    "file": "fabric-service.mjs",
    "layer": "L3",
    "imports": [
+    "fabric-actions",
     "fabric-auth",
     "fabric-backups",
     "fabric-base",
@@ -671,7 +700,7 @@
     "fabric-supervisors",
     "fabric-usage"
    ],
-   "sha256": "1b4639a10c530c1241d317c5e9cf3a10cd96e5d9af8b29fc1b1844de5c63bfec"
+   "sha256": "6aa673657427211b491a9b63f94b9847a7e6aa3ee1b7353e1af11f46469803a3"
   },
   {
    "module": "fabric-profiles",
@@ -690,11 +719,12 @@
    "file": "fabric-interop-rules.mjs",
    "layer": "L3",
    "imports": [
+    "fabric-actions",
     "fabric-base",
     "fabric-delegation",
     "fabric-jsvalue"
    ],
-   "sha256": "57a8081307956e8c381119b361fa5232a7bf791815be8e3541eb5492820e2ea5"
+   "sha256": "fc8f3044afe209a1b23ddb3bc9b3993f4831913fa66bfd6e7855f1be80428e43"
   },
   {
    "module": "fabric-interop",
@@ -705,7 +735,7 @@
     "fabric-interop-rules",
     "fabric-service"
    ],
-   "sha256": "581983ec3e197e5c2340ad25e8468320c69a2459c90097c7fcf2699766b4fb26"
+   "sha256": "8f1ca418112d7129402783376bb9cbc9d2607f2aceec2a6796e703591a88f535"
   },
   {
    "module": "fabric-hub",
@@ -3179,6 +3209,84 @@
    "fabric-openrouter.mjs": "ab6c4c7251d563980d895061ee19976bde2f364c21b6354efdd9a9027b1ea139",
    "fabric-package.schema.json": "2ba799f576fad0f608029223c4ccccd122152f1c5dbfa8ce8b31cd63ac92ad44",
    "share-registration.schema.json": "34b3997eeaf936ebc861342a23045634a7c18c19f01d7ed4198310d81989f5b0"
+  },
+  "0.50.0": {
+   "fabric_jsvalue.py": "12888a2c934a885d35999ac9782eaedc8d04946d9775213344a235a8814d3d28",
+   "fabric_time.py": "588f383da4ac6a243ea95b6ffc3a0aa99ca94245732dc4937734f190b7af4ae9",
+   "fabric_identifiers.py": "0fd814d521ac3aa39907458265870753046a73f48af3d8581ab864b93b211607",
+   "fabric_secrets.py": "68a0b5e9e90c468ec9ac67b2f0fd1848e08813d6ec1ec14a2a47337eb1a98911",
+   "fabric_crypto.py": "9c34aee20dbe4d6742e4fdbaab68ceb934bbe7dbd3a904c0010824ace16cdeaa",
+   "fabric_base.py": "f62bcc2ed9912660fa875d27a09f60867260cc4925f79873501fd9620be59611",
+   "fabric_platform.py": "a9350dff55ef0fb3a23cdb4d0320a15868b15a8deb10d2eb74d72c58740c284b",
+   "fabric_paths.py": "6c92af34292baddf7e10d3134d0a5b0bb23387741812a9f79c409cf1628bad23",
+   "fabric_estate.py": "a0ddc49d748c1efb1830de176998d6c8eac30f77d387c71eae12549c52aaab27",
+   "fabric_delegation.py": "f6c135126d2b9f6ff0c93f2947be1aa03d99460cb759495f51fe86f3edf481b3",
+   "fabric_share.py": "78506fe1a60829c525dbf6266a0aa0749a2164290ed94da8249a20b4e9be5605",
+   "fabric_ceremonies.py": "a59e83cf4adb2669a9b98008e3d3a0cba991a35cbff97bc604fc82fe81cfd49f",
+   "fabric_package_schema.py": "e623f0408d38e3343ed66222fb812907c6c52e1a286eb1c1176ab2e64640c9ad",
+   "fabric_package.py": "ff533f1b3f92b4ea0f532fcec50b68c610d47549930eef8ad5247692a64dfb3c",
+   "fabric_protocols.py": "4e78c4004d5d8eb26d1a6e40d6ab75f68af2a7f9165d386f9a62e79e69dcae19",
+   "fabric_actions.py": "44feb5e70bd9894c5ed1fa23bf8df55989ec99acb934b24bf97ddd7295891251",
+   "fabric_connections.py": "77d3ccf863c70e9209d21ef45c46a6db9c06237019bc20d54f8d3946873f3f11",
+   "fabric_lock.py": "ba2399d2137c7a7791b7133b9db9cca36693f4eb7e30955b25a75ade814e95ba",
+   "fabric_usage.py": "b1f335cab4625171a616cf68cf3fd892b18bdadcf4baec3a3a0fdcf12785c170",
+   "fabric_backups.py": "1f3f0d7ecf361b29e9101e07f1c53e5dc304d598bf26fd59ec89f16b9fed2420",
+   "fabric_descriptor.py": "361610f7c5bc94642a26a6dd7e4b6a5849efa0bd2aa814a8e2034eaed30368b6",
+   "fabric_auth.py": "71115d18c67b7b806cb57b64b77e01ad97fc0e63e6f49ee850f778123617d905",
+   "fabric_events.py": "0086886c2c29dbd5c9d152be9d375c5bdf4a29f89b8095baff8490c2bcd64e47",
+   "fabric_logs.py": "86dc55bfafa2a57264722e2403510a249b95de0e4a722b2e4bc3948e3bd93da9",
+   "fabric_supervisors.py": "a2dbf15aa1c4eb9de42996b413103fa4814afd2e4e66d1ab7315f30e06ab6841",
+   "fabric_service.py": "a2e813469a47d4d3eea996628635c8903007498bdb6a1ae032a7a5ce6f49fe2f",
+   "fabric_profiles.py": "26e21ec29c016000f8ca8053b7b489184854a73be1b7fdc0a18d12990203db9b",
+   "fabric_interop_rules.py": "33dfb0841077df5379df425e288c1e01ae03c22344e6870024b5f4231ad89e75",
+   "fabric_interop.py": "0999ded29d908c8a55d13061f0b501887a5ea259dbf7d2251a90c04018761fbb",
+   "fabric_hub.py": "b9ac852e601b1d54cf61351677a628afc69faeed7d1fc74ebe541c1cf38e0c2a",
+   "fabric_board_shapes.py": "0a0e8d3d40e33dfd8c457aedb85330b2ff25f8c49a33eb6cbd5a5cc8a5007f7e",
+   "fabric_board_link.py": "b5bff994cb615c6a4bb0d88d020e3a59504166180e1fa1aea3be93224f2aeccb",
+   "fabric_board_session.py": "2845d7d758b06ac4588bdf825a471c201a46ce535a631805697b1e35495fead6",
+   "fabric_board_fixture.py": "69761ce205ec640762ec9b591c6903e5a87f844e8d423b041681924027e39d1e",
+   "fabric_board.py": "0f075894b3e352194fcaf3fc7d08dee4e9f1c215e859769ed85fa5010e4a1599",
+   "fabric_http.py": "5d7f72af3a73fdbe8c1f487ecf60cef23a7c46289eba542b03aff4706b8218d4",
+   "fabric_openrouter.py": "309f588f9c976b1061323f3161e35d86248afd5b59b16391afbfc4e1099ecd65",
+   "fabric-jsvalue.mjs": "dfbdb8c41584972c9389750a41719374a1cfc5652ed438dd1623025190b0106e",
+   "fabric-time.mjs": "3ff932069038a720df1c68c6492976906737b2e67e5c12d9c81c418597f661de",
+   "fabric-identifiers.mjs": "a18c2a501a4aa170bfd3d99e571ad6b7662649b4d3b9d2a540c002ea42811bbf",
+   "fabric-secrets.mjs": "6ad8ab18ac899ecc2384e8ec6a3fb689b92be3b9a5ce3a59b92a37d52da5d766",
+   "fabric-crypto.mjs": "038e03689701e3c9721a1e7f8e0a4d02a52d6a5d1661b0dc84035edc3ebbfcf6",
+   "fabric-base.mjs": "7804b2df7715dbbf9702a9b61b6b8cef2110f9a52b04cabd8fb0a66458d87512",
+   "fabric-platform.mjs": "a8119d95ebba4d589a9e401f5d6fc8dda62d59d44e4c1ff811d97fac3771ac0c",
+   "fabric-paths.mjs": "2201b4ed7126f260931b63e8386377b4317d8dcad419d109bf22c683e44b7f29",
+   "fabric-estate.mjs": "b6610aaad9d00d8a7f42955627fb81725950841455bcedfc050abb0e079f0f93",
+   "fabric-delegation.mjs": "fab1efdc1a9a0a9a00768905dded538fe185ca1b63c115dc4273717efc8e81f6",
+   "fabric-share.mjs": "d40a7405d7bd4c3213ed691330b7549afe8e023db0753b582e249714e672010d",
+   "fabric-ceremonies.mjs": "117d4374c9e95c930a38de7adbd4323774798f4fe6ec6f24afcd6f2c7298ca44",
+   "fabric-package-schema.mjs": "cd28092375db0fc21ffab1f0bb7794f7f8979ee08c64d3b9faf4b3845357caa6",
+   "fabric-package.mjs": "13913ea6d12056c3a31b8222b6c4aab8395941fe519913692e1a06d8672e1c88",
+   "fabric-protocols.mjs": "acd32d9d05cf1a0319e84ad77cede479ef9b6337011e2cf7726e0e8aa590a9e0",
+   "fabric-actions.mjs": "66f9ca7d1da31c89eeedffe7b78ff2230361d375d44c3aa90d9c60b66dfe5cbe",
+   "fabric-connections.mjs": "303432e547ce563e90ca9ffcd827f5612f51d3582929834e1add0fdaf6485dcc",
+   "fabric-lock.mjs": "ac219ab0a326d5c43c7c4c255e0c3843d4794de795a60e3af661e7d5350ea052",
+   "fabric-usage.mjs": "1c4d18004639409624ac3516a02f2b60bbf55abdb612e9a96c37e83666eb87a7",
+   "fabric-backups.mjs": "cfd8c9085e3d597a783099c2bd2ffe2f3faa0daaadab46dedd30523894cfeb06",
+   "fabric-descriptor.mjs": "c1ccaa9dff5edf90b82d6d77e2e5189a5d0f677fd48cc0aed3cccb83ad2a1f12",
+   "fabric-auth.mjs": "782c2aa732f8320f604194660117640a7ea145e12b8155c04e88cef7c516a5b3",
+   "fabric-events.mjs": "c463d6ffcae24229a5c608d8fcea4268d2ccc5024b19fa10e5a452284068fa71",
+   "fabric-logs.mjs": "58467e5719c16e099d05bbedec47a95712506ab03c33f3cd4be1252e8498a946",
+   "fabric-supervisors.mjs": "9d61c1a17538a5e2453e33e5ae347337336748041bc054478a96dd51f3d4fc51",
+   "fabric-service.mjs": "6aa673657427211b491a9b63f94b9847a7e6aa3ee1b7353e1af11f46469803a3",
+   "fabric-profiles.mjs": "314376cf2deb87f235fb18b11d3b532e211f585b9af0a9302b5f4cc39971b532",
+   "fabric-interop-rules.mjs": "fc8f3044afe209a1b23ddb3bc9b3993f4831913fa66bfd6e7855f1be80428e43",
+   "fabric-interop.mjs": "8f1ca418112d7129402783376bb9cbc9d2607f2aceec2a6796e703591a88f535",
+   "fabric-hub.mjs": "c005115a864cfd67daa4862097bb14acfe5a60bf653897e5bf8a570dd80f1070",
+   "fabric-board-shapes.mjs": "c1db7b7bd0d58d82bb6d8dfbc3cd1547a256a333052d367e82ff1b3edf2804d7",
+   "fabric-board-link.mjs": "4cd6d4e21713a38c8e56f7d59db3148638b8c27c08e774d96a0f6283c6049e0a",
+   "fabric-board-session.mjs": "26c9b0b2818a4cedc5248b08ea6732e2ee4ee81e31f6fee2b572a019db813c93",
+   "fabric-board-fixture.mjs": "83c4b7e33ee47b68385faf2569d38d5c8a0c5cb0f8656090f41e1b0eed2f436e",
+   "fabric-board.mjs": "9e7bfe4d412521982224ef12bebfc2ff255eeeaf8d96cf40234ac18de68e7a59",
+   "fabric-http.mjs": "f886bcb49c4353d039387ac9568738dda26697a94dd07fc6a6204500f0bc27bf",
+   "fabric-openrouter.mjs": "ab6c4c7251d563980d895061ee19976bde2f364c21b6354efdd9a9027b1ea139",
+   "fabric-package.schema.json": "2ba799f576fad0f608029223c4ccccd122152f1c5dbfa8ce8b31cd63ac92ad44",
+   "share-registration.schema.json": "34b3997eeaf936ebc861342a23045634a7c18c19f01d7ed4198310d81989f5b0"
   }
  },
  "data": {