dosync 0.7.0__tar.gz → 0.8.0__tar.gz

{dosync-0.7.0 → dosync-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dosync
-Version: 0.7.0
+Version: 0.8.0
 Summary: The semantic layer between AI agents and physical devices
 Author-email: Rodrigo Giuliani <rgiuliani@dosync.dev>
 License-Expression: Apache-2.0
@@ -961,7 +961,7 @@ the other end.
 | Web dashboard | ✅ |
 | API key authentication + SHA-256 audit log | ✅ |
 | Capability-based resolver | ✅ |
-| Certification CLI — Basic 10 · Standard 33 · Emergency 44 · Conformance 65, each run in CI against a live hub (signed reports) | ✅ |
+| Certification CLI — Basic 10 · Standard 33 · Emergency 44 · Conformance 69, each run in CI against a live hub (signed reports) | ✅ |
 | Philips WiZ adapter (UDP local) | ✅ |
 | Home Assistant bridge (10 domains) | ✅ |
 | Native MCP server (Claude, ChatGPT, any LLM) | ✅ |
@@ -1014,8 +1014,8 @@ python3 certify.py --host <hub-ip> --port 47200 --tier standard
 
 | Language | Location | Author | Certification |
 |---|---|---|---|
-| Python (reference) | `server.py` | this project | Conformance 65/65 ✅ (every tier, in CI) |
-| Node.js (companion) | [giulianireg-spec/dosync-node](https://github.com/giulianireg-spec/dosync-node) | this project | Standard 33/33, against the v0.3 suite — re-validation against the current 65-check suite pending |
+| Python (reference) | `server.py` | this project | Conformance 69/69 ✅ (every tier, in CI) |
+| Node.js (companion) | [giulianireg-spec/dosync-node](https://github.com/giulianireg-spec/dosync-node) | this project | Standard 33/33, against the v0.3 suite — re-validation against the current 69-check suite pending |
 
 The Node.js implementation is a **companion** port that validates the protocol
 is implementable in a second language against the same certification suite —

{dosync-0.7.0 → dosync-0.8.0}/README.md

@@ -895,7 +895,7 @@ the other end.
 | Web dashboard | ✅ |
 | API key authentication + SHA-256 audit log | ✅ |
 | Capability-based resolver | ✅ |
-| Certification CLI — Basic 10 · Standard 33 · Emergency 44 · Conformance 65, each run in CI against a live hub (signed reports) | ✅ |
+| Certification CLI — Basic 10 · Standard 33 · Emergency 44 · Conformance 69, each run in CI against a live hub (signed reports) | ✅ |
 | Philips WiZ adapter (UDP local) | ✅ |
 | Home Assistant bridge (10 domains) | ✅ |
 | Native MCP server (Claude, ChatGPT, any LLM) | ✅ |
@@ -948,8 +948,8 @@ python3 certify.py --host <hub-ip> --port 47200 --tier standard
 
 | Language | Location | Author | Certification |
 |---|---|---|---|
-| Python (reference) | `server.py` | this project | Conformance 65/65 ✅ (every tier, in CI) |
-| Node.js (companion) | [giulianireg-spec/dosync-node](https://github.com/giulianireg-spec/dosync-node) | this project | Standard 33/33, against the v0.3 suite — re-validation against the current 65-check suite pending |
+| Python (reference) | `server.py` | this project | Conformance 69/69 ✅ (every tier, in CI) |
+| Node.js (companion) | [giulianireg-spec/dosync-node](https://github.com/giulianireg-spec/dosync-node) | this project | Standard 33/33, against the v0.3 suite — re-validation against the current 69-check suite pending |
 
 The Node.js implementation is a **companion** port that validates the protocol
 is implementable in a second language against the same certification suite —

{dosync-0.7.0 → dosync-0.8.0}/dosync/__init__.py

@@ -13,5 +13,5 @@ The two numbers move independently on purpose:
   __version__           this implementation of the hub  (semver)
   __protocol_version__  the wire contract other implementations must match
 """
-__version__ = "0.7.0"
+__version__ = "0.8.0"
 __protocol_version__ = "0.5"

{dosync-0.7.0 → dosync-0.8.0}/dosync/certify.py

@@ -9,7 +9,7 @@ Tiers:
   basic     (10 tests) — connectivity, authentication, device manifest
   standard  (33 tests) — protocol conformance, events, health, version headers, manifest privacy, intent lifecycle
   emergency (44 tests) — everything in standard + emergency override, policy engine, audit log integrity, firmware re-registration
-  conformance (65 tests) — everything in emergency + protocol features through 0.5: sensor kind, policy provenance,
+  conformance (69 tests) — everything in emergency + protocol features through 0.5: sensor kind, policy provenance,
                            chain archiving, adapters, discovery, and where a device is and what a location in an intent does
 
 Two testing modes:
@@ -261,7 +261,7 @@ class CertReport:
         # basic said 12 while the tier runs B01-B10: a basic certification was
         # always "incomplete" and could never certify. Nothing noticed because
         # nothing ran the suite; CI now certifies every tier on its own.
-        "basic": 10, "standard": 33, "emergency": 44, "conformance": 65,
+        "basic": 10, "standard": 33, "emergency": 44, "conformance": 69,
     }
 
     def finalize(self):
@@ -512,7 +512,10 @@ def run_standard(base: str, report: CertReport):
     status4, body4 = fire_intent_conformance(base, {
         "intent":  "control_access",
         "urgency": "alert",
-        "context": {"trigger": "certification_test"},
+        # control_access asks for lock and unlock; an intent says which it means
+        # (protocol 0.5 rev. 2026-10-02). Before this, S4 asked a hub's locks
+        # for both at once.
+        "context": {"trigger": "certification_test", "action_types": ["lock"]},
     })
     report.add(TestResult(
         "S04  Hub accepts alert urgency (control_access [alert])",
@@ -922,7 +925,7 @@ def run_emergency(base: str, report: CertReport):
     ))
 
 
-# ── TIER CONFORMANCE — protocol features through 0.5 (cumulative: 65) ─────────
+# ── TIER CONFORMANCE — protocol features through 0.5 (cumulative: 69) ─────────
 # Everything shipped in the 0.4 cycle (SENSOR-KIND, AUDIT-PROVENANCE,
 # EMERGENCY-UNSAT-ESCALATION, AUDIT-ARCHIVE) had unit tests but no CONFORMANCE
 # coverage — nothing proved, over the wire against a running hub, that the
@@ -1088,7 +1091,7 @@ def run_conformance(base: str, report: CertReport):
     run_conformance_05(base, report)
 
 
-# C13-C21 cover protocol 0.5 (spec §10.5): where a device is, and what a
+# C13-C25 cover protocol 0.5 (spec §10.5): where a device is, and what a
 # location in an intent's context does. The suite builds its own scene -- two
 # probe devices and two probe intent classes, prefixed certify- -- and removes it
 # whatever happens. It verifies through explain(), which executes nothing,
@@ -1097,6 +1100,8 @@ def run_conformance(base: str, report: CertReport):
 _PROBE_ACTION = "certify_probe"
 _PROBE_IN = "certify-probe-cell-2"      # placed at certify-site/line-3/cell-2
 _PROBE_OUT = "certify-probe-line-30"    # placed at certify-site/line-30/cell-1
+_PROBE_LOCK = "certify-probe-lock"      # emergency-capable, lock and unlock (C22)
+_PROBE_CONVEYOR = "certify-probe-conveyor"  # emergency-capable, declares stop (C24)
 _CLASS_RESTRICTS = "certify_location_restricts"
 _CLASS_INFORMS = "certify_location_informs"
 
@@ -1216,8 +1221,86 @@ def run_conformance_05(base: str, report: CertReport):
                       "as CI does, to check it")
             report.not_applicable.append((name, reason))
             warn(f"{name} — not applicable in production mode: {reason}")
+        # C22. In an emergency, an emergency-capable device the class asks
+        # nothing of does what it declared -- never every capability (a lock
+        # used to receive lock AND unlock at once). Checked through explain and
+        # PATCH: nothing is fired.
+        lock = _probe_device(_PROBE_LOCK)
+        lock.update({"emergency_capable": True, "tags": ["certify-probe"],
+                     "actuators": [{"id": "lock", "type": "lock", "description": "Lock"},
+                                   {"id": "unlock", "type": "unlock", "description": "Unlock"}]})
+        request("POST", f"{base}/v1/devices/register", lock)
+
+        def _lock_entry():
+            st, body = request("GET", f"{base}/v1/intents/ensure_safety/explain?urgency=emergency")
+            return next((d for d in body.get("included", []) if d.get("device_id") == _PROBE_LOCK), {}) if st == 200 else {}
+        before = _lock_entry()
+        c_st, _ = request("PATCH", f"{base}/v1/devices/{_PROBE_LOCK}", {"emergency_actions": ["lock", "unlock"]})
+        request("PATCH", f"{base}/v1/devices/{_PROBE_LOCK}", {"emergency_actions": ["unlock"]})
+        after = _lock_entry()
+        report.add(TestResult(
+            "C22  An emergency-capable device does only its declared emergency actions",
+            before.get("included_without_action") is True and c_st == 422
+            and after.get("emergency_actions") == ["unlock"],
+            f"undeclared: {'no action' if before.get('included_without_action') else before}; "
+            f"lock+unlock → HTTP {c_st}; declared: {after.get('emergency_actions')}"))
+        # C23. An intent whose class asks for opposite actions must say which it
+        # means; outside an emergency the hub refuses it before executing
+        # anything. Nothing is fired: both requests are refused.
+        a_st, a_body = request("POST", f"{base}/v1/intent/async",
+                               {"intent": "control_access", "urgency": "alert", "context": {}})
+        i_st, _ = request("POST", f"{base}/v1/intent/async",
+                          {"intent": "control_access", "urgency": "alert",
+                           "context": {"action_types": ["certify-no-such-action"]}})
+        report.add(TestResult(
+            "C23  An intent asking for opposite actions must say which (422)",
+            a_st == 422 and "action_types" in str(a_body) and i_st == 422,
+            f"ambiguous → HTTP {a_st}; outside the class → HTTP {i_st}"))
+
+        # C24. In an emergency, what a device declared comes first: a conveyor
+        # declared to stop is not turned on by a class that asks for turn_on.
+        conveyor = _probe_device(_PROBE_CONVEYOR)
+        conveyor.update({"emergency_capable": True, "tags": ["certify-probe"],
+                         "emergency_actions": [{"action": "stop"}],
+                         "actuators": [{"id": "turn_on", "type": "turn_on", "description": "Start"},
+                                       {"id": "stop", "type": "stop", "description": "Stop"}]})
+        request("POST", f"{base}/v1/devices/register", conveyor)
+        st, body = request("GET", f"{base}/v1/intents/ensure_safety/explain?urgency=emergency")
+        entry = next((d for d in (body.get("included", []) if st == 200 else [])
+                      if d.get("device_id") == _PROBE_CONVEYOR), {})
+        report.add(TestResult(
+            "C24  In an emergency a device's declared actions come first",
+            entry.get("emergency_actions") == ["stop"],
+            f"explain reports {entry.get('emergency_actions') or entry or 'nothing'}"))
+        # C25. Governed direct mode: the hub validates what an agent proposes.
+        # Every proposal here is invalid, so nothing runs -- an opposite pair, an
+        # undeclared action and an unknown device in one intent, an action
+        # outside the class in another -- and each refusal carries its reason.
+        def _refusals(body):
+            st, fired = request("POST", f"{base}/v1/intent/async", body)
+            if st != 200 or not fired.get("intent_id"):
+                return None, f"HTTP {st}"
+            time.sleep(2)
+            _, res = request("GET", f"{base}/v1/intent/{fired['intent_id']}")
+            return res, {(r.get("device_id"), r.get("action")): r.get("reason")
+                         for r in res.get("refused_proposals") or []}
+        r1, got1 = _refusals({"intent": "control_access", "urgency": "alert", "context": {"proposed_actions": [
+            {"device_id": _PROBE_LOCK, "action": "lock"}, {"device_id": _PROBE_LOCK, "action": "unlock"},
+            {"device_id": _PROBE_LOCK, "action": "certify-fly"},
+            {"device_id": "certify-no-such-device", "action": "lock"}]}})
+        r2, got2 = _refusals({"intent": "notify", "urgency": "info", "context": {"proposed_actions": [
+            {"device_id": _PROBE_LOCK, "action": "unlock"}]}})
+        want1 = {(_PROBE_LOCK, "lock"): "opposite_actions", (_PROBE_LOCK, "unlock"): "opposite_actions",
+                 (_PROBE_LOCK, "certify-fly"): "not_declared",
+                 ("certify-no-such-device", "lock"): "unknown_device"}
+        nothing_ran = all(isinstance(r, dict) and not (r.get("results") or []) for r in (r1, r2))
+        report.add(TestResult(
+            "C25  Proposed actions are validated; refused ones never run",
+            got1 == want1 and got2 == {(_PROBE_LOCK, "unlock"): "outside_class"} and nothing_ran,
+            f"refusals {sorted(set((got1 or {}).values()) | set((got2 or {}).values())) if isinstance(got1, dict) else got1}; "
+            f"actions run: {0 if nothing_ran else 'some'}"))
     finally:
-        for did in (_PROBE_IN, _PROBE_OUT):
+        for did in (_PROBE_IN, _PROBE_OUT, _PROBE_LOCK, _PROBE_CONVEYOR):
             request("DELETE", f"{base}/v1/devices/{did}")
         for name in (_CLASS_RESTRICTS, _CLASS_INFORMS):
             request("DELETE", f"{base}/v1/intent-classes/{name}")
@@ -1245,7 +1328,7 @@ Tier test counts:
   basic      10 tests  — connectivity, auth, registration, manifest
   standard   33 tests  — + intents, events, health, explainability, version headers, intent lifecycle
   emergency  44 tests  — + emergency override, audit log integrity, firmware re-registration
-  conformance 65 tests — + protocol features through 0.5: sensor-kind, policy provenance, chain archiving,
+  conformance 69 tests — + protocol features through 0.5: sensor-kind, policy provenance, chain archiving,
                          device locations and location-restricted intents
         """,
     )

{dosync-0.7.0 → dosync-0.8.0}/dosync/declarative.py

@@ -103,7 +103,7 @@ def build_manifest(data: dict, source: str = "<declarative>"):
     """
     from .models import (
         ActuatorSpec, CapabilityManifest, CertTier, DeviceCategory, SensorSpec,
-        normalize_location,
+        normalize_emergency_actions, normalize_location,
     )
 
     device = data.get("device")
@@ -139,6 +139,14 @@ def build_manifest(data: dict, source: str = "<declarative>"):
             f"{source}: device declares location '{raw_location}' and room "
             f"'{raw_room}'. They are the same field; keep one.")
     raw = raw_location if raw_location is not None else raw_room
+    # What the device does in an emergency, declared by the file's author -- the
+    # operator (protocol 0.5, spec §6). Validated against the file's own actions.
+    try:
+        emergency_actions = normalize_emergency_actions(
+            device.get("emergency_actions"),
+            {str(a.get("type", n)) for n, a in (data.get("actions") or {}).items()})
+    except ValueError as e:
+        raise DeclarativeError(f"{source}: device.emergency_actions: {e}")
     if raw_location is None and raw_room is not None:
         # A file cannot receive the Deprecation header an API call gets, so the
         # deprecation (protocol 0.5, spec §10.5) is said where its author reads.
@@ -244,7 +252,7 @@ def build_manifest(data: dict, source: str = "<declarative>"):
                     source, type(raw_provenance).__name__)
 
     return CapabilityManifest(
-        provenance=provenance,
+        provenance={**provenance, **({"emergency_actions_set_by": "operator"} if emergency_actions else {})},
         device_id=device_id,
         device_name=name,
         manufacturer=str(device.get("manufacturer", "declarative")),
@@ -268,8 +276,10 @@ def build_manifest(data: dict, source: str = "<declarative>"):
             "actions": actions,
             "sensors": data.get("sensors") or {},
             **({"location_from_file": source} if location else {}),
+            **({"emergency_actions_from_file": source} if emergency_actions else {}),
         },
         location=location,
+        emergency_actions=emergency_actions,
     )
 
 

{dosync-0.7.0 → dosync-0.8.0}/dosync/hub.py

@@ -533,7 +533,29 @@ class DoSyncHub:
                 intent, executor, composition_kind)
 
         _t0 = time.perf_counter()
-        plan = self.resolver.resolve(intent)
+        if (intent.context or {}).get("proposed_actions"):
+            # Governed direct mode: validate what the agent proposed instead of
+            # resolving (spec §6 rule 7). An external resolver's local fallback
+            # applies the same guarantees.
+            _validate = (getattr(self.resolver, "validate_proposals", None)
+                         or getattr(getattr(self.resolver, "_fallback", None), "validate_proposals", None))
+            if _validate is None:
+                from .models import ActionPlan as _APlan
+                plan = _APlan(intent_id=intent.intent_id, actions=[], urgency=intent.urgency,
+                              refused_proposals=[{"device_id": p.get("device_id"), "action": p.get("action"),
+                                                  "reason": "resolver_cannot_validate"}
+                                                 for p in intent.context["proposed_actions"]])
+            else:
+                plan = _validate(intent)
+        else:
+            plan = self.resolver.resolve(intent)
+        # Parameter validation and the policy engine rebuild the plan from its
+        # actions alone; what the plan says about devices that took part without
+        # acting, and about refused proposals, is captured here so no later step
+        # can drop it. (included_without_action was lost from the audit entry
+        # whenever a policy modified the plan, from 2026-09-30 to 2026-10-02.)
+        _plan_idle = list(getattr(plan, "included_without_action", None) or [])
+        _plan_refused = list(getattr(plan, "refused_proposals", None) or [])
         if _M is not None:
             _M.intent_resolution_seconds.observe(time.perf_counter() - _t0)
 
@@ -781,6 +803,7 @@ class DoSyncHub:
                 {"device_id": a.device_id, "action": a.action, "reason": err}
                 for a, err in rejected_actions
             ],
+            refused_proposals=_plan_refused,
             operations=started_operations,
         )
         # Audit log
@@ -791,6 +814,8 @@ class DoSyncHub:
             "urgency":          intent.urgency.value,
             "source":           getattr(intent, "source", "api"),
             "actions":          len(plan.actions),
+            **({"included_without_action": _plan_idle} if _plan_idle else {}),
+            **({"refused_proposals": _plan_refused} if _plan_refused else {}),
             # The chain answers "what did this system do". An action that never
             # left the hub is part of that answer and used not to be: entries
             # written before 2026-08-13 do not distinguish execution from

{dosync-0.7.0 → dosync-0.8.0}/dosync/mcp_server.py

@@ -234,6 +234,26 @@ async def list_tools() -> list[types.Tool]:
                         "type": "string",
                         "description": "Message to include in notifications",
                     },
+                    "proposed_actions": {
+                        "type": "array",
+                        "items": {"type": "object", "properties": {
+                            "device_id": {"type": "string"}, "action": {"type": "string"},
+                            "params": {"type": "object"}}, "required": ["device_id", "action"]},
+                        "description": (
+                            "Optional, governed direct mode: the device actions you choose. "
+                            "The hub runs only those that pass its rules -- the device "
+                            "declares the action, the intent's class allows it, the device is "
+                            "in a restricting place, no opposite actions, declared emergency "
+                            "actions in an emergency -- and reports each refusal with its reason."),
+                    },
+                    "action_types": {
+                        "type": "array", "items": {"type": "string"},
+                        "description": (
+                            "Optional: the subset of the class's actions you mean. "
+                            "Required when the class asks for actions that undo each "
+                            "other (e.g. lock and unlock): the hub refuses the intent "
+                            "until you say which."),
+                    },
                     "location": {
                         "type": "string",
                         "description": (
@@ -482,6 +502,10 @@ async def call_tool(name: str, arguments: dict) -> list[types.TextContent]:
 
         # Merge the convenience fields (message, location) into context for backward
         # compatibility, without overwriting anything the AI put in `context`.
+        if arguments.get("proposed_actions") and "proposed_actions" not in ctx:
+            ctx["proposed_actions"] = list(arguments["proposed_actions"])
+        if arguments.get("action_types") and "action_types" not in ctx:
+            ctx["action_types"] = list(arguments["action_types"])
         for k, v in (("message", message), ("location", location)):
             if v and k not in ctx:
                 ctx[k] = v

{dosync-0.7.0 → dosync-0.8.0}/dosync/models.py

@@ -200,6 +200,52 @@ class ContextSignal:
 LOCATION_MAX_LENGTH = 256
 
 
+#: Pairs of actuator types that undo each other. An emergency action list may
+#: not contain both: that is exactly what the full-capability fallback did.
+OPPOSITE_ACTIONS = (frozenset({"lock", "unlock"}), frozenset({"turn_on", "turn_off"}),
+                    frozenset({"open", "close"}), frozenset({"start", "stop"}),
+                    frozenset({"arm", "disarm"}))
+
+
+def opposite_pairs(action_types) -> list:
+    """The pairs of OPPOSITE_ACTIONS that are both present in `action_types`."""
+    present = set(action_types)
+    return [tuple(sorted(p)) for p in OPPOSITE_ACTIONS if p <= present]
+
+
+def normalize_emergency_actions(raw, actuator_types) -> list:
+    """Validate what a device does in an emergency (protocol 0.5, spec §6).
+
+    Accepts action names or {"action", "params"} objects. Each action must be
+    one the device declares, none may repeat, and no two may undo each other.
+    Raises ValueError with the reason; returns [{"action", "params"}, ...].
+    """
+    if raw is None:
+        return []
+    if not isinstance(raw, list):
+        raise ValueError("emergency_actions must be a list")
+    out, seen = [], set()
+    for item in raw:
+        entry = {"action": item, "params": {}} if isinstance(item, str) else dict(item or {})
+        action = entry.get("action")
+        if not isinstance(action, str) or not action:
+            raise ValueError(f"each emergency action needs an 'action' name: {item!r}")
+        if action not in actuator_types:
+            raise ValueError(f"'{action}' is not an action this device declares "
+                             f"(it declares {sorted(actuator_types)})")
+        if action in seen:
+            raise ValueError(f"'{action}' is listed twice")
+        params = entry.get("params") or {}
+        if not isinstance(params, dict):
+            raise ValueError(f"params of '{action}' must be an object")
+        seen.add(action)
+        out.append({"action": action, "params": params})
+    for pair in OPPOSITE_ACTIONS:
+        if pair <= seen:
+            raise ValueError(f"emergency actions {sorted(pair)} undo each other; keep one")
+    return out
+
+
 def normalize_location(value) -> str:
     """Validate an operator-given location path and return it normalized.
 
@@ -315,6 +361,16 @@ class CapabilityManifest:
     #: It is where the device was ASSIGNED; the live position of something that
     #: moves is telemetry, not this.
     location: str                          = ""
+    #: What this device does when an emergency includes it and the intent's
+    #: class asks for none of its actions: a subset of its own actuators, with
+    #: optional params -- [{"action": "unlock"}] for an evacuation door,
+    #: [{"action": "stop"}] for a conveyor. Until protocol 0.5 rev. 2026-09-30
+    #: such a device executed EVERY actuator it declared, so a lock received
+    #: lock and unlock at once. What a device must do in an emergency depends on
+    #: the deployment, so a value the operator set takes precedence over the
+    #: device's own (provenance["emergency_actions_set_by"] == "operator").
+    #: Empty: the device takes part without acting, and the plan says so.
+    emergency_actions: list                = field(default_factory=list)
 
     def to_dict(self) -> dict:
         d = {
@@ -363,6 +419,8 @@ class CapabilityManifest:
             d["provenance"] = self.provenance
         if self.location:
             d["location"] = self.location
+        if self.emergency_actions:
+            d["emergency_actions"] = [dict(a) for a in self.emergency_actions]
         return d
 
     def carry_over_from(self, existing: "CapabilityManifest") -> None:
@@ -377,6 +435,11 @@ class CapabilityManifest:
         Descriptive data only: nothing here decides whether an action may run.
         """
         self.location = existing.location
+        if (existing.provenance or {}).get("emergency_actions_set_by") == "operator":
+            # The operator decided what this device does in an emergency; a
+            # device re-registering does not get to change that.
+            self.emergency_actions = [dict(a) for a in existing.emergency_actions]
+            self.provenance = {**(self.provenance or {}), "emergency_actions_set_by": "operator"}
         if (not self.adapter_config and existing.adapter_config
                 and (self.adapter or None) == (existing.adapter or None)):
             self.adapter_config = dict(existing.adapter_config)
@@ -455,6 +518,7 @@ class CapabilityManifest:
             discovery_evidence=dict(d.get("discovery_evidence") or {}),
             provenance=dict(d.get("provenance") or {}),
             location=d.get("location", ""),
+            emergency_actions=[dict(a) for a in (d.get("emergency_actions") or [])],
         )
 
     def to_public_dict(self) -> dict:
@@ -652,6 +716,14 @@ class ActionPlan:
     created_at: float                 = field(default_factory=time.time)
     failure_policy: "FailurePolicy"   = field(default=None)
     max_retries: int                  = 1
+    #: Emergency-capable devices an emergency included that had no action of the
+    #: class and declared no emergency_actions: they take part without acting,
+    #: and the record says so rather than hiding them.
+    included_without_action: list     = field(default_factory=list)
+    #: Governed direct mode (spec §6, rule 7): the actions an agent proposed
+    #: that the hub refused, each {device_id, action, reason}. A refused
+    #: proposal is never executed and never silently dropped.
+    refused_proposals: list           = field(default_factory=list)
     # failure_policy=None → usa CONTINUE (backward compatible)
 
 @dataclass
@@ -709,6 +781,7 @@ class IntentResult:
     failure_policy_applied: str       = "continue"
     status: str                       = "success"
     rejected_actions: list            = field(default_factory=list)
+    refused_proposals: list           = field(default_factory=list)
     # Long-running operations started by this intent (execution_model). Each entry:
     # {operation_id, device_id, state}. EMPTY for intents that only triggered instant
     # actions → a client that predates operations sees an identical IntentResult.