Harden HA conversation policy/taxonomy and persist timers

.env.example

@@ -16,6 +16,8 @@ HOME_PERMISSION_PROFILE=control
 HOME_REQUIRE_CONFIRM_EXECUTE=false
 # Optional: enable Home Assistant conversation intent tool
 HOME_CONVERSATION_ENABLED=false
+# Home Assistant conversation permission profile: readonly or control
+HOME_CONVERSATION_PERMISSION_PROFILE=readonly
 
 # Todoist integration (optional)
 TODOIST_API_TOKEN=

README.md

@@ -83,6 +83,7 @@ cp .env.example .env
 # Optional: HOME_PERMISSION_PROFILE=readonly (state only) or control (default)
 # Optional: HOME_REQUIRE_CONFIRM_EXECUTE=true (require confirm=true on all executes)
 # Optional: HOME_CONVERSATION_ENABLED=true (enable HA conversation intent tool)
+# Optional: HOME_CONVERSATION_PERMISSION_PROFILE=readonly|control (default readonly)
 # Optional: TODOIST_API_TOKEN / TODOIST_PROJECT_ID / TODOIST_PERMISSION_PROFILE
 # Optional: TODOIST_TIMEOUT_SEC=10.0 / PUSHOVER_TIMEOUT_SEC=10.0
 # Optional: PUSHOVER_API_TOKEN / PUSHOVER_USER_KEY / NOTIFICATION_PERMISSION_PROFILE
@@ -96,7 +97,7 @@ Smart home safety defaults:
 - Integration runbook: [`docs/operations/integration-policy.md`](docs/operations/integration-policy.md).
 - Home Assistant conversation tool requires both:
   - `HOME_CONVERSATION_ENABLED=true`
-  - `HOME_PERMISSION_PROFILE=control`
+  - `HOME_CONVERSATION_PERMISSION_PROFILE=control`
   - and tool argument `confirm=true`
 - Release checklist: [`docs/operations/release-checklist.md`](docs/operations/release-checklist.md).
 - Security maintenance: [`docs/operations/security-maintenance.md`](docs/operations/security-maintenance.md).

TODO.md

@@ -40,8 +40,8 @@ This backlog replaces the completed hardening backlog and focuses on feature gap
 - [ ] `HA05` Add Home Assistant timer integration tool path.
 - [ ] `HA06` Add entity capability discovery helper for safer action planning.
 - [ ] `HA07` Add optional area-aware commands (room/area targeting helper).
-- [ ] `HA08` Add HA conversation error taxonomy mapping and tests.
-- [ ] `HA09` Add policy profile controls for HA intent tool (`readonly|control`).
+- [x] `HA08` Add HA conversation error taxonomy mapping and tests.
+- [x] `HA09` Add policy profile controls for HA intent tool (`readonly|control`).
 - [ ] `HA10` Add HA intent runbook section with safe rollout checklist.
 
 ---
@@ -56,7 +56,7 @@ This backlog replaces the completed hardening backlog and focuses on feature gap
 - [ ] `PR06` Add optional reminder notifications via Pushover.
 - [ ] `PR07` Add calendar read integration (Google/ICS or HA calendar bridge).
 - [ ] `PR08` Add “next event” conversational helper tool.
-- [ ] `PR09` Add persistence layer for timers/reminders across restarts.
+- [x] `PR09` Add persistence layer for timers/reminders across restarts.
 - [ ] `PR10` Add productivity tool regression tests and edge-case parsing tests.
 
 ---
@@ -156,7 +156,7 @@ This backlog replaces the completed hardening backlog and focuses on feature gap
 
 - [x] `E01` Implement `HA01` + `HA02` + `HA03` (Home Assistant conversation API tool + schema + mapping + tests).
 - [x] `E02` Implement `PR01` + `PR02` + `PR03` (timer create/list/cancel tools + tests + status exposure).
-- [ ] `E03` Implement `HA08` + `HA09` (policy and taxonomy mapping for HA intent tool).
-- [ ] `E04` Implement `PR09` (persist timer/reminder data in `MemoryStore`).
+- [x] `E03` Implement `HA08` + `HA09` (policy and taxonomy mapping for HA intent tool).
+- [x] `E04` Implement `PR09` (persist timer/reminder data in `MemoryStore`).
 - [ ] `E05` Implement `UX06` (structured status endpoint behavior contract).
-- [ ] `E06` Update README/runbooks for new tools and safe operating guidance.
+- [x] `E06` Update README/runbooks for new tools and safe operating guidance.

docs/operations/error-taxonomy.md

@@ -7,27 +7,27 @@ Canonical tool error taxonomy shared by service tools and telemetry.
 | Error code | Owning tool families |
 |---|---|
 | `api_error` | `pushover_notify` |
-| `auth` | `smart_home`, `smart_home_state`, `todoist_*`, `pushover_notify` |
-| `cancelled` | `smart_home*`, `todoist_*`, `pushover_notify` |
-| `http_error` | `smart_home*`, `todoist_*`, `pushover_notify` |
-| `invalid_data` | `smart_home`, `task_plan_*`, `memory_*` |
-| `invalid_json` | `smart_home*`, `todoist_*`, `pushover_notify` |
+| `auth` | `smart_home`, `smart_home_state`, `home_assistant_conversation`, `todoist_*`, `pushover_notify` |
+| `cancelled` | `smart_home*`, `home_assistant_conversation`, `todoist_*`, `pushover_notify` |
+| `http_error` | `smart_home*`, `home_assistant_conversation`, `todoist_*`, `pushover_notify` |
+| `invalid_data` | `smart_home`, `home_assistant_conversation`, `timer_*`, `task_plan_*`, `memory_*` |
+| `invalid_json` | `smart_home*`, `home_assistant_conversation`, `todoist_*`, `pushover_notify` |
 | `invalid_plan` | `task_plan_*` |
 | `invalid_status` | `task_plan_update` |
 | `invalid_steps` | `task_plan_create` |
-| `missing_config` | `smart_home*`, `todoist_*`, `pushover_notify` |
+| `missing_config` | `smart_home*`, `home_assistant_conversation`, `todoist_*`, `pushover_notify` |
 | `missing_entity` | `smart_home_state` |
-| `missing_fields` | `smart_home`, `todoist_add_task`, `pushover_notify` |
+| `missing_fields` | `smart_home`, `home_assistant_conversation`, `timer_cancel`, `todoist_add_task`, `pushover_notify` |
 | `missing_plan` | `task_plan_*` |
 | `missing_query` | `memory_search` |
 | `missing_store` | `memory_*`, `task_plan_*` |
 | `missing_text` | `memory_add` |
-| `network_client_error` | `smart_home*`, `todoist_*`, `pushover_notify` |
-| `not_found` | `smart_home*`, `task_plan_*` |
-| `policy` | cross-cutting tool policy enforcement |
-| `storage_error` | `memory_*`, `task_plan_*` |
+| `network_client_error` | `smart_home*`, `home_assistant_conversation`, `todoist_*`, `pushover_notify` |
+| `not_found` | `smart_home*`, `home_assistant_conversation`, `timer_cancel`, `task_plan_*` |
+| `policy` | cross-cutting tool policy enforcement (`smart_home*`, `home_assistant_conversation`, allow/deny lists) |
+| `storage_error` | `memory_*`, `task_plan_*`, `timer_*` |
 | `summary_unavailable` | `tool_summary*`, `system_status` |
-| `timeout` | `smart_home*`, `todoist_*`, `pushover_notify` |
+| `timeout` | `smart_home*`, `home_assistant_conversation`, `todoist_*`, `pushover_notify` |
 | `unexpected` | cross-cutting runtime guard |
 | `unknown_error` | fallback normalization bucket |
 

docs/operations/home-control-policy.md

@@ -29,7 +29,7 @@ For `smart_home` requests:
 
 For `home_assistant_conversation` requests:
 - Requires `HOME_CONVERSATION_ENABLED=true`.
-- Requires `HOME_PERMISSION_PROFILE=control`.
+- Requires `HOME_CONVERSATION_PERMISSION_PROFILE=control`.
 - Requires tool argument `confirm=true` on every request.
 
 ## 4) Transport/Service Validation
@@ -42,6 +42,8 @@ For `home_assistant_conversation` requests:
 - `system_status` includes:
   - tool allow/deny counts
   - active `home_permission_profile`
+  - active `home_conversation_enabled`
+  - active `home_conversation_permission_profile`
 
 ### Redaction examples
 Input payload:
@@ -77,3 +79,4 @@ Audit payload:
   3. Ensure sensitive executes pass `confirm=true`.
   4. Verify `HASS_URL` and `HASS_TOKEN` are both set.
   5. If an execute is blocked, check whether an action cooldown is currently active.
+  6. For `home_assistant_conversation`, verify `HOME_CONVERSATION_ENABLED=true`, `HOME_CONVERSATION_PERMISSION_PROFILE=control`, and `confirm=true`.

docs/operations/integration-policy.md

@@ -109,4 +109,4 @@ Persisted audit details:
 - `timer_create` accepts numeric seconds or compact durations (`90s`, `5m`, `1h 15m`).
 - `timer_list` reports current active timers and remaining time.
 - `timer_cancel` removes a timer by `timer_id` or exact `label`.
-- Timers are currently runtime-memory only and reset on process restart.
+- Timers are persisted in the memory store when memory is enabled and are restored on restart.

src/jarvis/config.py

@@ -125,6 +125,9 @@ class Config:
     home_permission_profile: str = field(default_factory=lambda: os.environ.get("HOME_PERMISSION_PROFILE", "control"))
     home_require_confirm_execute: bool = field(default_factory=lambda: _env_bool("HOME_REQUIRE_CONFIRM_EXECUTE") or False)
     home_conversation_enabled: bool = field(default_factory=lambda: _env_bool("HOME_CONVERSATION_ENABLED") or False)
+    home_conversation_permission_profile: str = field(
+        default_factory=lambda: os.environ.get("HOME_CONVERSATION_PERMISSION_PROFILE", "readonly")
+    )
     todoist_api_token: str = field(default_factory=lambda: os.environ.get("TODOIST_API_TOKEN", ""))
     todoist_project_id: str = field(default_factory=lambda: os.environ.get("TODOIST_PROJECT_ID", ""))
     todoist_permission_profile: str = field(default_factory=lambda: os.environ.get("TODOIST_PERMISSION_PROFILE", "control"))
@@ -177,6 +180,9 @@ class Config:
         self.backchannel_style = self._normalize_backchannel_style(self.backchannel_style)
         self.persona_style = self._normalize_persona_style(self.persona_style)
         self.home_permission_profile = self._normalize_home_permission_profile(self.home_permission_profile)
+        self.home_conversation_permission_profile = self._normalize_home_conversation_permission_profile(
+            self.home_conversation_permission_profile
+        )
         self.todoist_permission_profile = self._normalize_todoist_permission_profile(self.todoist_permission_profile)
         self.notification_permission_profile = self._normalize_notification_permission_profile(self.notification_permission_profile)
         if _env_is_set("BACKCHANNEL_STYLE") and self.backchannel_style == "balanced":
@@ -191,6 +197,13 @@ class Config:
             raw = os.environ.get("HOME_PERMISSION_PROFILE", "")
             if raw.strip().lower() not in {"readonly", "control"}:
                 self.startup_warnings.append("HOME_PERMISSION_PROFILE invalid; using control.")
+        if (
+            _env_is_set("HOME_CONVERSATION_PERMISSION_PROFILE")
+            and self.home_conversation_permission_profile == "readonly"
+        ):
+            raw = os.environ.get("HOME_CONVERSATION_PERMISSION_PROFILE", "")
+            if raw.strip().lower() not in {"readonly", "control"}:
+                self.startup_warnings.append("HOME_CONVERSATION_PERMISSION_PROFILE invalid; using readonly.")
         if _env_is_set("TODOIST_PERMISSION_PROFILE") and self.todoist_permission_profile == "control":
             raw = os.environ.get("TODOIST_PERMISSION_PROFILE", "")
             if raw.strip().lower() not in {"readonly", "control"}:
@@ -221,6 +234,13 @@ class Config:
             return normalized
         return "control"
 
+    @staticmethod
+    def _normalize_home_conversation_permission_profile(profile: str) -> str:
+        normalized = (profile or "readonly").strip().lower()
+        if normalized in {"readonly", "control"}:
+            return normalized
+        return "readonly"
+
     @staticmethod
     def _normalize_todoist_permission_profile(profile: str) -> str:
         normalized = (profile or "control").strip().lower()
@@ -248,6 +268,15 @@ class Config:
             and not has_hass_token
         ):
             warnings.append("HOME_PERMISSION_PROFILE=control set while HASS_URL/HASS_TOKEN are empty.")
+        if (
+            _env_is_set("HOME_CONVERSATION_PERMISSION_PROFILE")
+            and self.home_conversation_permission_profile == "control"
+            and not has_hass_url
+            and not has_hass_token
+        ):
+            warnings.append(
+                "HOME_CONVERSATION_PERMISSION_PROFILE=control set while HASS_URL/HASS_TOKEN are empty."
+            )
         has_todoist_token = bool((self.todoist_api_token or "").strip())
         has_todoist_project = bool((self.todoist_project_id or "").strip())
         if has_todoist_project and not has_todoist_token:

src/jarvis/memory.py

@@ -49,6 +49,17 @@ class MemorySummary:
     updated_at: float
 
 
+@dataclass
+class TimerEntry:
+    id: int
+    created_at: float
+    due_at: float
+    duration_sec: float
+    label: str
+    status: str
+    cancelled_at: float | None
+
+
 class MemoryStore:
     def __init__(self, path: str) -> None:
         if path not in {":memory:", ""}:
@@ -134,6 +145,20 @@ class MemoryStore:
             """
         )
         cur.execute("CREATE INDEX IF NOT EXISTS idx_memory_summaries_updated ON memory_summaries(updated_at DESC);")
+        cur.execute(
+            """
+            CREATE TABLE IF NOT EXISTS timers (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                created_at REAL NOT NULL,
+                due_at REAL NOT NULL,
+                duration_sec REAL NOT NULL,
+                label TEXT NOT NULL DEFAULT '',
+                status TEXT NOT NULL DEFAULT 'active',
+                cancelled_at REAL
+            );
+            """
+        )
+        cur.execute("CREATE INDEX IF NOT EXISTS idx_timers_status_due ON timers(status, due_at ASC);")
         try:
             cur.execute(
                 """
@@ -454,6 +479,95 @@ class MemoryStore:
             updated_at=float(row["updated_at"]),
         )
 
+    def add_timer(
+        self,
+        *,
+        due_at: float,
+        duration_sec: float,
+        label: str = "",
+        created_at: float | None = None,
+    ) -> int:
+        if not math.isfinite(due_at):
+            raise ValueError("due_at must be finite")
+        if not math.isfinite(duration_sec) or duration_sec <= 0.0:
+            raise ValueError("duration_sec must be > 0")
+        created = time.time() if created_at is None else float(created_at)
+        clean_label = label.strip()
+        cur = self._conn.cursor()
+        cur.execute(
+            """
+            INSERT INTO timers(created_at, due_at, duration_sec, label, status, cancelled_at)
+            VALUES (?, ?, ?, ?, 'active', NULL)
+            """,
+            (created, float(due_at), float(duration_sec), clean_label),
+        )
+        self._conn.commit()
+        return int(cur.lastrowid)
+
+    def list_timers(
+        self,
+        *,
+        status: str = "active",
+        include_expired: bool = False,
+        now: float | None = None,
+        limit: int = 200,
+    ) -> list[TimerEntry]:
+        clean_status = status.strip().lower()
+        if clean_status not in {"active", "expired", "cancelled"}:
+            raise ValueError("status must be active, expired, or cancelled")
+        limit = self._normalize_limit(limit, default=200)
+        cur = self._conn.cursor()
+        params: list[Any] = [clean_status]
+        where = "status = ?"
+        if clean_status == "active" and not include_expired:
+            now_ts = time.time() if now is None else float(now)
+            where += " AND due_at > ?"
+            params.append(now_ts)
+        rows = cur.execute(
+            f"SELECT * FROM timers WHERE {where} ORDER BY due_at ASC LIMIT ?",
+            (*params, limit),
+        ).fetchall()
+        return [self._row_to_timer(row) for row in rows]
+
+    def expire_timers(self, *, now: float | None = None) -> int:
+        now_ts = time.time() if now is None else float(now)
+        with self._conn:
+            cur = self._conn.cursor()
+            cur.execute(
+                """
+                UPDATE timers
+                SET status = 'expired'
+                WHERE status = 'active' AND due_at <= ?
+                """,
+                (now_ts,),
+            )
+            return int(cur.rowcount)
+
+    def cancel_timer(self, timer_id: int, *, cancelled_at: float | None = None) -> bool:
+        cancelled = time.time() if cancelled_at is None else float(cancelled_at)
+        with self._conn:
+            cur = self._conn.cursor()
+            cur.execute(
+                """
+                UPDATE timers
+                SET status = 'cancelled', cancelled_at = ?
+                WHERE id = ? AND status = 'active'
+                """,
+                (cancelled, int(timer_id)),
+            )
+            return cur.rowcount > 0
+
+    def timer_counts(self) -> dict[str, int]:
+        rows = self._conn.cursor().execute(
+            "SELECT status, COUNT(*) AS c FROM timers GROUP BY status",
+        ).fetchall()
+        counts = {"active": 0, "expired": 0, "cancelled": 0}
+        for row in rows:
+            key = str(row["status"])
+            if key in counts:
+                counts[key] = int(row["c"])
+        return counts
+
     def close(self) -> None:
         if self._closed:
             return
@@ -470,6 +584,7 @@ class MemoryStore:
             "fts": self._fts_enabled,
             "vector": self._memory_enabled,
             "sources": source_counts,
+            "timers": self.timer_counts(),
             "last_warm": self._last_warm,
             "last_sync": self._last_sync,
             "last_optimize": self._last_optimize,
@@ -511,6 +626,18 @@ class MemoryStore:
             source=str(row["source"]),
         )
 
+    def _row_to_timer(self, row: sqlite3.Row) -> TimerEntry:
+        cancelled_at = row["cancelled_at"]
+        return TimerEntry(
+            id=int(row["id"]),
+            created_at=float(row["created_at"]),
+            due_at=float(row["due_at"]),
+            duration_sec=float(row["duration_sec"]),
+            label=str(row["label"] or ""),
+            status=str(row["status"]),
+            cancelled_at=float(cancelled_at) if cancelled_at is not None else None,
+        )
+
     @staticmethod
     def _normalize_limit(value: Any, *, default: int = 5) -> int:
         parsed = default

src/jarvis/tools/services.py

