diploid-plugins 0.1.0__tar.gz

diploid_plugins-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Emil Tsoi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

diploid_plugins-0.1.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: diploid-plugins
+Version: 0.1.0
+Summary: Built-in state plugins for diploid-agent
+License: MIT
+Project-URL: Homepage, https://github.com/emiltsoi/diploid-plugins
+Project-URL: Repository, https://github.com/emiltsoi/diploid-plugins.git
+Project-URL: Issues, https://github.com/emiltsoi/diploid-plugins/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: diploid-agent>=0.5.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: ruff>=0.5; extra == "dev"
+Requires-Dist: respx>=0.20; extra == "dev"
+Dynamic: license-file
+
+# diploid-plugins
+
+Built-in state plugins for [`diploid-agent`](https://github.com/emiltsoi/diploid-agent).
+
+These plugins implement the `diploid-agent` plugin contract (`StatePlugin` lifecycle hooks) and are loaded by the harness through the `harness.plugins` config.
+
+## Included plugins
+
+- `body` — physical/emotional body state that persists across sessions and transport restarts. Includes a felt layer: `felt_warmth` (an ember that fades per wake/turn, not per wall-clock minute — a restart is not an experience) and `felt_summary` (one agent-authored line of texture via the `body_felt` MCP tool; never synthesized from telemetry). Reads are pure — `state_for_prompt` never mutates.
+- `continuity` — wake state, time asleep, last stop reason, pending dispatches, and active/interrupted-turn breadcrumbs (`current_intent`/`last_side_effect`).
+- `working_memory` — a chat-scoped scratchpad for the current turn.
+- `persistent_memory` — auto-recall and auto-promote of ` ```memory ` blocks, including mid-stream promotion while the reply is still being written.
+- `planner` — turn a user request into an executable plan.
+- `auto_continue` — resume a turn automatically after a configured stop reason.
+- `self_state` — a first-person self-state note across sessions, with a first-person guard that keeps the previous note if a new block is not written in `I am`/`We are`/`My` form.
+- `self_management` — in-chat plugin enable/disable and approval tools.
+- `curriculum` — language-learning target, unit, and vocabulary tracking.
+- `identity` — self-narrative / identity prompt block.
+
+## Install
+
+```bash
+pip install diploid-agent[plugins]
+# or explicitly
+pip install diploid-agent diploid-plugins
+```
+
+## Usage
+
+In `config/harness.yaml`:
+
+```yaml
+harness:
+  plugins:
+    - name: continuity
+      module: diploid_plugins.continuity
+      prompt_slot: wake
+      first_prompt_only: true
+      prompt_order: 0
+      state_file: chat_wake_state.json
+      max_prompt_chars: 1024
+    - name: working_memory
+      module: diploid_plugins.working_memory
+      prompt_slot: working_memory
+      first_prompt_only: false
+      prompt_order: 40
+      state_file: chat_working_memory.json
+      max_prompt_chars: 1024
+    # ... add the rest as needed
+```
+
+## Development
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev]"
+pytest
+```
+
+## Hot reload
+
+With an editable install, plugin changes go live in a running harness without
+a service restart: `POST /plugin/reload` (or Telegram `/plugin reload <name>`)
+deep-reloads the plugin's whole package subtree — every already-imported
+submodule, then the package itself — and recycles its instances.
+
+Keep module-level code side-effect free: reload re-executes it. Do real work in
+`start()`, release resources in `stop()`. A module that fails to import makes
+the reload raise and leaves the running instances untouched. Changes in code
+outside the plugin's own subtree (e.g. a shared helper package) are not picked
+up — reload each dependent plugin or restart the service.
+
+## License
+
+[MIT](LICENSE)

diploid_plugins-0.1.0/README.md

@@ -0,0 +1,76 @@
+# diploid-plugins
+
+Built-in state plugins for [`diploid-agent`](https://github.com/emiltsoi/diploid-agent).
+
+These plugins implement the `diploid-agent` plugin contract (`StatePlugin` lifecycle hooks) and are loaded by the harness through the `harness.plugins` config.
+
+## Included plugins
+
+- `body` — physical/emotional body state that persists across sessions and transport restarts. Includes a felt layer: `felt_warmth` (an ember that fades per wake/turn, not per wall-clock minute — a restart is not an experience) and `felt_summary` (one agent-authored line of texture via the `body_felt` MCP tool; never synthesized from telemetry). Reads are pure — `state_for_prompt` never mutates.
+- `continuity` — wake state, time asleep, last stop reason, pending dispatches, and active/interrupted-turn breadcrumbs (`current_intent`/`last_side_effect`).
+- `working_memory` — a chat-scoped scratchpad for the current turn.
+- `persistent_memory` — auto-recall and auto-promote of ` ```memory ` blocks, including mid-stream promotion while the reply is still being written.
+- `planner` — turn a user request into an executable plan.
+- `auto_continue` — resume a turn automatically after a configured stop reason.
+- `self_state` — a first-person self-state note across sessions, with a first-person guard that keeps the previous note if a new block is not written in `I am`/`We are`/`My` form.
+- `self_management` — in-chat plugin enable/disable and approval tools.
+- `curriculum` — language-learning target, unit, and vocabulary tracking.
+- `identity` — self-narrative / identity prompt block.
+
+## Install
+
+```bash
+pip install diploid-agent[plugins]
+# or explicitly
+pip install diploid-agent diploid-plugins
+```
+
+## Usage
+
+In `config/harness.yaml`:
+
+```yaml
+harness:
+  plugins:
+    - name: continuity
+      module: diploid_plugins.continuity
+      prompt_slot: wake
+      first_prompt_only: true
+      prompt_order: 0
+      state_file: chat_wake_state.json
+      max_prompt_chars: 1024
+    - name: working_memory
+      module: diploid_plugins.working_memory
+      prompt_slot: working_memory
+      first_prompt_only: false
+      prompt_order: 40
+      state_file: chat_working_memory.json
+      max_prompt_chars: 1024
+    # ... add the rest as needed
+```
+
+## Development
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev]"
+pytest
+```
+
+## Hot reload
+
+With an editable install, plugin changes go live in a running harness without
+a service restart: `POST /plugin/reload` (or Telegram `/plugin reload <name>`)
+deep-reloads the plugin's whole package subtree — every already-imported
+submodule, then the package itself — and recycles its instances.
+
+Keep module-level code side-effect free: reload re-executes it. Do real work in
+`start()`, release resources in `stop()`. A module that fails to import makes
+the reload raise and leaves the running instances untouched. Changes in code
+outside the plugin's own subtree (e.g. a shared helper package) are not picked
+up — reload each dependent plugin or restart the service.
+
+## License
+
+[MIT](LICENSE)

diploid_plugins-0.1.0/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["setuptools>=70.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "diploid-plugins"
+version = "0.1.0"
+description = "Built-in state plugins for diploid-agent"
+readme = "README.md"
+requires-python = ">=3.12"
+license = {text = "MIT"}
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+    "diploid-agent>=0.5.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.23",
+    "ruff>=0.5",
+    "respx>=0.20",
+]
+
+[project.urls]
+Homepage = "https://github.com/emiltsoi/diploid-plugins"
+Repository = "https://github.com/emiltsoi/diploid-plugins.git"
+Issues = "https://github.com/emiltsoi/diploid-plugins/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"

diploid_plugins-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

diploid_plugins-0.1.0/src/diploid_plugins/__init__.py

@@ -0,0 +1,25 @@
+"""Built-in state plugins for diploid-agent."""
+
+from diploid_plugins.auto_continue import AutoContinuePlugin
+from diploid_plugins.body import BodyPlugin
+from diploid_plugins.continuity import ContinuityPlugin
+from diploid_plugins.curriculum import CurriculumPlugin
+from diploid_plugins.identity import IdentityPlugin
+from diploid_plugins.persistent_memory import PersistentMemoryPlugin
+from diploid_plugins.planner import PlannerPlugin
+from diploid_plugins.self_management import SelfManagementPlugin
+from diploid_plugins.self_state import SelfStatePlugin
+from diploid_plugins.working_memory import WorkingMemoryPlugin
+
+__all__ = [
+    "AutoContinuePlugin",
+    "BodyPlugin",
+    "ContinuityPlugin",
+    "CurriculumPlugin",
+    "IdentityPlugin",
+    "PersistentMemoryPlugin",
+    "PlannerPlugin",
+    "SelfManagementPlugin",
+    "SelfStatePlugin",
+    "WorkingMemoryPlugin",
+]

diploid_plugins-0.1.0/src/diploid_plugins/auto_continue/__init__.py

@@ -0,0 +1,5 @@
+"""Auto-continue plugin."""
+
+from diploid_plugins.auto_continue.auto_continue import AutoContinuePlugin
+
+Plugin = AutoContinuePlugin

diploid_plugins-0.1.0/src/diploid_plugins/auto_continue/auto_continue.py

@@ -0,0 +1,222 @@
+"""Auto-continue plugin: resume a chat turn automatically after a stop reason."""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+from pathlib import Path
+from typing import Any
+
+from diploid_agent.config import PluginConfig
+from diploid_agent.models import WakeEvent
+from diploid_agent.plugins.base import StatePlugin, TurnInfo
+from diploid_agent.plugins.contexts import TurnStartContext
+from diploid_agent.runtime.plugin_runtime import PluginRuntime
+
+logger = logging.getLogger(__name__)
+
+# Cap the continuation payload so the wake queue and downstream Telegram edits
+# do not balloon with a huge partial thought stream.
+_MAX_CONTINUATION_TEXT_CHARS = 2000
+
+
+def _join_notices(*parts: str | None) -> str | None:
+    """Concatenate non-empty notice strings with a blank line between them."""
+    joined = "\n\n".join(p for p in parts if p)
+    return joined or None
+
+
+class AutoContinuePlugin(StatePlugin):
+    """Resume a chat turn automatically after a configured stop reason."""
+
+    def __init__(
+        self,
+        config: PluginConfig,
+        chat_id: str,
+        sessions_root: Path,
+        runtime: PluginRuntime | None = None,
+    ) -> None:
+        super().__init__(config, chat_id, sessions_root, runtime=runtime)
+        self._state = self._load_state()
+        cfg = self.config.config or {}
+        self._delay_seconds = float(cfg.get("delay_seconds", 2.0))
+        self._max_attempts = int(cfg.get("max_attempts", 3))
+        self._delay_cap_seconds = float(cfg.get("delay_cap_seconds", 60.0))
+        self._stop_reasons = set(cfg.get("stop_reasons", ["timeout", "cancelled"]))
+        self._per_reason = dict(cfg.get("per_reason", {}))
+        self._reason = cfg.get("reason", "auto_continue")
+
+    def _settings(self, stop_reason: str | None) -> tuple[int, float, float]:
+        """Return (max_attempts, delay_seconds, delay_cap) for a stop reason."""
+        reason_cfg = self._per_reason.get(stop_reason, {})
+        max_attempts = int(reason_cfg.get("max_attempts", self._max_attempts))
+        delay = float(reason_cfg.get("delay_seconds", self._delay_seconds))
+        cap = float(reason_cfg.get("delay_cap_seconds", self._delay_cap_seconds))
+        return max_attempts, delay, cap
+
+    def _backoff_delay(self, delay: float, attempt: int, cap: float) -> float:
+        """Exponential backoff capped at delay_cap_seconds."""
+        return min(delay * (2 ** (attempt - 1)), cap)
+
+    def _load_state(self) -> dict[str, Any]:
+        path = self.state_path()
+        if path is None or not path.exists():
+            return {}
+        try:
+            return json.loads(path.read_text())
+        except (json.JSONDecodeError, OSError):
+            return {}
+
+    def _save_state(self) -> None:
+        path = self.state_path()
+        if path is None:
+            return
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(self._state, indent=2, default=str))
+
+    def _is_continuation(self, text: str) -> bool:
+        if not self._runtime:
+            return False
+        return self._runtime.is_continuation_message(text)
+
+    def _cancel_pending(self) -> None:
+        if not self._runtime:
+            return
+        now = time.time()
+        for event in self._runtime.wake_queue.pending(chat_id=self.chat_id):
+            if event.reason != self._reason:
+                continue
+            if event.leased_until is not None and event.leased_until > now:
+                continue
+            self._runtime.wake_queue.complete(event.id)
+
+    def before_turn(self, context: TurnStartContext) -> None:
+        record = context.record
+        if record is None or record.last_stop_reason not in self._stop_reasons:
+            return
+
+        if self._is_continuation(context.user_message):
+            # Manual continue takes over; cancel any pending auto-continue and
+            # drop any deferred partial notice.
+            self._cancel_pending()
+            self._state.pop("deferred_notice", None)
+            self._state.pop("send_deferred", None)
+            self._save_state()
+            # Attempt count stays as-is because this manual turn is the next attempt.
+        else:
+            # User changed topic; cancel the auto-continue chain and drop the
+            # deferred partial notice. If the user wants the partial result, they
+            # can still say Continue; otherwise we should not leak a soft-timeout
+            # / stopped notice into a normal reply.
+            self._cancel_pending()
+            self._state["attempt"] = 0
+            self._state.pop("deferred_notice", None)
+            self._state.pop("send_deferred", None)
+            self._save_state()
+
+    def after_turn(self, turn: TurnInfo) -> None:
+        # If the harness has suppressed auto-continue (e.g., a service restart
+        # is pending), drop the continuation chain and any deferred notice.
+        if self._runtime and self._runtime.is_auto_continue_suppressed(self.chat_id):
+            self._cancel_pending()
+            self._state.pop("deferred_notice", None)
+            self._state.pop("send_deferred", None)
+            self._state["attempt"] = 0
+            self._save_state()
+            return
+
+        reason = turn.last_stop_reason
+        if reason not in self._stop_reasons:
+            # The turn finished or was stopped by the user. Send any deferred
+            # partial notice that has been pending, then reset the chain.
+            if self._state.get("send_deferred") and self._state.get("deferred_notice"):
+                turn.notice = _join_notices(self._state.pop("deferred_notice"), turn.notice)
+                self._state.pop("send_deferred", None)
+                self._save_state()
+            elif self._state.get("attempt"):
+                self._state["attempt"] = 0
+                self._save_state()
+            return
+
+        max_attempts, base_delay, delay_cap = self._settings(reason)
+        attempt = self._state.get("attempt", 0) + 1
+        if attempt > max_attempts:
+            logger.info(
+                "Auto-continue for %s reached max %d attempts",
+                self.chat_id,
+                max_attempts,
+            )
+            # Give up: send the current partial notice along with any older one.
+            if turn.partial_notice or self._state.get("deferred_notice"):
+                turn.notice = _join_notices(
+                    turn.partial_notice,
+                    self._state.pop("deferred_notice", None),
+                    turn.notice,
+                )
+                turn.partial_notice = None
+                self._state.pop("send_deferred", None)
+            self._state["attempt"] = 0
+            self._save_state()
+            return
+
+        # Show the working indicator, but keep the partial notice visible so the
+        # user can see what was already completed before the auto-continuation.
+        delay = self._backoff_delay(base_delay, attempt, delay_cap)
+        working = f"Working... (attempt {attempt}/{max_attempts}); continuing automatically in {delay:.0f}s."
+        if turn.partial_notice:
+            turn.notice = _join_notices(
+                turn.notice,
+                turn.partial_notice,
+                working,
+            )
+            turn.partial_notice = None
+            # Do not carry a stale deferred notice from a previous version.
+            self._state.pop("deferred_notice", None)
+            self._state.pop("send_deferred", None)
+        else:
+            turn.notice = _join_notices(turn.notice, working)
+
+        self._schedule(attempt, max_attempts, delay)
+
+    def _schedule(self, attempt: int, max_attempts: int, delay: float) -> None:
+        if not self._runtime:
+            return
+
+        payload: dict[str, Any] = {"user_message": "Continue"}
+        try:
+            chat_id_int = int(self.chat_id)
+            placeholder_path = self.sessions_root / ".poller-placeholders" / f"{chat_id_int}.json"
+            if placeholder_path.exists():
+                placeholder_state = json.loads(placeholder_path.read_text())
+                payload["message_id"] = placeholder_state.get("message_id")
+                payload["thought_id"] = placeholder_state.get("thought_id")
+
+            active = self._runtime._active_turns.get(self.chat_id)
+            if active is not None:
+                payload["message_text"] = active.message_text[:_MAX_CONTINUATION_TEXT_CHARS]
+                payload["thought_text"] = active.thought_text[:_MAX_CONTINUATION_TEXT_CHARS]
+        except Exception:
+            logger.exception("Failed to capture continuation placeholder for %s", self.chat_id)
+
+        event = WakeEvent(
+            id="",
+            chat_id=self.chat_id,
+            reason=self._reason,
+            priority=1,
+            scheduled_at=time.time() + delay,
+            payload=payload,
+            silent=False,
+            created_at=time.time(),
+            ready=True,
+        )
+        self._runtime.wake_queue.enqueue(event)
+        self._state["attempt"] = attempt
+        self._save_state()
+        logger.info(
+            "Auto-continue scheduled for %s in %.1fs (attempt %d/%d)",
+            self.chat_id,
+            delay,
+            attempt,
+            max_attempts,
+        )

diploid_plugins-0.1.0/src/diploid_plugins/body/__init__.py

@@ -0,0 +1,8 @@
+"""Body state plugin for diploid-agent."""
+
+from diploid_plugins.body.body import BodyPlugin
+from diploid_plugins.body.body_mcp import BodyMcpServer, main
+
+Plugin = BodyPlugin
+
+__all__ = ["BodyMcpServer", "BodyPlugin", "Plugin", "main"]