merge upstream

.github/workflows/release-please.yml

@@ -11,7 +11,7 @@ jobs:
   release-please:
     runs-on: ubuntu-latest
     steps:
-      - uses: googleapis/release-please-action@v4
+      - uses: googleapis/release-please-action@v5
         with:
           config-file: release-please-config.json
           manifest-file: .release-please-manifest.json

config.yaml.example

@@ -634,7 +634,11 @@ memory:
     prediction_inject_prompt: true       # Inject predictions into the system prompt
     prediction_proactive_scheduling: true # Spawn proactive sessions at predicted active times
     prediction_proactive_cooldown_hours: 4 # Min hours between proactive fires per prediction
-    # proactive_target_thread_id: "default"  # Thread to deliver proactive results to (default: main thread)
+    # proactive_target_thread_id: "default"  # Keep "default" to use /proactive on room opt-in (recommended); set a specific thread ID to force delivery there instead.
+    # Proactive delivery (experimental): use the /proactive on slash command in any Matrix/Signal
+    # room to opt that room in to receiving proactive check-in results. Multiple rooms can be
+    # opted in independently. Use /proactive off to remove a room. No config change required for
+    # the recommended default behavior (proactive_target_thread_id = "default").
 
     # ── Confidence Gating (weak-model resilience) ──
     # Programmatic validators reject garbage dreaming outputs before memory writes.

docs/configuration.md

@@ -415,7 +415,9 @@ Controls the dreaming pipeline parameters.
 | `prediction_inject_prompt` | no | `true` | Inject predictions into the main-thread system prompt |
 | `prediction_proactive_scheduling` | no | `true` | Spawn proactive sub-sessions at predicted active times |
 | `prediction_proactive_cooldown_hours` | no | `4` | Minimum hours between proactive fires per prediction |
-| `proactive_target_thread_id` | no | `"default"` | Thread ID to deliver proactive sub-session results to (e.g. a Matrix room thread); defaults to the main LLM thread |
+| `proactive_target_thread_id` | no | `"default"` | When `"default"` (recommended), proactive results are eligible for broadcast to rooms opted in via `/proactive on`. When set to any other thread ID, proactive sub-sessions deliver only to that thread and room opt-in broadcast is bypassed. |
+
+> **Experimental — Proactive delivery to rooms:** Proactive sub-sessions can deliver their results to specific Matrix/Signal rooms when `proactive_target_thread_id` is `"default"` (or unset). Each room must opt in via the `/proactive on` slash command. Results are delivered to all opted-in rooms simultaneously. Disable delivery for a room with `/proactive off`. If `proactive_target_thread_id` is set to a non-`"default"` thread, proactive results go only to that thread and room opt-in is bypassed. Because proactive sessions run with full tool access (including the ability to spawn sub-workers), they can take autonomous actions — not just summarise. Users will see the final LLM-processed response in their opted-in room.
 
 **Access tracking:** Every `search()` call updates `last_accessed` and `access_count` for returned entries. This metadata drives stale pruning during dreaming.
 

wintermute/core/llm_thread.py

@@ -92,6 +92,7 @@ class _QueueItem:
     # dequeued, the correction is stale and will be dropped.
     correction_for_seq: Optional[int] = None
     ephemeral: bool = False  # skip loading history (group mode: single-turn)
+    is_proactive: bool = False  # result of a proactive sub-session (routes to opted-in rooms)
 
 
 class LLMThread:
@@ -228,9 +229,11 @@ async def enqueue_user_message(
         ))
         return await fut
 
-    async def enqueue_system_event(self, text: str, thread_id: str = "default") -> None:
+    async def enqueue_system_event(self, text: str, thread_id: str = "default", *,
+                                   is_proactive: bool = False) -> None:
         """Submit an autonomous system event (heartbeat, scheduled task, etc.)."""
-        await self._dispatch(_QueueItem(text=text, thread_id=thread_id, is_system_event=True))
+        await self._dispatch(_QueueItem(text=text, thread_id=thread_id, is_system_event=True,
+                                        is_proactive=is_proactive))
 
     async def reset_session(self, thread_id: str = "default") -> None:
         await self._session_mgr.reset_session(thread_id)
