caudate-cli 0.1.87__tar.gz → 0.1.89__tar.gz

{caudate_cli-0.1.87/caudate_cli.egg-info → caudate_cli-0.1.89}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: caudate-cli
-Version: 0.1.87
+Version: 0.1.89
 Summary: A local-first cognitive agent with a learned router (Caudate) and Claude-SDK-shaped tool palette.
 Author-email: Rave Manji <rahimtz93@googlemail.com>
 License-Expression: MIT

{caudate_cli-0.1.87 → caudate_cli-0.1.89/caudate_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: caudate-cli
-Version: 0.1.87
+Version: 0.1.89
 Summary: A local-first cognitive agent with a learned router (Caudate) and Claude-SDK-shaped tool palette.
 Author-email: Rave Manji <rahimtz93@googlemail.com>
 License-Expression: MIT

{caudate_cli-0.1.87 → caudate_cli-0.1.89}/caudate_cli.egg-info/SOURCES.txt

@@ -40,12 +40,15 @@ core/diff_viewer.py
 core/export.py
 core/file_refs.py
 core/files.py
+core/goal.py
+core/goal_store.py
 core/hooks.py
 core/image.py
 core/input.py
 core/loop.py
 core/memory_md.py
 core/notifications.py
+core/outcomes.py
 core/ownership.py
 core/paste.py
 core/permissions.py
@@ -77,6 +80,7 @@ execution/tools/calculator_tool.py
 execution/tools/cognos_card_tool.py
 execution/tools/cron_tool.py
 execution/tools/datetime_tool.py
+execution/tools/decompose_goal_tool.py
 execution/tools/describe_image_tool.py
 execution/tools/draw_tool.py
 execution/tools/edit_image_tool.py
@@ -120,6 +124,7 @@ memory/__init__.py
 memory/episodic.py
 memory/procedural.py
 memory/semantic.py
+memory/strategies.py
 memory/working.py
 nn/__init__.py
 nn/auto_evolve.py

{caudate_cli-0.1.87 → caudate_cli-0.1.89}/core/agent.py

@@ -231,16 +231,44 @@ class CognosAgent:
                 self.llm.set_mood(self.personality.mood)
 
         # Wrap personality's system_prompt provider with goal-injection.
-        # The slash command `/goal <text>` sets `self._goal`, which we
-        # prepend to whatever the personality returns. Stored as a
-        # plain attribute so the slash setter doesn't need a method.
+        # Legacy `self._goal` (free-text string) is preserved for
+        # backward-compat. Phase 2 introduces the structured
+        # `self.active_goal: Goal | None` — managed by the new
+        # /goal slash commands + core.goal_store, persists across
+        # sessions. 2.4 will inject its `render_for_prompt()` block.
         self._goal: str = ""
+        try:
+            from core.goal import Goal as _Goal  # noqa: F401 (type hint only)
+        except Exception:
+            pass
+        self.active_goal = None  # type: "Goal | None"
+        # Auto-resume: if a previous session set an active goal pointer,
+        # load it so caudate boots back into that goal's context. Best-
+        # effort; missing / unreadable goals are silently ignored.
+        try:
+            from core.goal_store import get_store
+            self.active_goal = get_store().active()
+        except Exception as e:
+            logger.debug(f"active goal auto-resume failed: {e}")
         _personality_wrap = (
             self.personality.wrap_system_prompt if self.personality else None
         )
 
         def system_prompt_provider(base: str) -> str:
             wrapped = _personality_wrap(base) if _personality_wrap else base
+            # Phase 2.4: prefer the structured active_goal's render_for_prompt
+            # block when present — it carries the subtask tree, progress
+            # counts, and a "don't restart the plan" nudge that single-
+            # string goal injection can't express. Falls back to the
+            # legacy free-text string for users who set /goal <text>
+            # without going through `/goal new`.
+            ag = getattr(self, "active_goal", None)
+            if ag is not None:
+                try:
+                    block = ag.render_for_prompt()
+                    return f"{block}\n\n{wrapped}"
+                except Exception as e:
+                    logger.debug(f"active_goal render failed: {e}")
             goal = (self._goal or "").strip()
             if not goal:
                 return wrapped

{caudate_cli-0.1.87 → caudate_cli-0.1.89}/core/agentic_loop.py

@@ -151,6 +151,11 @@ class AgenticLoop:
         self.documents = documents or []
         self.last_citations = []
         self._turn_aborted_by_user = False
+        # Phase 1.2: accumulate outcome signals across the turn so we
+        # can pass a real reward to Caudate at turn end instead of the
+        # success/failure heuristic.
+        from core.outcomes import OutcomeCollector
+        self._outcome_collector = OutcomeCollector()
         await self.hooks.emit(HookEvent.USER_PROMPT_SUBMIT, {"message": user_message})
         self._start_turn(user_message, attachments=attachments or [])
         consecutive_errors = 0
@@ -198,22 +203,40 @@ class AgenticLoop:
                 result_block = await self._execute_call(call)
                 self._append_tool_result(result_block)
                 self._notify_caudate_tool_use(call.name, was_error=result_block.is_error)
+                # Phase 1.2: feed each tool result into the outcome collector
+                try:
+                    self._outcome_collector.on_tool_result(
+                        name=call.name, ok=not result_block.is_error,
+                    )
+                except Exception:
+                    pass
                 if self._turn_aborted_by_user:
                     break
 
             if self._turn_aborted_by_user:
+                try:
+                    self._outcome_collector.on_turn_aborted_by_user()
+                except Exception:
+                    pass
                 msg = "(turn aborted: user denied a tool call)"
                 await self.hooks.emit(HookEvent.STOP, {"text": msg})
                 self._notify_caudate_turn_end()
                 return msg
 
         logger.warning(f"Agentic loop hit max_iterations={self.max_iterations}")
-        self._notify_caudate_turn_end(reward=0.2)  # hit cap → low reward
+        try:
+            self._outcome_collector.on_hit_max_iterations()
+        except Exception:
+            pass
+        self._notify_caudate_turn_end()  # outcome_collector now drives the reward
         return "(max iterations reached)"
 
     async def run_streaming(self, user_message: str) -> AsyncIterator[StreamEvent]:
         """Run the loop streaming tokens/events as they arrive."""
         self._turn_aborted_by_user = False
+        # Phase 1.2: outcome collector for the streaming path too.
+        from core.outcomes import OutcomeCollector
+        self._outcome_collector = OutcomeCollector()
         self._start_turn(user_message)
         self._notify_caudate_turn_start(user_message)
         tools = self._caudate_constrained_tools(self.executor.tool_definitions())
@@ -253,6 +276,12 @@ class AgenticLoop:
                 result_block = await self._execute_call(call)
                 self._append_tool_result(result_block)
                 self._notify_caudate_tool_use(call.name, was_error=result_block.is_error)
+                try:
+                    self._outcome_collector.on_tool_result(
+                        name=call.name, ok=not result_block.is_error,
+                    )
+                except Exception:
+                    pass
                 yield StreamEvent(
                     type="tool_result",
                     tool_use_id=call.id,
@@ -262,6 +291,10 @@ class AgenticLoop:
                     break
 
             if self._turn_aborted_by_user:
+                try:
+                    self._outcome_collector.on_turn_aborted_by_user()
+                except Exception:
+                    pass
                 self._notify_caudate_turn_end()
                 yield StreamEvent(
                     type="message_stop",
@@ -270,6 +303,11 @@ class AgenticLoop:
                 return
 
         logger.warning(f"Agentic loop (stream) hit max_iterations={self.max_iterations}")
+        try:
+            self._outcome_collector.on_hit_max_iterations()
+        except Exception:
+            pass
+        self._notify_caudate_turn_end()
 
     def reset(self) -> None:
         """Clear conversation history (new session)."""
@@ -764,13 +802,29 @@ class AgenticLoop:
     def _notify_caudate_turn_end(self, reward: float | None = None) -> None:
         if self.caudate is None:
             return
+        # Phase 1.2: drain the outcome collector. When signals fired,
+        # pass `outcome_reward ∈ [-1, +1]` and let the observer derive
+        # its native [0, 1] reward. When no signals fired (e.g. plain
+        # chat turn), fall back to the legacy heuristic.
+        outcome_reward = None
+        try:
+            coll = getattr(self, "_outcome_collector", None)
+            if coll is not None:
+                sig = coll.finalize()
+                if sig.is_informative():
+                    outcome_reward = sig.reward()
+                    logger.debug(f"caudate outcome signal: {sig.summary()}")
+        except Exception as e:
+            logger.debug(f"outcome collector finalize failed: {e}")
+
         try:
-            if reward is None and self.caudate._pending is not None:
-                # Heuristic if no explicit reward: 0.7 default,
-                # 0.3 if any tool errored mid-turn.
+            if outcome_reward is None and reward is None and self.caudate._pending is not None:
+                # Legacy heuristic if neither outcome signals nor an
+                # explicit reward are available: 0.7 default, 0.3 if
+                # any tool errored mid-turn.
                 had_err = getattr(self.caudate._pending, "_had_error", False)
                 reward = 0.3 if had_err else 0.7
-            self.caudate.on_turn_end(reward=reward)
+            self.caudate.on_turn_end(reward=reward, outcome_reward=outcome_reward)
         except Exception as e:
             logger.debug(f"caudate.on_turn_end failed: {e}")
 

{caudate_cli-0.1.87 → caudate_cli-0.1.89}/core/compaction.py

@@ -23,10 +23,26 @@ asked for, what tools were used and their key results, any decisions made, and
 any open threads. Be concise (300 words max) but include concrete facts (file
 paths, values, names). Do NOT add commentary — just the summary.
 
-Conversation:
+{goal_context}Conversation:
 {conversation}"""
 
 
+# Phase 2.6: when an active goal exists, prepend its block to the
+# compaction prompt so the summarizer LLM knows what context matters
+# most. Subtask transitions and attempt outcomes are easy to lose in
+# a generic "summarize this" pass; this nudge keeps them anchored.
+_GOAL_CONTEXT_HEADER = """The agent is working on this active goal:
+{goal_block}
+
+When summarizing, EXPLICITLY preserve:
+- Any subtask status transitions (which moved from pending → in_progress → done)
+- Any subtask that was blocked + why
+- Attempt outcomes that mattered (rewards, errors, unexpected results)
+- Decisions made about the goal's scope or approach
+
+"""
+
+
 class ContextCompactor:
     """Summarizes older messages to fit a token budget."""
 
@@ -72,7 +88,23 @@ class ContextCompactor:
         conversation = "\n\n".join(
             f"[{m.get('role')}]: {_content_str(m)}" for m in to_summarize
         )
-        prompt = COMPACT_PROMPT.format(conversation=conversation[:12000])
+        # Phase 2.6: pull the active goal context (if any) into the
+        # compactor's prompt so the LLM-driven summary preserves
+        # subtask transitions + outcomes instead of dropping them as
+        # "implementation noise".
+        goal_context = ""
+        try:
+            from core.goal_store import get_store
+            active = get_store().active()
+            if active is not None:
+                goal_block = active.render_for_prompt()
+                goal_context = _GOAL_CONTEXT_HEADER.format(goal_block=goal_block)
+        except Exception as e:
+            logger.debug(f"compaction goal-context lookup failed: {e}")
+        prompt = COMPACT_PROMPT.format(
+            conversation=conversation[:12000],
+            goal_context=goal_context,
+        )
 
         try:
             response = await self.llm.complete(prompt=prompt, caller="compaction")

caudate_cli-0.1.89/core/goal.py

@@ -0,0 +1,361 @@
+"""Agent-state Goal model (Phase 2.1).
+
+A `Goal` is the persistent intent the agent is working toward across
+turns and sessions. Unlike `planning.forge_models.ForgeProject` (which
+is the SQLAlchemy project-management surface), `Goal` here is the
+agent's working memory of "what we're ultimately trying to build /
+fix / explore."
+
+The schema is deliberately lean — JSON-serializable so it can live
+under `~/.caudate/goals/<id>.json` without a database dependency.
+
+A goal is the unit of resumption:
+    caudate --goal <id>              ← reboot into the goal
+    /goal resume <id>                ← swap to a different goal mid-session
+    /goal status                     ← see current subtask tree
+    /goal complete                   ← mark done (positive Phase 1 signal)
+    /goal abandon                    ← mark abandoned (negative signal)
+
+Subsequent Phase 2 sub-steps wire this in:
+    2.2 GoalStore (file persistence)
+    2.3 slash commands
+    2.4 system-prompt injection
+    2.5 sub-task decomposition tool
+    2.6 compaction-aware goal context
+    2.7 CLI flag
+"""
+
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass, field, asdict
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any
+
+
+# ---------------------------------------------------------------------
+# Status enums — string-valued so they round-trip through JSON cleanly.
+# ---------------------------------------------------------------------
+
+class GoalStatus(str, Enum):
+    ACTIVE     = "active"
+    PAUSED     = "paused"
+    COMPLETED  = "completed"
+    ABANDONED  = "abandoned"
+
+
+class SubtaskStatus(str, Enum):
+    PENDING     = "pending"
+    IN_PROGRESS = "in_progress"
+    DONE        = "done"
+    BLOCKED     = "blocked"
+
+
+class AttemptResult(str, Enum):
+    SUCCESS = "success"
+    PARTIAL = "partial"
+    ERROR   = "error"
+
+
+# ---------------------------------------------------------------------
+# Subtask — one step in the goal's decomposition.
+# ---------------------------------------------------------------------
+
+@dataclass
+class Subtask:
+    """A single step in the goal's decomposition tree."""
+
+    id: str
+    description: str
+    status: SubtaskStatus = SubtaskStatus.PENDING
+    # IDs of other subtasks that must complete before this one can start.
+    # Empty list = independently dispatchable (Phase 6 sub-agents will
+    # parallelize these).
+    depends_on: list[str] = field(default_factory=list)
+    # AttemptLog ids that targeted this subtask.
+    attempts: list[str] = field(default_factory=list)
+
+    @classmethod
+    def new(cls, description: str, depends_on: list[str] | None = None) -> "Subtask":
+        return cls(
+            id=str(uuid.uuid4()),
+            description=description,
+            depends_on=list(depends_on or []),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "description": self.description,
+            "status": self.status.value,
+            "depends_on": list(self.depends_on),
+            "attempts": list(self.attempts),
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> "Subtask":
+        return cls(
+            id=str(d.get("id") or uuid.uuid4()),
+            description=str(d.get("description", "")),
+            status=SubtaskStatus(d.get("status", "pending")),
+            depends_on=list(d.get("depends_on") or []),
+            attempts=list(d.get("attempts") or []),
+        )
+
+
+# ---------------------------------------------------------------------
+# AttemptLog — a turn-by-turn record of work toward the goal.
+# Links into Phase 1's outcome signal: `reward` is the same scalar
+# `outcome_reward` Phase 1.1+1.2 produce.
+# ---------------------------------------------------------------------
+
+@dataclass
+class AttemptLog:
+    """One turn's worth of work toward the goal."""
+
+    id: str
+    turn_index: int                     # ordinal across the goal's lifetime
+    timestamp: str                       # ISO 8601 UTC
+    subtask_id: str | None = None        # which subtask was being worked on
+    tool_calls: list[str] = field(default_factory=list)  # tool names in order
+    result: AttemptResult | None = None
+    reward: float | None = None          # outcome_reward ∈ [-1, +1] from Phase 1
+    note: str = ""                       # one-liner from agent: "added Flask routes"
+
+    @classmethod
+    def new(
+        cls,
+        turn_index: int,
+        subtask_id: str | None = None,
+        tool_calls: list[str] | None = None,
+        result: AttemptResult | None = None,
+        reward: float | None = None,
+        note: str = "",
+    ) -> "AttemptLog":
+        return cls(
+            id=str(uuid.uuid4()),
+            turn_index=turn_index,
+            timestamp=datetime.now(timezone.utc).isoformat(),
+            subtask_id=subtask_id,
+            tool_calls=list(tool_calls or []),
+            result=result,
+            reward=reward,
+            note=note,
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "turn_index": self.turn_index,
+            "timestamp": self.timestamp,
+            "subtask_id": self.subtask_id,
+            "tool_calls": list(self.tool_calls),
+            "result": self.result.value if self.result else None,
+            "reward": self.reward,
+            "note": self.note,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> "AttemptLog":
+        return cls(
+            id=str(d.get("id") or uuid.uuid4()),
+            turn_index=int(d.get("turn_index") or 0),
+            timestamp=str(d.get("timestamp") or datetime.now(timezone.utc).isoformat()),
+            subtask_id=d.get("subtask_id"),
+            tool_calls=list(d.get("tool_calls") or []),
+            result=AttemptResult(d["result"]) if d.get("result") else None,
+            reward=d.get("reward"),
+            note=str(d.get("note", "")),
+        )
+
+
+# ---------------------------------------------------------------------
+# Goal — the top-level persistent intent.
+# ---------------------------------------------------------------------
+
+@dataclass
+class Goal:
+    """Persistent agent-state intent. The unit of resumption."""
+
+    id: str
+    intent: str                            # user's original ask
+    cwd: str                               # workspace path
+    status: GoalStatus = GoalStatus.ACTIVE
+    created_at: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+    updated_at: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+    subtasks: list[Subtask] = field(default_factory=list)
+    attempts: list[AttemptLog] = field(default_factory=list)
+    # Cross-link to a forge project if the user spun one up alongside
+    # this goal (planning/forge_models.ForgeProject). Optional —
+    # most goals won't have one.
+    forge_project_id: int | None = None
+    notes: str = ""
+
+    @classmethod
+    def new(cls, intent: str, cwd: str) -> "Goal":
+        return cls(
+            id=str(uuid.uuid4()),
+            intent=intent,
+            cwd=cwd,
+        )
+
+    # ── State queries ──────────────────────────────────────────────
+
+    def is_active(self) -> bool:
+        return self.status == GoalStatus.ACTIVE
+
+    def short_id(self) -> str:
+        """First 8 chars of the UUID — what we show in the statusline / picker."""
+        return self.id[:8]
+
+    def subtask_counts(self) -> dict[str, int]:
+        """{status: count} across all subtasks."""
+        out = {s.value: 0 for s in SubtaskStatus}
+        for st in self.subtasks:
+            out[st.status.value] = out.get(st.status.value, 0) + 1
+        return out
+
+    def progress_fraction(self) -> float:
+        """Fraction of subtasks marked done. 0.0 if none."""
+        if not self.subtasks:
+            return 0.0
+        done = sum(1 for st in self.subtasks if st.status == SubtaskStatus.DONE)
+        return done / len(self.subtasks)
+
+    def next_dispatchable(self) -> list[Subtask]:
+        """Subtasks that are pending AND all their dependencies are done.
+        Phase 6 sub-agents will dispatch from this list in parallel."""
+        done_ids = {st.id for st in self.subtasks if st.status == SubtaskStatus.DONE}
+        return [
+            st for st in self.subtasks
+            if st.status == SubtaskStatus.PENDING
+            and all(dep in done_ids for dep in st.depends_on)
+        ]
+
+    # ── Mutation helpers ───────────────────────────────────────────
+
+    def touch(self) -> None:
+        self.updated_at = datetime.now(timezone.utc).isoformat()
+
+    def add_subtask(self, description: str, depends_on: list[str] | None = None) -> Subtask:
+        st = Subtask.new(description, depends_on)
+        self.subtasks.append(st)
+        self.touch()
+        return st
+
+    def find_subtask(self, subtask_id: str) -> Subtask | None:
+        for st in self.subtasks:
+            if st.id == subtask_id or st.id.startswith(subtask_id):
+                return st
+        return None
+
+    def set_subtask_status(self, subtask_id: str, status: SubtaskStatus) -> bool:
+        st = self.find_subtask(subtask_id)
+        if st is None:
+            return False
+        st.status = status
+        self.touch()
+        return True
+
+    def add_attempt(self, attempt: AttemptLog) -> None:
+        self.attempts.append(attempt)
+        if attempt.subtask_id:
+            st = self.find_subtask(attempt.subtask_id)
+            if st is not None and attempt.id not in st.attempts:
+                st.attempts.append(attempt.id)
+        self.touch()
+
+    def complete(self) -> None:
+        self.status = GoalStatus.COMPLETED
+        self.touch()
+
+    def abandon(self, reason: str = "") -> None:
+        self.status = GoalStatus.ABANDONED
+        if reason:
+            self.notes = (self.notes + f"\nabandoned: {reason}").strip()
+        self.touch()
+
+    # ── Serialization ──────────────────────────────────────────────
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "intent": self.intent,
+            "cwd": self.cwd,
+            "status": self.status.value,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "subtasks": [st.to_dict() for st in self.subtasks],
+            "attempts": [a.to_dict() for a in self.attempts],
+            "forge_project_id": self.forge_project_id,
+            "notes": self.notes,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> "Goal":
+        return cls(
+            id=str(d.get("id") or uuid.uuid4()),
+            intent=str(d.get("intent", "")),
+            cwd=str(d.get("cwd", "")),
+            status=GoalStatus(d.get("status", "active")),
+            created_at=str(d.get("created_at") or datetime.now(timezone.utc).isoformat()),
+            updated_at=str(d.get("updated_at") or datetime.now(timezone.utc).isoformat()),
+            subtasks=[Subtask.from_dict(s) for s in (d.get("subtasks") or [])],
+            attempts=[AttemptLog.from_dict(a) for a in (d.get("attempts") or [])],
+            forge_project_id=d.get("forge_project_id"),
+            notes=str(d.get("notes", "")),
+        )
+
+    # ── Display ────────────────────────────────────────────────────
+
+    def summary_line(self) -> str:
+        """One-liner for the picker / statusline."""
+        counts = self.subtask_counts()
+        n_done = counts.get("done", 0)
+        n_total = len(self.subtasks)
+        progress = f"{n_done}/{n_total}" if n_total else "—"
+        intent_short = self.intent[:60].replace("\n", " ")
+        return (
+            f"[{self.short_id()}] {self.status.value:9}  "
+            f"{progress:>5}  {intent_short!r}"
+        )
+
+    def render_for_prompt(self) -> str:
+        """Block injected into the system prompt by Phase 2.4. Compact
+        so it doesn't blow context."""
+        lines = [
+            "### Active goal",
+            f"  ID: {self.short_id()}",
+            f"  Intent: {self.intent}",
+            f"  Cwd: {self.cwd}",
+        ]
+        if self.subtasks:
+            n_done = sum(1 for s in self.subtasks if s.status == SubtaskStatus.DONE)
+            lines.append(f"  Subtasks ({n_done}/{len(self.subtasks)} done):")
+            glyph = {
+                SubtaskStatus.DONE:        "✓",
+                SubtaskStatus.IN_PROGRESS: "◐",
+                SubtaskStatus.PENDING:     "☐",
+                SubtaskStatus.BLOCKED:     "⊘",
+            }
+            for st in self.subtasks:
+                lines.append(f"    {glyph[st.status]} {st.description}")
+        else:
+            # Phase 2.5 nudge — agent's first move on a fresh goal
+            # should be DecomposeGoal so the tree persists.
+            lines.append("  Subtasks: none yet.")
+            lines.append(
+                "  → As your FIRST tool call, call DecomposeGoal with the "
+                "subtask breakdown. That persists the plan across turns "
+                "and sessions (unlike TodoWrite which is per-turn)."
+            )
+        if self.attempts:
+            recent_reward = next(
+                (a.reward for a in reversed(self.attempts) if a.reward is not None),
+                None,
+            )
+            if recent_reward is not None:
+                lines.append(f"  Last attempt reward: {recent_reward:+.2f}")
+        lines.append("  Pick up where the last turn left off — don't restart the plan.")
+        return "\n".join(lines)