@@ -67,6 +67,7 @@ _audit_log_backups: int = 3
 _home_permission_profile: str = "control"
 _home_require_confirm_execute: bool = False
 _home_conversation_enabled: bool = False
+_home_conversation_permission_profile: str = "readonly"
 _todoist_permission_profile: str = "control"
 _notification_permission_profile: str = "allow"
 _todoist_timeout_sec: float = 10.0
@@ -344,6 +345,7 @@ def _record_service_error(tool_name: str, start_time: float, code: str) -> None:
 def bind(config: Config, memory_store: MemoryStore | None = None) -> None:
     global _config, _memory, _audit_log_max_bytes, _audit_log_backups
     global _home_permission_profile, _home_require_confirm_execute, _home_conversation_enabled
+    global _home_conversation_permission_profile
     global _todoist_permission_profile, _notification_permission_profile
     global _todoist_timeout_sec, _pushover_timeout_sec
     global _timer_id_seq
@@ -356,6 +358,11 @@ def bind(config: Config, memory_store: MemoryStore | None = None) -> None:
         _home_permission_profile = "control"
     _home_require_confirm_execute = bool(getattr(config, "home_require_confirm_execute", False))
     _home_conversation_enabled = bool(getattr(config, "home_conversation_enabled", False))
+    _home_conversation_permission_profile = str(
+        getattr(config, "home_conversation_permission_profile", "readonly")
+    ).strip().lower()
+    if _home_conversation_permission_profile not in {"readonly", "control"}:
+        _home_conversation_permission_profile = "readonly"
     _todoist_permission_profile = str(getattr(config, "todoist_permission_profile", "control")).strip().lower()
     if _todoist_permission_profile not in {"readonly", "control"}:
         _todoist_permission_profile = "control"
@@ -370,6 +377,7 @@ def bind(config: Config, memory_store: MemoryStore | None = None) -> None:
     _ha_state_cache.clear()
     _timers.clear()
     _timer_id_seq = 1
+    _load_timers_from_store()
     global _tool_allowlist, _tool_denylist
     _tool_allowlist = list(config.tool_allowlist)
     _tool_denylist = list(config.tool_denylist)
@@ -738,6 +746,11 @@ def _audit_status() -> dict[str, Any]:
 
 
 def _prune_timers(now_mono: float | None = None) -> None:
+    if _memory is not None:
+        try:
+            _memory.expire_timers(now=time.time())
+        except Exception:
+            log.warning("Failed to expire persisted timers", exc_info=True)
     if not _timers:
         return
     current = time.monotonic() if now_mono is None else now_mono
@@ -758,6 +771,37 @@ def _timer_status() -> dict[str, Any]:
     }
 
 
+def _load_timers_from_store() -> None:
+    global _timer_id_seq
+    if _memory is None:
+        return
+    now_wall = time.time()
+    now_mono = time.monotonic()
+    try:
+        _memory.expire_timers(now=now_wall)
+        rows = _memory.list_timers(status="active", include_expired=False, now=now_wall, limit=TIMER_MAX_ACTIVE)
+    except Exception:
+        log.warning("Failed to load persisted timers", exc_info=True)
+        return
+    max_id = 0
+    for row in rows:
+        remaining = float(row.due_at) - now_wall
+        if remaining <= 0.0:
+            continue
+        timer_id = int(row.id)
+        max_id = max(max_id, timer_id)
+        _timers[timer_id] = {
+            "id": timer_id,
+            "label": row.label,
+            "duration_sec": float(row.duration_sec),
+            "created_at": float(row.created_at),
+            "due_at": float(row.due_at),
+            "due_mono": now_mono + remaining,
+        }
+    if max_id >= _timer_id_seq:
+        _timer_id_seq = max_id + 1
+
+
 def _ha_headers() -> dict[str, str]:
     assert _config is not None
     return {"Authorization": f"Bearer {_config.hass_token}"}
@@ -1113,10 +1157,17 @@ async def home_assistant_conversation(args: dict[str, Any]) -> dict[str, Any]:
                 }
             ]
         }
-    if _home_permission_profile != "control":
+    if _home_conversation_permission_profile != "control":
         _record_service_error("home_assistant_conversation", start_time, "policy")
-        _audit("home_assistant_conversation", {"result": "denied", "reason": "readonly_profile"})
-        return {"content": [{"type": "text", "text": "Home Assistant conversation requires HOME_PERMISSION_PROFILE=control."}]}
+        _audit("home_assistant_conversation", {"result": "denied", "reason": "conversation_readonly_profile"})
+        return {
+            "content": [
+                {
+                    "type": "text",
+                    "text": "Home Assistant conversation requires HOME_CONVERSATION_PERMISSION_PROFILE=control.",
+                }
+            ]
+        }
     text = str(args.get("text", "")).strip()
     if not text:
         _record_service_error("home_assistant_conversation", start_time, "missing_fields")
@@ -1619,6 +1670,7 @@ async def system_status(args: dict[str, Any]) -> dict[str, Any]:
             "home_permission_profile": _home_permission_profile,
             "home_require_confirm_execute": bool(_home_require_confirm_execute),
             "home_conversation_enabled": bool(_home_conversation_enabled),
+            "home_conversation_permission_profile": _home_conversation_permission_profile,
             "todoist_permission_profile": _todoist_permission_profile,
             "notification_permission_profile": _notification_permission_profile,
         },
@@ -2007,11 +2059,24 @@ async def timer_create(args: dict[str, Any]) -> dict[str, Any]:
         _record_service_error("timer_create", start_time, "invalid_data")
         return {"content": [{"type": "text", "text": f"Too many active timers ({TIMER_MAX_ACTIVE} max)."}]}
     label = str(args.get("label", "")).strip()
-    timer_id = _allocate_timer_id()
     now_wall = time.time()
     now_mono = time.monotonic()
     due_wall = now_wall + duration
     due_mono = now_mono + duration
+    timer_id: int
+    if _memory is not None:
+        try:
+            timer_id = _memory.add_timer(
+                due_at=due_wall,
+                duration_sec=duration,
+                label=label,
+                created_at=now_wall,
+            )
+        except Exception:
+            _record_service_error("timer_create", start_time, "storage_error")
+            return {"content": [{"type": "text", "text": "Timer create failed: persistent storage unavailable."}]}
+    else:
+        timer_id = _allocate_timer_id()
     _timers[timer_id] = {
         "id": timer_id,
         "label": label,
@@ -2106,6 +2171,15 @@ async def timer_cancel(args: dict[str, Any]) -> dict[str, Any]:
     if selected_id is None:
         _record_service_error("timer_cancel", start_time, "not_found")
         return {"content": [{"type": "text", "text": "Timer not found."}]}
+    if _memory is not None:
+        try:
+            cancelled = _memory.cancel_timer(selected_id)
+        except Exception:
+            _record_service_error("timer_cancel", start_time, "storage_error")
+            return {"content": [{"type": "text", "text": "Timer cancel failed: persistent storage unavailable."}]}
+        if not cancelled:
+            _record_service_error("timer_cancel", start_time, "not_found")
+            return {"content": [{"type": "text", "text": "Timer not found."}]}
     removed = _timers.pop(selected_id, None)
     if removed is None:
         _record_service_error("timer_cancel", start_time, "not_found")

tests/test_config.py

@@ -97,6 +97,12 @@ class TestConfig:
         c = Config(home_permission_profile="execute-all")
         assert c.home_permission_profile == "control"
 
+    def test_home_conversation_permission_profile_normalizes(self, monkeypatch):
+        monkeypatch.setenv("ANTHROPIC_API_KEY", "test")
+        from jarvis.config import Config
+        c = Config(home_conversation_permission_profile="execute-all")
+        assert c.home_conversation_permission_profile == "readonly"
+
     def test_todoist_permission_profile_normalizes(self, monkeypatch):
         monkeypatch.setenv("ANTHROPIC_API_KEY", "test")
         from jarvis.config import Config
@@ -130,6 +136,7 @@ class TestConfig:
         monkeypatch.setenv("HOME_REQUIRE_CONFIRM_EXECUTE", "sometimes")
         monkeypatch.setenv("HOME_CONVERSATION_ENABLED", "perhaps")
         monkeypatch.setenv("HOME_PERMISSION_PROFILE", "execute-all")
+        monkeypatch.setenv("HOME_CONVERSATION_PERMISSION_PROFILE", "execute-all")
         monkeypatch.setenv("TODOIST_PERMISSION_PROFILE", "write-all")
         monkeypatch.setenv("NOTIFICATION_PERMISSION_PROFILE", "enabled")
         from jarvis.config import Config
@@ -147,6 +154,7 @@ class TestConfig:
         assert "HOME_REQUIRE_CONFIRM_EXECUTE invalid boolean" in text
         assert "HOME_CONVERSATION_ENABLED invalid boolean" in text
         assert "HOME_PERMISSION_PROFILE invalid" in text
+        assert "HOME_CONVERSATION_PERMISSION_PROFILE invalid" in text
         assert "TODOIST_PERMISSION_PROFILE invalid" in text
         assert "NOTIFICATION_PERMISSION_PROFILE invalid" in text
 
@@ -242,6 +250,7 @@ class TestConfig:
     def test_startup_warning_for_permissive_profiles_without_credentials(self, monkeypatch):
         monkeypatch.setenv("ANTHROPIC_API_KEY", "test")
         monkeypatch.setenv("HOME_PERMISSION_PROFILE", "control")
+        monkeypatch.setenv("HOME_CONVERSATION_PERMISSION_PROFILE", "control")
         monkeypatch.setenv("TODOIST_PERMISSION_PROFILE", "control")
         monkeypatch.setenv("NOTIFICATION_PERMISSION_PROFILE", "allow")
         monkeypatch.delenv("HASS_URL", raising=False)
@@ -254,5 +263,6 @@ class TestConfig:
         c = Config()
         text = "\n".join(c.startup_warnings).lower()
         assert "home_permission_profile=control set while hass_url/hass_token are empty" in text
+        assert "home_conversation_permission_profile=control set while hass_url/hass_token are empty" in text
         assert "todoist_permission_profile=control set while todoist_api_token is empty" in text
         assert "notification_permission_profile=allow set while pushover credentials are empty" in text

tests/test_memory.py

@@ -206,3 +206,48 @@ def test_update_task_step_rolls_back_on_plan_status_failure(tmp_path):
         assert plan_status == "open"
     finally:
         store.close()
+
+
+def test_timer_store_lifecycle(tmp_path):
+    store = MemoryStore(str(tmp_path / "memory.sqlite"))
+    try:
+        now = 1_700_000_000.0
+        timer_id = store.add_timer(
+            due_at=now + 120.0,
+            duration_sec=120.0,
+            label="tea",
+            created_at=now,
+        )
+        active = store.list_timers(status="active", include_expired=False, now=now)
+        assert [timer.id for timer in active] == [timer_id]
+        assert active[0].label == "tea"
+
+        assert store.cancel_timer(timer_id) is True
+        assert store.cancel_timer(timer_id) is False
+        cancelled = store.list_timers(status="cancelled")
+        assert [timer.id for timer in cancelled] == [timer_id]
+    finally:
+        store.close()
+
+
+def test_expire_timers_moves_due_rows_to_expired(tmp_path):
+    store = MemoryStore(str(tmp_path / "memory.sqlite"))
+    try:
+        now = 1_700_000_000.0
+        _ = store.add_timer(
+            due_at=now - 5.0,
+            duration_sec=30.0,
+            label="old",
+            created_at=now - 35.0,
+        )
+        changed = store.expire_timers(now=now)
+        assert changed == 1
+        active = store.list_timers(status="active", include_expired=False, now=now)
+        assert active == []
+        expired = store.list_timers(status="expired")
+        assert len(expired) == 1
+        counts = store.timer_counts()
+        assert counts["expired"] == 1
+        assert counts["active"] == 0
+    finally:
+        store.close()

tests/test_tools_services.py

@@ -797,6 +797,7 @@ class TestServicesTools:
         cfg = services._config
         assert cfg is not None
         cfg.home_conversation_enabled = True
+        cfg.home_conversation_permission_profile = "control"
         services.bind(cfg)
 
         result = await services.home_assistant_conversation({
@@ -811,14 +812,14 @@ class TestServicesTools:
         cfg = services._config
         assert cfg is not None
         cfg.home_conversation_enabled = True
-        cfg.home_permission_profile = "readonly"
+        cfg.home_conversation_permission_profile = "readonly"
         services.bind(cfg)
 
         result = await services.home_assistant_conversation({
             "text": "turn on kitchen lights",
             "confirm": True,
         })
-        assert "home_permission_profile=control" in result["content"][0]["text"].lower()
+        assert "home_conversation_permission_profile=control" in result["content"][0]["text"].lower()
 
     @pytest.mark.asyncio
     async def test_home_assistant_conversation_success(self, aiohttp_response, aiohttp_session_mock):
@@ -827,7 +828,7 @@ class TestServicesTools:
         cfg = services._config
         assert cfg is not None
         cfg.home_conversation_enabled = True
-        cfg.home_permission_profile = "control"
+        cfg.home_conversation_permission_profile = "control"
         services.bind(cfg)
 
         response = aiohttp_response(
@@ -860,7 +861,7 @@ class TestServicesTools:
         cfg = services._config
         assert cfg is not None
         cfg.home_conversation_enabled = True
-        cfg.home_permission_profile = "control"
+        cfg.home_conversation_permission_profile = "control"
         services.bind(cfg)
 
         response = aiohttp_response(status=200, json_data="not-a-dict")
@@ -872,6 +873,82 @@ class TestServicesTools:
             })
         assert "invalid home assistant conversation response" in result["content"][0]["text"].lower()
 
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        ("status", "expected_text", "expected_detail"),
+        [
+            (401, "authentication failed", "auth"),
+            (404, "endpoint not found", "not_found"),
+            (500, "conversation error (500)", "http_error"),
+        ],
+    )
+    async def test_home_assistant_conversation_http_mappings(
+        self,
+        status,
+        expected_text,
+        expected_detail,
+        aiohttp_response,
+        aiohttp_session_mock,
+    ):
+        from jarvis.tools import services
+        from jarvis.tool_summary import list_summaries
+
+        cfg = services._config
+        assert cfg is not None
+        cfg.home_conversation_enabled = True
+        cfg.home_conversation_permission_profile = "control"
+        services.bind(cfg)
+
+        response = aiohttp_response(status=status, json_data={})
+        with patch("aiohttp.ClientSession") as mock_session_cls:
+            mock_session_cls.return_value = aiohttp_session_mock(post=response)
+            result = await services.home_assistant_conversation({
+                "text": "turn off the kitchen lights",
+                "confirm": True,
+            })
+        assert expected_text in result["content"][0]["text"].lower()
+        summaries = list_summaries(25)
+        assert any(
+            item.get("name") == "home_assistant_conversation" and item.get("detail") == expected_detail
+            for item in summaries
+        )
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        ("side_effect", "expected_text", "expected_detail"),
+        [
+            (asyncio.TimeoutError(), "timed out", "timeout"),
+            (asyncio.CancelledError(), "was cancelled", "cancelled"),
+            (aiohttp.ClientError("boom"), "failed to reach", "network_client_error"),
+        ],
+    )
+    async def test_home_assistant_conversation_transport_error_mappings(
+        self,
+        side_effect,
+        expected_text,
+        expected_detail,
+    ):
+        from jarvis.tools import services
+        from jarvis.tool_summary import list_summaries
+
+        cfg = services._config
+        assert cfg is not None
+        cfg.home_conversation_enabled = True
+        cfg.home_conversation_permission_profile = "control"
+        services.bind(cfg)
+
+        with patch("aiohttp.ClientSession", side_effect=side_effect):
+            result = await services.home_assistant_conversation({
+                "text": "turn off the kitchen lights",
+                "confirm": True,
+            })
+        assert expected_text in result["content"][0]["text"].lower()
+        summaries = list_summaries(25)
+        assert any(
+            item.get("name") == "home_assistant_conversation" and item.get("detail") == expected_detail
+            for item in summaries
+        )
+
     @pytest.mark.asyncio
     async def test_timer_create_list_cancel_lifecycle(self):
         from jarvis.tools import services