@@ -444,12 +447,13 @@ async def _thread_worker(self, thread_id: str) -> None:
                 elif item.is_system_event and not item.future and item.convergence_depth == 0:
                     text_to_send = reply.text or item.text
                     logger.info(
-                        "Broadcasting system-event reply for thread %s (%d chars, reply_empty=%s)",
-                        thread_id, len(text_to_send), not reply.text,
+                        "Broadcasting system-event reply for thread %s (%d chars, reply_empty=%s, proactive=%s)",
+                        thread_id, len(text_to_send), not reply.text, item.is_proactive,
                     )
                     try:
                         await self._broadcast(text_to_send, thread_id,
-                                              reasoning=reply.reasoning)
+                                              reasoning=reply.reasoning,
+                                              is_proactive=item.is_proactive)
                     except Exception:  # noqa: BLE001
                         logger.exception("Failed to broadcast system-event reply for thread %s",
                                          thread_id)

wintermute/core/sub_session.py

@@ -205,6 +205,7 @@ class SubSessionState:
     timeout_value: int = DEFAULT_TIMEOUT    # configured timeout for this session
     cp_verdict: str = "skipped"             # CP verdict: 'pass' | 'fail' | 'skipped'
     task_id: Optional[str] = None          # originating scheduled task id (for reflection)
+    is_proactive: bool = False             # set by scheduler for proactive sessions
 
 
 @dataclass
@@ -230,6 +231,7 @@ class TaskNode:
     max_rounds: Optional[int] = None        # None = unlimited inference rounds
     skip_cp_on_exit: bool = False           # skip CP post_inference on terminal response
     task_id: Optional[str] = None          # originating scheduled task id (for reflection)
+    is_proactive: bool = False             # set by scheduler for proactive sessions
 
 
 @dataclass
