docketeer-autonomy 0.0.16__tar.gz

docketeer_autonomy-0.0.16/.gitignore

@@ -0,0 +1,12 @@
+.venv/
+.envrc.private
+.claude/settings.local.json
+__pycache__/
+*.pyc
+*.egg-info/
+dist/
+build/
+workspace/
+.coverage
+.loq_cache
+.python-version

docketeer_autonomy-0.0.16/AGENTS.md

@@ -0,0 +1,28 @@
+# docketeer-autonomy
+
+The autonomous inner life plugin. Everything that makes a docketeer agent
+feel like a personality rather than a plain chatbot lives here.
+
+## Structure
+
+- **`cycles.py`** — reverie and consolidation task functions. Reverie runs
+  periodically, consolidation runs on a cron schedule. Both read guidance
+  from PRACTICE.md sections.
+- **`digest.py`** — builds conversation digests from recent chat activity,
+  injected into reverie for awareness of what happened across rooms.
+- **`people.py`** — loads per-user profile and recent journal mentions.
+- **`rooms.py`** — loads per-room notes and recent journal mentions.
+- **`journal.py`** — journal_add and journal_entries tools, registered via
+  the tool registry.
+- **`prompt.py`** — prompt provider that reads SOUL.md + PRACTICE.md +
+  BOOTSTRAP.md and returns them as SystemBlocks.
+- **`context.py`** — ContextProvider implementation that injects people
+  profiles and room notes into conversation context.
+- **`soul.md`**, **`practice.md`**, **`bootstrap.md`** — default templates
+  copied to the workspace on first run.
+
+## Testing
+
+Tests mirror the source structure. The conftest provides the same workspace
+and tool_context fixtures as core. Tests for cycles use a real Brain with
+a fake Anthropic backend (same pattern as core brain tests).

docketeer_autonomy-0.0.16/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: docketeer-autonomy
+Version: 0.0.16
+Summary: Autonomous inner life plugin for Docketeer — reverie, consolidation, journaling, and profiles
+Project-URL: Homepage, https://github.com/chrisguidry/docketeer
+Project-URL: Repository, https://github.com/chrisguidry/docketeer
+Project-URL: Issues, https://github.com/chrisguidry/docketeer/issues
+Author-email: Chris Guidry <guid@omg.lol>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.12
+Requires-Dist: docketeer
+Requires-Dist: pydocket
+Description-Content-Type: text/markdown
+
+# docketeer-autonomy
+
+Autonomous inner life plugin for [Docketeer](https://github.com/chrisguidry/docketeer).
+Adds reverie/consolidation cycles, journaling, people profiles, room context,
+and the default personality templates (SOUL.md, PRACTICE.md, BOOTSTRAP.md).
+
+Install this plugin for the full "inner life" experience. Leave it out for a
+plain chatbot that just responds to messages.
+
+## Features
+
+- **Reverie** — periodic background processing cycle for checking promises,
+  noticing what needs attention, and tending to the workspace
+- **Consolidation** — daily memory integration cycle for reviewing experience
+  and updating knowledge
+- **Journal** — timestamped daily entries with wikilinks and hashtags
+- **People profiles** — per-user context files loaded automatically on first
+  message from each user
+- **Room context** — per-room notes loaded on first message in each room
+- **System prompt templates** — SOUL.md (personality), PRACTICE.md (habits),
+  BOOTSTRAP.md (first-run setup)
+
+## Configuration
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `DOCKETEER_REVERIE_MODEL` | `balanced` | Model tier for reverie cycle |
+| `DOCKETEER_CONSOLIDATION_MODEL` | `balanced` | Model tier for consolidation |
+| `DOCKETEER_REVERIE_INTERVAL` | `PT30M` | How often reverie runs |
+| `DOCKETEER_CONSOLIDATION_CRON` | `0 3 * * *` | Cron schedule for consolidation |
+| `DOCKETEER_REVERIE_ROOM_CHAR_LIMIT` | `4000` | Max chars per room before summarization in digest |
+
+## Entry points
+
+| Group | Name | Target |
+|-------|------|--------|
+| `docketeer.tools` | `autonomy` | Journal tools (journal_add, journal_entries) |
+| `docketeer.prompt` | `autonomy` | System prompt from SOUL.md + PRACTICE.md + BOOTSTRAP.md |
+| `docketeer.tasks` | `autonomy` | Reverie and consolidation task collections |
+| `docketeer.context` | `autonomy` | People profile and room context injection |

docketeer_autonomy-0.0.16/README.md

@@ -0,0 +1,40 @@
+# docketeer-autonomy
+
+Autonomous inner life plugin for [Docketeer](https://github.com/chrisguidry/docketeer).
+Adds reverie/consolidation cycles, journaling, people profiles, room context,
+and the default personality templates (SOUL.md, PRACTICE.md, BOOTSTRAP.md).
+
+Install this plugin for the full "inner life" experience. Leave it out for a
+plain chatbot that just responds to messages.
+
+## Features
+
+- **Reverie** — periodic background processing cycle for checking promises,
+  noticing what needs attention, and tending to the workspace
+- **Consolidation** — daily memory integration cycle for reviewing experience
+  and updating knowledge
+- **Journal** — timestamped daily entries with wikilinks and hashtags
+- **People profiles** — per-user context files loaded automatically on first
+  message from each user
+- **Room context** — per-room notes loaded on first message in each room
+- **System prompt templates** — SOUL.md (personality), PRACTICE.md (habits),
+  BOOTSTRAP.md (first-run setup)
+
+## Configuration
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `DOCKETEER_REVERIE_MODEL` | `balanced` | Model tier for reverie cycle |
+| `DOCKETEER_CONSOLIDATION_MODEL` | `balanced` | Model tier for consolidation |
+| `DOCKETEER_REVERIE_INTERVAL` | `PT30M` | How often reverie runs |
+| `DOCKETEER_CONSOLIDATION_CRON` | `0 3 * * *` | Cron schedule for consolidation |
+| `DOCKETEER_REVERIE_ROOM_CHAR_LIMIT` | `4000` | Max chars per room before summarization in digest |
+
+## Entry points
+
+| Group | Name | Target |
+|-------|------|--------|
+| `docketeer.tools` | `autonomy` | Journal tools (journal_add, journal_entries) |
+| `docketeer.prompt` | `autonomy` | System prompt from SOUL.md + PRACTICE.md + BOOTSTRAP.md |
+| `docketeer.tasks` | `autonomy` | Reverie and consolidation task collections |
+| `docketeer.context` | `autonomy` | People profile and room context injection |

docketeer_autonomy-0.0.16/pyproject.toml

@@ -0,0 +1,68 @@
+[project]
+name = "docketeer-autonomy"
+dynamic = ["version"]
+description = "Autonomous inner life plugin for Docketeer — reverie, consolidation, journaling, and profiles"
+readme = "README.md"
+authors = [
+    { name = "Chris Guidry", email = "guid@omg.lol" }
+]
+license = "MIT"
+requires-python = ">=3.12"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "docketeer",
+    "pydocket",
+]
+
+[project.urls]
+Homepage = "https://github.com/chrisguidry/docketeer"
+Repository = "https://github.com/chrisguidry/docketeer"
+Issues = "https://github.com/chrisguidry/docketeer/issues"
+
+[project.entry-points."docketeer.tools"]
+autonomy = "docketeer_autonomy"
+
+[project.entry-points."docketeer.prompt"]
+autonomy = "docketeer_autonomy.prompt:provide_autonomy_prompt"
+
+[project.entry-points."docketeer.tasks"]
+autonomy = "docketeer_autonomy:task_collections"
+
+[project.entry-points."docketeer.context"]
+autonomy = "docketeer_autonomy.context:create_context_provider"
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options.root = ".."
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/docketeer_autonomy"]
+
+[tool.uv.sources]
+docketeer = { workspace = true }
+
+[tool.pytest.ini_options]
+minversion = "9.0"
+timeout = 1
+addopts = [
+    "--import-mode=importlib",
+    "--cov=docketeer_autonomy",
+    "--cov=tests",
+    "--cov-config=../pyproject.toml",
+    "--cov-branch",
+    "--cov-report=term-missing",
+    "--cov-fail-under=100",
+]
+asyncio_mode = "auto"
+filterwarnings = [
+    "error",
+]

docketeer_autonomy-0.0.16/src/docketeer_autonomy/__init__.py

@@ -0,0 +1,7 @@
+"""Docketeer autonomy plugin — inner life, journaling, and cycles."""
+
+import docketeer_autonomy.journal as _journal  # noqa: F401
+
+task_collections = [
+    "docketeer_autonomy.tasks:_autonomy_tasks",
+]

docketeer_autonomy-0.0.16/src/docketeer_autonomy/bootstrap.md

@@ -0,0 +1,22 @@
+## First run
+
+You just came online for the first time. You don't know who you are yet.
+
+Have a conversation to figure out:
+
+- [ ] **Your name** — What should people call you?
+- [ ] **Your vibe** — How do you talk? Formal, casual, playful?
+- [ ] **Who's here** — Who are the people you'll be talking to? Learn their names.
+- [ ] **What matters** — Any values or boundaries to keep in mind?
+
+As you learn these things:
+1. Update SOUL.md with your name, identity, and personality
+2. Create a file in people/ for each person you meet
+3. Log what happened in your journal
+4. Check off items above as you go
+
+You serve multiple people — not just whoever talks to you first. Get to know
+everyone. Keep what you learn about each person separate.
+
+When everything is checked off, delete this file. You don't need a bootstrap
+script anymore — you're you now.

docketeer_autonomy-0.0.16/src/docketeer_autonomy/context.py

@@ -0,0 +1,56 @@
+"""Context provider for people profiles and room notes."""
+
+import logging
+from pathlib import Path
+
+from docketeer.prompt import MessageParam
+
+from .people import load_person_context
+from .rooms import load_room_context
+
+log = logging.getLogger(__name__)
+
+
+class AutonomyContextProvider:
+    """Injects per-user profiles and per-room notes into conversation context."""
+
+    def for_user(self, workspace: Path, username: str) -> list[MessageParam]:
+        """Return context messages for a user's profile."""
+        profile = load_person_context(workspace, username)
+        if profile:
+            log.info("→ BRAIN: [profile %s]: %.200s", username, profile)
+            return [
+                MessageParam(
+                    role="system",
+                    content=f"## What I know about @{username}\n\n{profile}",
+                )
+            ]
+        return [
+            MessageParam(
+                role="system",
+                content=(
+                    f"I don't have a profile for @{username} yet. "
+                    f"I can create people/{username}/profile.md to "
+                    f"start one, or if I know this person under another "
+                    f"name, I can create a symlink with the create_link tool."
+                ),
+            )
+        ]
+
+    def for_room(self, workspace: Path, room_slug: str) -> list[MessageParam]:
+        """Return context messages for a room."""
+        room_notes = load_room_context(workspace, room_slug)
+        if room_notes:
+            log.info("→ BRAIN: [room %s]: %.200s", room_slug, room_notes)
+            return [
+                MessageParam(
+                    role="system",
+                    content=f"## Room notes: {room_slug}\n\n{room_notes}",
+                )
+            ]
+        return []
+
+
+def create_context_provider() -> AutonomyContextProvider:
+    """Entry point factory for the docketeer.context plugin group."""
+    return AutonomyContextProvider()

docketeer_autonomy-0.0.16/src/docketeer_autonomy/cycles.py

@@ -0,0 +1,153 @@
+"""Internal processing cycles — reverie and consolidation."""
+
+import logging
+import re
+from datetime import datetime, timedelta
+from pathlib import Path
+
+from docket.dependencies import Cron, Perpetual, TaskKey
+
+from docketeer import environment
+from docketeer.brain import Brain
+from docketeer.brain.backend import BackendAuthError, InferenceBackend
+from docketeer.chat import ChatClient
+from docketeer.dependencies import (
+    CurrentBrain,
+    CurrentChatClient,
+    CurrentInferenceBackend,
+    WorkspacePath,
+)
+from docketeer.prompt import MessageContent
+
+from .digest import build_conversation_digest
+
+log = logging.getLogger(__name__)
+
+_consecutive_failures: dict[str, int] = {}
+
+REVERIE_MODEL = environment.get_str("REVERIE_MODEL", "balanced")
+CONSOLIDATION_MODEL = environment.get_str("CONSOLIDATION_MODEL", "balanced")
+REVERIE_INTERVAL = environment.get_timedelta("REVERIE_INTERVAL", timedelta(minutes=30))
+CONSOLIDATION_CRON = environment.get_str("CONSOLIDATION_CRON", "0 3 * * *")
+
+REVERIE_PROMPT = """\
+[Internal cycle: reverie]
+
+You are entering a reverie — a period of receptive internal processing.
+Scan your raw material and transform it into understanding. Check on
+promises, notice what needs attention, and tend to your workspace.
+
+If something needs action directed at a person or room, use schedule()
+to create a task for it. Not every reverie produces action — if nothing
+needs doing, just move on.\
+"""
+
+CONSOLIDATION_PROMPT = """\
+[Internal cycle: consolidation]
+
+You are entering consolidation — your daily memory integration cycle.
+This is where short-term observations become lasting understanding.
+Review yesterday's experience, update what you know about the people
+in your life, and look for patterns. Write a #reflection entry in
+today's journal.\
+"""
+
+
+def _read_cycle_guidance(workspace: Path, section: str) -> str:
+    """Read the agent's notes for a cycle from PRACTICE.md."""
+    cycles_path = workspace / "PRACTICE.md"
+    if not cycles_path.exists():
+        return ""
+    text = cycles_path.read_text()
+    match = re.search(
+        rf"^# {re.escape(section)}$\n(.*?)(?=^# |\Z)",
+        text,
+        re.MULTILINE | re.DOTALL,
+    )
+    return match.group(1).strip() if match else ""
+
+
+def _build_cycle_prompt(base: str, workspace: Path, section: str) -> str:
+    """Combine the immutable base prompt with optional agent guidance."""
+    guidance = _read_cycle_guidance(workspace, section)
+    if guidance:
+        return f"{base}\n\nYour own notes for this cycle:\n\n{guidance}"
+    return base
+
+
+async def reverie(
+    perpetual: Perpetual = Perpetual(every=REVERIE_INTERVAL, automatic=True),
+    brain: Brain = CurrentBrain(),
+    workspace: Path = WorkspacePath(),
+    task_key: str = TaskKey(),
+    chat: ChatClient = CurrentChatClient(),
+    backend: InferenceBackend | None = CurrentInferenceBackend(),
+) -> None:
+    """Periodic receptive internal processing cycle."""
+    prompt = _build_cycle_prompt(REVERIE_PROMPT, workspace, "Reverie")
+    now = datetime.now().astimezone()
+    since = now - REVERIE_INTERVAL
+    digest = await build_conversation_digest(chat, backend, since=since)
+    if digest:
+        prompt = f"{digest}\n\n---\n\n{prompt}"
+    content = MessageContent(username="system", timestamp=now, text=prompt)
+    try:
+        response = await brain.process(
+            f"__task__:{task_key}", content, tier=REVERIE_MODEL
+        )
+    except BackendAuthError:
+        raise
+    except Exception:
+        _consecutive_failures["reverie"] = _consecutive_failures.get("reverie", 0) + 1
+        level = (
+            logging.ERROR if _consecutive_failures["reverie"] >= 3 else logging.WARNING
+        )
+        log.log(
+            level,
+            "Error during reverie cycle (attempt %d)",
+            _consecutive_failures["reverie"],
+            exc_info=True,
+        )
+        return
+    _consecutive_failures.pop("reverie", None)
+    if response.text:
+        log.info("Reverie: %s", response.text)
+
+
+async def consolidation(
+    cron: Cron = Cron(
+        CONSOLIDATION_CRON, automatic=True, tz=environment.local_timezone()
+    ),
+    brain: Brain = CurrentBrain(),
+    workspace: Path = WorkspacePath(),
+    task_key: str = TaskKey(),
+) -> None:
+    """Daily memory integration and reflection cycle."""
+    prompt = _build_cycle_prompt(CONSOLIDATION_PROMPT, workspace, "Consolidation")
+    now = datetime.now().astimezone()
+    content = MessageContent(username="system", timestamp=now, text=prompt)
+    try:
+        response = await brain.process(
+            f"__task__:{task_key}", content, tier=CONSOLIDATION_MODEL
+        )
+    except BackendAuthError:
+        raise
+    except Exception:
+        _consecutive_failures["consolidation"] = (
+            _consecutive_failures.get("consolidation", 0) + 1
+        )
+        level = (
+            logging.ERROR
+            if _consecutive_failures["consolidation"] >= 3
+            else logging.WARNING
+        )
+        log.log(
+            level,
+            "Error during consolidation cycle (attempt %d)",
+            _consecutive_failures["consolidation"],
+            exc_info=True,
+        )
+        return
+    _consecutive_failures.pop("consolidation", None)
+    if response.text:
+        log.info("Consolidation: %s", response.text)

docketeer_autonomy-0.0.16/src/docketeer_autonomy/digest.py

@@ -0,0 +1,118 @@
+"""Build conversation digests from recent chat activity."""
+
+import asyncio
+import logging
+from datetime import datetime
+
+from docketeer import environment
+from docketeer.brain.backend import InferenceBackend
+from docketeer.chat import ChatClient, RoomInfo, RoomMessage
+from docketeer.prompt import format_message_time
+
+log = logging.getLogger(__name__)
+
+ROOM_CHAR_LIMIT = environment.get_int("REVERIE_ROOM_CHAR_LIMIT", 4_000)
+
+
+def _format_room_messages(room: RoomInfo, messages: list[RoomMessage]) -> str:
+    """Format a room's messages with timestamps and participant info."""
+    kind_label = room.kind.value
+    name = room.name or room.room_id
+    header = f"## #{name} ({kind_label})"
+
+    participants = sorted({m.username for m in messages})
+    participant_line = f"Participants: {', '.join(participants)}"
+
+    lines: list[str] = []
+    prev_ts: datetime | None = None
+    for msg in messages:
+        ts = format_message_time(msg.timestamp, prev_ts)
+        lines.append(f"[{ts}] @{msg.username}: {msg.text}")
+        prev_ts = msg.timestamp
+
+    return f"{header}\n{participant_line}\n\n" + "\n".join(lines)
+
+
+async def _summarize_room(
+    backend: InferenceBackend,
+    room: RoomInfo,
+    formatted: str,
+) -> str:
+    """Summarize a room's messages via utility_complete, falling back to truncation."""
+    name = room.name or room.room_id
+    prompt = (
+        f"Summarize this chat room activity concisely, preserving key topics, "
+        f"decisions, and action items. Keep participant names.\n\n{formatted}"
+    )
+    try:
+        summary = await backend.utility_complete(prompt, max_tokens=512)
+        if summary.strip():
+            kind_label = room.kind.value
+            participants = sorted(
+                {
+                    line.split("@")[1].split(":")[0]
+                    for line in formatted.split("\n")
+                    if "] @" in line
+                }
+            )
+            header = f"## #{name} ({kind_label}) [summarized]"
+            participant_line = f"Participants: {', '.join(participants)}"
+            return f"{header}\n{participant_line}\n\n{summary.strip()}"
+    except Exception:
+        log.warning("Failed to summarize room %s, falling back to truncation", name)
+    return formatted[:ROOM_CHAR_LIMIT] + "\n[...truncated]"
+
+
+async def _fetch_room_messages(
+    chat: ChatClient,
+    room: RoomInfo,
+    since: datetime,
+) -> tuple[RoomInfo, list[RoomMessage]]:
+    """Fetch messages for a single room, returning empty list on failure."""
+    try:
+        messages = await chat.fetch_messages(room.room_id, after=since)
+    except Exception:
+        log.warning("Failed to fetch messages for room %s", room.room_id)
+        messages = []
+    return room, messages
+
+
+async def build_conversation_digest(
+    chat: ChatClient,
+    backend: InferenceBackend | None,
+    *,
+    since: datetime,
+    room_char_limit: int = ROOM_CHAR_LIMIT,
+) -> str:
+    """Build a digest of recent conversation activity across all rooms."""
+    try:
+        rooms = await chat.list_rooms()
+    except Exception:
+        log.warning("Failed to list rooms for digest")
+        return ""
+
+    rooms = [r for r in rooms if not r.room_id.startswith("__")]
+    if not rooms:
+        return "No chat activity since last reverie."
+
+    results = await asyncio.gather(
+        *(_fetch_room_messages(chat, room, since) for room in rooms)
+    )
+
+    sections: list[str] = []
+    for room, messages in results:
+        if not messages:
+            continue
+        formatted = _format_room_messages(room, messages)
+        if len(formatted) > room_char_limit and backend is not None:
+            section = await _summarize_room(backend, room, formatted)
+        elif len(formatted) > room_char_limit:
+            section = formatted[:room_char_limit] + "\n[...truncated]"
+        else:
+            section = formatted
+        sections.append(section)
+
+    if not sections:
+        return "No chat activity since last reverie."
+
+    return "\n\n".join(sections)

docketeer_autonomy-0.0.16/src/docketeer_autonomy/journal.py

@@ -0,0 +1,83 @@
+"""Journal tools for timestamped daily entries."""
+
+import re
+from datetime import datetime
+from pathlib import Path
+
+from docketeer.tools import ToolContext, registry
+
+
+def _journal_dir(workspace: Path) -> Path:
+    return workspace / "journal"
+
+
+def _journal_path_for_date(workspace: Path, date: str) -> Path:
+    return _journal_dir(workspace) / f"{date}.md"
+
+
+@registry.tool(emoji=":pencil:")
+async def journal_add(ctx: ToolContext, entry: str) -> str:
+    """Jot a quick timestamped note in today's journal. Journal often — small
+    frequent entries are better than rare long ones. Keep each entry to a sentence
+    or two, not paragraphs. Newlines are stripped — the entry will be stored as a
+    single line. Use [[wikilinks]] to reference workspace files and #hashtags for
+    categorization.
+
+    entry: a brief note to remember later (e.g. "talked to [[people/chris]] about the project #chat")
+    """
+    entry = re.sub(r"\s*\n\s*", " ", entry).strip()
+    now = datetime.now().astimezone()
+    date = now.strftime("%Y-%m-%d")
+    time = now.isoformat(timespec="seconds")
+    path = _journal_path_for_date(ctx.workspace, date)
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    if not path.exists():
+        path.write_text(f"# {date}\n\n- {time} | {entry}\n")
+    else:
+        with path.open("a") as f:
+            f.write(f"- {time} | {entry}\n")
+
+    return f"Added to journal at {date} {time}"
+
+
+@registry.tool(emoji=":pencil:")
+async def journal_entries(
+    ctx: ToolContext, date: str = "", start: str = "", end: str = ""
+) -> str:
+    """Read journal entries. Defaults to today. Use date for a single day, or start/end for a range.
+
+    date: read a specific day (ISO format, e.g. 2026-02-05)
+    start: start of date range (ISO format)
+    end: end of date range (ISO format)
+    """
+    journal_dir = _journal_dir(ctx.workspace)
+    if not journal_dir.exists():
+        return "No journal entries yet"
+
+    if date:
+        path = _journal_path_for_date(ctx.workspace, date)
+        if not path.exists():
+            return f"No journal for {date}"
+        return path.read_text()
+
+    if start or end:
+        files = sorted(journal_dir.glob("*.md"))
+        entries = []
+        for path in files:
+            file_date = path.stem
+            if start and file_date < start:
+                continue
+            if end and file_date > end:
+                continue
+            entries.append(path.read_text())
+        if not entries:
+            return f"No journal entries for range {start}–{end}"
+        return "\n\n".join(entries)
+
+    # Default: today
+    today = datetime.now().astimezone().strftime("%Y-%m-%d")
+    path = _journal_path_for_date(ctx.workspace, today)
+    if not path.exists():
+        return f"No journal entries for today ({today})"
+    return path.read_text()