@@ -921,6 +998,43 @@ class TestServicesTools:
         hidden = await services.timer_list({})
         assert "no active timers" in hidden["content"][0]["text"].lower()
 
+    @pytest.mark.asyncio
+    async def test_timer_persists_across_bind(self, tmp_path):
+        from jarvis.config import Config
+        from jarvis.memory import MemoryStore
+        from jarvis.tools import services
+
+        cfg = Config()
+        store = MemoryStore(str(tmp_path / "memory.sqlite"))
+        services.bind(cfg, store)
+
+        created = await services.timer_create({"duration": 600, "label": "persisted"})
+        timer_id = int(created["content"][0]["text"].split()[1])
+
+        services.bind(cfg, store)
+        listed = await services.timer_list({})
+        text = listed["content"][0]["text"].lower()
+        assert "persisted" in text
+        assert f"- {timer_id}" in text
+
+    @pytest.mark.asyncio
+    async def test_timer_cancel_persists_across_bind(self, tmp_path):
+        from jarvis.config import Config
+        from jarvis.memory import MemoryStore
+        from jarvis.tools import services
+
+        cfg = Config()
+        store = MemoryStore(str(tmp_path / "memory.sqlite"))
+        services.bind(cfg, store)
+
+        created = await services.timer_create({"duration": 600, "label": "to-cancel"})
+        timer_id = int(created["content"][0]["text"].split()[1])
+        await services.timer_cancel({"timer_id": timer_id})
+
+        services.bind(cfg, store)
+        listed = await services.timer_list({})
+        assert "no active timers" in listed["content"][0]["text"].lower()
+
     @pytest.mark.asyncio
     async def test_todoist_add_task_requires_config(self):
         from jarvis.tools import services
@@ -2067,6 +2181,7 @@ class TestServicesTools:
         assert "tool_policy" in payload
         assert isinstance(payload["tool_policy"]["home_require_confirm_execute"], bool)
         assert isinstance(payload["tool_policy"]["home_conversation_enabled"], bool)
+        assert payload["tool_policy"]["home_conversation_permission_profile"] in {"readonly", "control"}
         assert "memory" in payload
         assert "audit" in payload
         assert payload["audit"]["redaction_enabled"] is True
@@ -2386,3 +2501,10 @@ class TestServicesTools:
         }
         for code in critical_codes:
             assert code in script_text
+
+    def test_error_taxonomy_doc_mentions_home_assistant_conversation_and_timers(self):
+        project_root = Path(__file__).resolve().parents[1]
+        taxonomy_doc = (project_root / "docs" / "operations" / "error-taxonomy.md").read_text()
+        assert "home_assistant_conversation" in taxonomy_doc
+        assert "timer_cancel" in taxonomy_doc
+        assert "timer_*" in taxonomy_doc