@@ -375,6 +377,7 @@ def spawn(
         profile: Optional[str] = None,
         task_id: Optional[str] = None,
         spawn_batch_id: Optional[str] = None,
+        is_proactive: bool = False,
     ) -> str:
         """
         Register a sub-session and start it immediately (or defer if deps pending).
@@ -464,6 +467,7 @@ def spawn(
             max_rounds=max_rounds,
             skip_cp_on_exit=skip_cp_on_exit,
             task_id=task_id,
+            is_proactive=is_proactive,
         )
 
         if deps:
@@ -493,6 +497,7 @@ def spawn(
                     system_prompt_mode=system_prompt_mode,
                     status="failed", created_at=now,
                     error=node.error,
+                    is_proactive=is_proactive,
                 )
                 self._states[session_id] = state
                 report_coro = self._report(state, f"[SUB-SESSION {session_id} FAILED] dependency failed")
@@ -508,6 +513,7 @@ def spawn(
                     system_prompt_mode=system_prompt_mode,
                     status="pending", created_at=now,
                     nesting_depth=nesting_depth,
+                    is_proactive=is_proactive,
                 )
                 self._states[session_id] = state
                 logger.info(
@@ -540,6 +546,7 @@ def spawn(
                 system_prompt_mode=system_prompt_mode,
                 status="pending", created_at=now,
                 nesting_depth=nesting_depth,
+                is_proactive=is_proactive,
             )
             self._states[session_id] = state
             self._schedule_time_gate(session_id, node.not_before)
@@ -848,6 +855,7 @@ def _start_node(
             skip_cp_on_exit=node.skip_cp_on_exit,
             timeout_value=node.timeout,
             task_id=node.task_id,
+            is_proactive=node.is_proactive,
         )
         self._states[session_id] = state
 
@@ -950,6 +958,7 @@ async def _resolve_dependents(self, session_id: str) -> None:
                     system_prompt_mode=n.system_prompt_mode,
                     status="failed", created_at="",
                     error=n.error,
+                    is_proactive=n.is_proactive,
                 ),
                 f"[SUB-SESSION {n.node_id} FAILED] dependency failed",
             )
@@ -1564,7 +1573,8 @@ async def _report(self, state: SubSessionState, text: str) -> None:
 
         if state.parent_thread_id:
             try:
-                await self._enqueue(text, state.parent_thread_id)
+                is_proactive = state.is_proactive
+                await self._enqueue(text, state.parent_thread_id, is_proactive=is_proactive)
             except Exception as exc:  # noqa: BLE001
                 logger.error("Sub-session %s failed to report back: %s", state.session_id, exc)
         else:
@@ -1650,7 +1660,8 @@ async def _check_nested_aggregation(self, completed_session_id: str) -> None:
             len(siblings), parent_sid, root_tid,
         )
         try:
-            await self._enqueue(text, root_tid)
+            is_proactive = parent_state.is_proactive if parent_state else False
+            await self._enqueue(text, root_tid, is_proactive=is_proactive)
         except Exception as exc:  # noqa: BLE001
             logger.error(
                 "Failed to deliver aggregated nested results to %s: %s",

wintermute/infra/thread_config.py

@@ -15,6 +15,7 @@
   - ``memory_score_threshold``    — minimum similarity score for memory retrieval
   - ``compaction_keep_recent``    — messages kept untouched during compaction
   - ``max_inline_tool_rounds``    — inline tool call limit before CP enforcement
+  - ``proactive_enabled``         — opt this room/thread into proactive message delivery [experimental]
 
 The ``ThreadConfigManager`` caches configs in memory and persists to SQLite.
 All mutations are logged to the interaction_log for auditability.
@@ -49,6 +50,7 @@ class ThreadConfig:
     memory_score_threshold: Optional[float] = None
     compaction_keep_recent: Optional[int] = None
     max_inline_tool_rounds: Optional[int] = None
+    proactive_enabled: Optional[bool] = None  # opt-in for proactive message delivery [experimental]
 
     def to_json(self) -> str:
         return json.dumps(asdict(self))
@@ -76,6 +78,7 @@ class ResolvedThreadConfig:
     memory_score_threshold: float
     compaction_keep_recent: int
     max_inline_tool_rounds: int
+    proactive_enabled: bool  # opt-in for proactive message delivery [experimental]
 
 
 # Hardcoded fallback defaults (baseline when no per-thread override exists).
@@ -91,6 +94,7 @@ class ResolvedThreadConfig:
     "memory_score_threshold": 0.3,
     "compaction_keep_recent": 10,
     "max_inline_tool_rounds": 3,
+    "proactive_enabled": False,
 }
 
 # Valid values for system_prompt_mode.
@@ -218,6 +222,7 @@ def _pick(key: str):
             memory_score_threshold=float(_pick("memory_score_threshold")),
             compaction_keep_recent=int(_pick("compaction_keep_recent")),
             max_inline_tool_rounds=int(_pick("max_inline_tool_rounds")),
+            proactive_enabled=bool(_pick("proactive_enabled")),
         )
 
     def resolve_as_dict(self, thread_id: str) -> dict:
@@ -305,6 +310,13 @@ def get_available_backends(self) -> list[str]:
         """Return the list of configured backend names."""
         return list(self._available_backends)
 
+    def get_proactive_thread_ids(self) -> list[str]:
+        """Return thread_ids that have opted in to proactive message delivery."""
+        return [
+            tid for tid, tc in self._cache.items()
+            if tc.proactive_enabled is True
+        ]
+
     def get_all_overrides(self) -> dict[str, dict]:
         """Return all thread_ids that have custom config (for SSE/debug)."""
         result = {}
@@ -428,6 +440,8 @@ def set(self, thread_id: str, key: str, value: Any,
             value = int(value)
             if value < 0:
                 raise ValueError("max_inline_tool_rounds must be >= 0 (or null to use default)")
+        elif key == "proactive_enabled":
+            value = _parse_bool(value)
 
         old_value = getattr(tc, key, None)
         setattr(tc, key, value)

wintermute/interfaces/slash_commands.py

@@ -116,6 +116,9 @@ async def dispatch(self, text: str, thread_id: str, send_fn: SendFn) -> bool:
         if text == "/commands":
             await self._cmd_commands(send_fn)
             return True
+        if text.split(maxsplit=1)[0] == "/proactive":
+            await self._cmd_proactive(text, thread_id, send_fn)
+            return True
 
         return False
 
@@ -493,6 +496,45 @@ async def _cmd_memory_stats(self, send_fn: SendFn) -> None:
         except Exception as exc:
             await send_fn(f"Failed to get memory stats: {exc}")
 
+    async def _cmd_proactive(self, text: str, thread_id: str, send_fn: SendFn) -> None:
+        """[experimental] Opt this room in or out of proactive message delivery."""
+        mgr = self._thread_config_manager
+        if not mgr:
+            await send_fn("Thread config manager not available.")
+            return
+
+        parts = text.strip().split()
+        if len(parts) == 1:
+            # Show current status.
+            resolved = mgr.resolve(thread_id)
+            state = "on" if resolved.proactive_enabled else "off"
+            await send_fn(
+                f"Proactive delivery for this room is currently **{state}**.\n"
+                f"Use `/proactive on` or `/proactive off` to change it.\n"
+                f"*(experimental)*"
+            )
+            return
+
+        arg = parts[1].lower()
+        if arg not in ("on", "off"):
+            await send_fn("Usage: `/proactive on` or `/proactive off`")
+            return
+
+        try:
+            mgr.set(thread_id, "proactive_enabled", arg, source="slash")
+        except ValueError as exc:
+            await send_fn(f"Error: {exc}")
+            return
+
+        if arg == "on":
+            await send_fn(
+                "Proactive delivery **enabled** for this room. "
+                "Scheduled proactive check-ins will be delivered here.\n"
+                "*(experimental — use `/proactive off` to disable)*"
+            )
+        else:
+            await send_fn("Proactive delivery **disabled** for this room.")
+
     async def _cmd_commands(self, send_fn: SendFn) -> None:
         await send_fn(
             "**Wintermute — Slash Commands**\n\n"
@@ -502,7 +544,8 @@ async def _cmd_commands(self, send_fn: SendFn) -> None:
             "**Autonomy**\n"
             "- `/tasks` — List all active tasks\n"
             "- `/dream` — Run a dream cycle (memory consolidation + task pruning)\n"
-            "- `/reflect` — Trigger a reflection cycle; shows findings and self-model update\n\n"
+            "- `/reflect` — Trigger a reflection cycle; shows findings and self-model update\n"
+            "- `/proactive [on|off]` — Opt this room in/out of proactive check-ins *(experimental)*\n\n"
             "**Memory**\n"
             "- `/memory-stats` — Show memory store backend, entry count, and status\n"
             "- `/rebuild-index` — Rebuild the vector memory index\n\n"

wintermute/main.py

@@ -577,7 +577,8 @@ def _tuning_int(key: str, default: int, minimum: int = 0) -> int:
     _signal_ref: list[Optional[SignalThread]] = [None]
 
     async def broadcast(text: str, thread_id: Optional[str] = None, *,
-                        reasoning: Optional[str] = None) -> None:
+                        reasoning: Optional[str] = None,
+                        is_proactive: bool = False) -> None:
         mx = _matrix_ref[0]
         wi = _web_ref[0]
         si = _signal_ref[0]
@@ -587,6 +588,24 @@ async def broadcast(text: str, thread_id: Optional[str] = None, *,
             await mx.send_message(text, thread_id)
         if wi and thread_id:
             await wi.broadcast(text, thread_id, reasoning=reasoning)
+        # Proactive results: deliver to all rooms that have opted in via /proactive on.
+        # This fires only when thread_id == "default" (proactive sessions have no specific
+        # target room), ensuring regular messages are never duplicated.
+        if is_proactive and thread_id == "default":
+            opted_in = thread_config_mgr.get_proactive_thread_ids()
+            if opted_in:
+                async def _send_to_room(tid: str) -> None:
+                    try:
+                        if si and tid.startswith("sig_"):
+                            await si.send_message(text, tid)
+                        elif wi and tid.startswith("web_"):
+                            await wi.broadcast(text, tid, reasoning=reasoning)
+                        elif mx and not tid.startswith("web_") and not tid.startswith("sig_"):
+                            await mx.send_message(text, tid)
+                    except Exception as exc:  # noqa: BLE001
+                        logger.warning("Failed to deliver proactive message to %s: %s", tid, exc, exc_info=True)
+
+                await asyncio.gather(*(_send_to_room(tid) for tid in opted_in))
 
     # 2. LLMThread — uses a lazy getter for SubSessionManager (breaks cycle).
     seed_language = cfg.get("seed", {}).get("language", "en") if cfg.get("seed") else "en"

wintermute/workers/scheduler_thread.py

@@ -719,6 +719,7 @@ async def _check_predictions(self) -> None:
                 ),
                 system_prompt_mode="full",
                 parent_thread_id=self._cfg.proactive_target_thread_id,
+                is_proactive=True,
             )
 
             if self._event_bus: