monoco-toolkit 0.3.2__py3-none-any.whl → 0.3.3__py3-none-any.whl

monoco/features/scheduler/worker.py

@@ -0,0 +1,129 @@
+from typing import Optional
+from .models import RoleTemplate
+
+
+class Worker:
+    """
+    Represents an active or pending agent session assigned to a specific role and issue.
+    """
+
+    def __init__(self, role: RoleTemplate, issue_id: str):
+        self.role = role
+        self.issue_id = issue_id
+        self.status = "pending"  # pending, running, suspended, terminated
+        self.process_id: Optional[int] = None
+        self._process = None
+
+    def start(self, context: Optional[dict] = None):
+        """
+        Start the worker session asynchronously.
+        """
+        # Allow restart if not currently running
+        if self.status == "running":
+            return
+
+        print(f"Starting worker {self.role.name} for issue {self.issue_id}")
+
+        try:
+            self._execute_work(context)
+            self.status = "running"
+        except Exception as e:
+            print(f"Worker failed to start: {e}")
+            self.status = "failed"
+            raise
+
+    def _execute_work(self, context: Optional[dict] = None):
+        import subprocess
+        import sys
+
+        # Prepare the prompt
+        if self.role.name == "drafter" and context:
+            issue_type = context.get("type", "feature")
+            description = context.get("description", "No description")
+            prompt = (
+                f"You are a Drafter in the Monoco project.\n\n"
+                f"Task: Create a new {issue_type} issue based on this request: {description}\n\n"
+                "Constraints:\n"
+                "1. Use 'monoco issue create' to generate the file.\n"
+                "2. Use 'monoco issue update' or direct file editing to enrich Objective and Tasks.\n"
+                "3. IMPORTANT: Once the issue file is created and filled with high-quality content, EXIT search or interactive mode immediately.\n"
+                "4. Do not perform any other development tasks."
+            )
+        else:
+            prompt = (
+                f"{self.role.system_prompt}\n\n"
+                f"Issue context: {self.issue_id}\n"
+                f"Goal: {self.role.goal}\n"
+            )
+            if context and "description" in context:
+                prompt += f"Specific Task: {context['description']}"
+
+        engine = self.role.engine
+
+        print(f"[{self.role.name}] Engine: {engine}")
+        print(f"[{self.role.name}] Goal: {self.role.goal}")
+
+        try:
+            # Execute CLI agent with YOLO mode
+            engine_args = (
+                [engine, "-y", prompt] if engine == "gemini" else [engine, prompt]
+            )
+
+            self._process = subprocess.Popen(
+                engine_args, stdout=sys.stdout, stderr=sys.stderr, text=True
+            )
+            self.process_id = self._process.pid
+
+            # DO NOT WAIT HERE.
+            # The scheduler/monitoring loop is responsible for checking status.
+
+        except FileNotFoundError:
+            raise RuntimeError(
+                f"Agent engine '{engine}' not found. Please ensure it is installed and in PATH."
+            )
+        except Exception as e:
+            print(f"[{self.role.name}] Process Error: {e}")
+            raise
+
+    def poll(self) -> str:
+        """
+        Check process status. Returns current worker status.
+        Updates self.status if process has finished.
+        """
+        if not self._process:
+            return self.status
+
+        returncode = self._process.poll()
+        if returncode is None:
+            return "running"
+
+        if returncode == 0:
+            self.status = "completed"
+        else:
+            self.status = "failed"
+
+        return self.status
+
+    def wait(self):
+        """
+        Block until process finishes.
+        """
+        if self._process:
+            self._process.wait()
+            self.poll()  # Update status
+
+    def stop(self):
+        """
+        Stop the worker session.
+        """
+        if self.status == "terminated":
+            return
+
+        print(f"Stopping worker {self.role.name} for issue {self.issue_id}")
+        self.status = "terminated"
+        self.process_id = None
+
+    def __repr__(self):
+        return (
+            f"<Worker role={self.role.name} issue={self.issue_id} status={self.status}>"
+        )

monoco/main.py

@@ -166,6 +166,10 @@ app.add_typer(config_cmd.app, name="config", help="Manage configuration")
 app.add_typer(project_cmd.app, name="project", help="Manage projects")
 app.add_typer(workspace_cmd.app, name="workspace", help="Manage workspace")
 
+from monoco.features.scheduler import cli as scheduler_cmd
+
+app.add_typer(scheduler_cmd.app, name="agent", help="Manage agent sessions")
+
 
 from monoco.daemon.commands import serve
 

{monoco_toolkit-0.3.2.dist-info → monoco_toolkit-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monoco-toolkit
-Version: 0.3.2
+Version: 0.3.3
 Summary: Agent Native Toolkit for Monoco - Task Management & Kanban for AI Agents
 Project-URL: Homepage, https://monoco.io
 Project-URL: Repository, https://github.com/IndenScale/Monoco

{monoco_toolkit-0.3.2.dist-info → monoco_toolkit-0.3.3.dist-info}/RECORD

@@ -1,29 +1,24 @@
-monoco/main.py,sha256=_ZhokFhmYF1NNHubuVr9gZ_HLg6AaZPWMppnUESbpwA,5346
+monoco/main.py,sha256=YGQ-A3UlD12cyvJscFfV_BFpeHxlm_LJn_WVIaLrINc,5484
 monoco/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monoco/cli/project.py,sha256=FqLaDD3hiWxa0_TKzxEF7PYH9RPsvmLyjO3NYVckgGs,2737
 monoco/cli/workspace.py,sha256=1TVVS835XyirLDvBGQXSblIaYVhe2Pk9EpORDvcktyk,1538
 monoco/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monoco/core/config.py,sha256=DsxkUaHbKK17JuMzcYLVBWnLhhs78HC_gday2fyx6sw,12250
+monoco/core/config.py,sha256=M9F5De2FUgaIxFwqZBoJUXsMsph31rNh-4U-k_9rUHA,13543
 monoco/core/execution.py,sha256=7522s7uVWiNdMKtWlIb8JHzbAcJgLVuxUFp_6VmhWNQ,1801
 monoco/core/feature.py,sha256=bcK0C1CaQgNLcdMF0RuniaaQRCYSA-0JdOpQz9W_1xM,1968
 monoco/core/git.py,sha256=d3A8L30nlEj0F1pwSHk_cOoRYi1dMCiZc7KD70ViMyw,8335
 monoco/core/hooks.py,sha256=QY4c74LIYDtcjtWYax1PrK5CtVNKYTfVVVBOj-SCulo,1826
 monoco/core/injection.py,sha256=zs9RpXaBfwP-fbwOU_X2nm-AH94tQN9tVWXNtV4tCYM,6887
-monoco/core/integrations.py,sha256=GOWwDceEuhU6Q1nX8vvyGQ7s_kzuW0lKK23nEFkzCT0,7912
+monoco/core/integrations.py,sha256=ifSz7I87DXHF-eHLyXRN3pY1-Kh8IjvMyIrG9iogGpw,7744
 monoco/core/lsp.py,sha256=GOrHzubkMWS3iBpP4H2fTFW-0JXa6D2YlU0ZEhp5zmY,2018
 monoco/core/output.py,sha256=ZlUydZ65FIP5a32_eESIIvMrhcSwghIqZ3N23OSx6Ss,3878
 monoco/core/registry.py,sha256=1m9wvkcqWqrTcARt-jUGHH1BEYMvp0NJGRkq-uduJeg,1167
 monoco/core/setup.py,sha256=YUIhzqZwjEeH7zGZm9SPA-OhgTISJtA6ByNFCGBznUU,11487
 monoco/core/skills.py,sha256=KeVN09KIcRiksjJ91AggJbN_EvjRQfMGqd_hUQfUjes,16168
 monoco/core/state.py,sha256=dfoTH1Sj_TSjtTEXuv4w0ZOp_Fd30XNymVSZo30Xshg,1820
-monoco/core/sync.py,sha256=DJXnWM_LxN36VniTUS5axFiAhVXYHbxLbI1uaUvV1JU,8750
+monoco/core/sync.py,sha256=1p37pTfGBanogzcLhdTfMTxDqq79B5iiwiPS4fiuQaA,8378
 monoco/core/telemetry.py,sha256=GQDbtgrZwAL1ZpjgbJZuawbTyH6J0NjMXMi4ogq-Ang,2915
 monoco/core/workspace.py,sha256=H_PHD5A0HZFq841u1JtLoFjkXdQg9D6x6I7QcFtJge4,3000
-monoco/core/agent/__init__.py,sha256=iU3wac9iYecA1M2jaYnnPjU9wANdAS7B-jRAuT5gCo4,38
-monoco/core/agent/action.py,sha256=qkQGJERhL4N5MSuwDivn8NAw4sMhEa346huGtqNyFTM,5295
-monoco/core/agent/adapters.py,sha256=q6obVcXve46mVNBaSCBRFRYs8gImv6Y2gAJVv173Z6w,4376
-monoco/core/agent/protocol.py,sha256=eB0OiMjDQu1DOoeVqb_PpHsMyPy2LdNenNyt4vJ9qbQ,798
-monoco/core/agent/state.py,sha256=Z8qqY7loms5nt3524_TrEMmlpnurxf0aHfiCT1FgvDI,3385
 monoco/core/resources/en/AGENTS.md,sha256=vf9z43UU-LPwYKPWCrtw8TpWrmkeZ6zfMyHP4Q9JqdQ,1178
 monoco/core/resources/en/SKILL.md,sha256=wBXNpPqATOxO8TGiOM8S091gMNZ8du_WhQubO6TfNyg,3504
 monoco/core/resources/zh/AGENTS.md,sha256=KBNZSCPBIals6jDdvG5wJgjZuswi_1nKljggJSMtfy8,1156
@@ -46,16 +41,18 @@ monoco/features/i18n/resources/en/SKILL.md,sha256=Z8fAAqeMvpLDw1D_9AzZIykS5-HLVM
 monoco/features/i18n/resources/zh/AGENTS.md,sha256=lKkwLLCADRH7UDq9no4eQY2sRfJrb64JoZ_HNved8vA,175
 monoco/features/i18n/resources/zh/SKILL.md,sha256=Wynk7zVBW7CO0_6AEQNUvlD_3eMW_7EPnzEn9QUaiDs,1884
 monoco/features/issue/adapter.py,sha256=4dzKg4-0XH63uORoh8qcolvKxJR6McBDIYxYEcZJJkA,1204
-monoco/features/issue/commands.py,sha256=ndBE_3tP4CZK45lqAbsGpeopzvebMZKeIezZchTGIsc,37353
-monoco/features/issue/core.py,sha256=WoWZRpw7o9f6ERqqIgD35c-SYD7Jv1aTsJVj6ljPz9E,50369
-monoco/features/issue/linter.py,sha256=DQ3UruGUUMZu63EFn71eczoFDoqj31JxHHaRR3Ej6O8,21067
+monoco/features/issue/commands.py,sha256=V5EVdmin-JPoqdV9-vrbKcZ7HXWHZt-zq_mM1kqFVu0,38163
+monoco/features/issue/core.py,sha256=kRyUbYqEBno0Zoogq7dMIcQv5M0QIRSlptvzp0pfImE,51302
+monoco/features/issue/domain_commands.py,sha256=eatSF_uZp4nGpVr2PIgb00MWfEBm0OnyAd4JvUJEAAA,1535
+monoco/features/issue/domain_service.py,sha256=bEs_WXOWmotgIR-lGwyWekF4nonvjsgrK1YG3pyVfwk,2564
+monoco/features/issue/linter.py,sha256=lBXWj3T9OK4ysU33Mr-gzO7wcxXxl4Mu_IMgv4ePwjQ,26502
 monoco/features/issue/migration.py,sha256=i0xlxZjrpmuHGHOAIN4iu31EwwVIvZn7yjveS-kU22c,4896
 monoco/features/issue/models.py,sha256=7oIMxvUEfe00n7wni9bZgKU2e9404flvArixbLQ95Dg,5902
 monoco/features/issue/monitor.py,sha256=vZN0TbR3V5fHKHRGkIhimO6UwWcwYjDHQs2qzjEG174,3549
-monoco/features/issue/validator.py,sha256=Rbn5M_RLEHVPi5n0Y19-VCWZvVlRWcCRFYRbsw-Oc-I,24732
+monoco/features/issue/validator.py,sha256=8N921_3B2Cd3hFjRRMFPwCZh9Pbc6CsGXFRt28X9KLQ,26798
 monoco/features/issue/domain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monoco/features/issue/domain/lifecycle.py,sha256=oIuLYTVy1RRHGngAzbNU4kTWOHMBhjuw_TuYCwNqMJw,4991
-monoco/features/issue/domain/models.py,sha256=eo5Ks7VzWDQsqzuu9gcBuxIafvfqnzUDNDG9wbaghsc,5797
+monoco/features/issue/domain/models.py,sha256=2vuSAGaFrbAEkQapwkGG_T8cHlsmARN71fTA44PIVSM,5850
 monoco/features/issue/domain/parser.py,sha256=axfB9BjY-m4DQqYwTQBm_38plOidZaDqFtsIejW_kYI,9095
 monoco/features/issue/domain/workspace.py,sha256=nyTEFNmpLPuX7nssMCBiFI1XBhY9zbqG877Ppp_s0Fg,3658
 monoco/features/issue/engine/__init__.py,sha256=-SBvzjlZJz0O-IB1c95d9pbhr3lydJNLq2vhnfkZ8PQ,747
@@ -68,6 +65,15 @@ monoco/features/issue/resources/en/AGENTS.md,sha256=7lMJdLhokispHVTrViIyMaz5TOJ8
 monoco/features/issue/resources/en/SKILL.md,sha256=M5khTJdraQenX0tf7RHOVcqyKHC285qwDzWdsCJ7XPI,4032
 monoco/features/issue/resources/zh/AGENTS.md,sha256=veb22lU0qindYcsNsuGLqzpBEjExCPDOkX5Q39OjZz0,1113
 monoco/features/issue/resources/zh/SKILL.md,sha256=XFE33cCCos0U1IVNkMhU7fGuqVqfxo_FNKdp1aScaoM,5055
+monoco/features/scheduler/__init__.py,sha256=hvE9A14qFTeTYbWlK9iMRdXIFLMBuG8724GEZzFTHB8,483
+monoco/features/scheduler/cli.py,sha256=peRfALi_4etXpyn9SKl98lNJhUdNWlgX1GVo0xXSlLI,5859
+monoco/features/scheduler/config.py,sha256=4kC9ll-bFd8jldzxF29D94inn4HR2DkDEO-4u0LqjXA,1175
+monoco/features/scheduler/defaults.py,sha256=4Ne3RpF7gZ46BmHtF0hC8wYkuCIkDSuKB7hGnHhGXms,2208
+monoco/features/scheduler/manager.py,sha256=PmNKqfktgrdpUwE-jPE_WX3IvzZat0JKdEcmzse08-0,1680
+monoco/features/scheduler/models.py,sha256=rb8rx8t_TD5ilUC6xU3jvK0sud7YUZE_iEdes9Np8R0,877
+monoco/features/scheduler/reliability.py,sha256=AGs87DPkAa0IMYtQ5x7dpAOeTB4NTRh37FJsiqZY9Y4,3624
+monoco/features/scheduler/session.py,sha256=V1xFXA65BaERhBwRYIecaye2TjDtFvAzuIy2gZ68ag8,2954
+monoco/features/scheduler/worker.py,sha256=4eFyC3118ZuUnmiFVe3nSTUsIOn-N2uPXpCP_1FSTRg,4238
 monoco/features/skills/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monoco/features/skills/core.py,sha256=BXVvMot8E457-pj9U19lPHypBVhdLQRsx0zEAXJxpGY,3436
 monoco/features/spike/adapter.py,sha256=ZIpw-xNVoA2IIP18dbR-dmQGbQmK5ua_P-uGXuDjCeI,1021
@@ -77,8 +83,8 @@ monoco/features/spike/resources/en/AGENTS.md,sha256=NG3CMnlDk_0J8hnRUcueAM9lgIQr
 monoco/features/spike/resources/en/SKILL.md,sha256=qKDcVh0D3pDRvfNLh1Bzo4oQU3obpl4tqdlzxeiWYMk,1911
 monoco/features/spike/resources/zh/AGENTS.md,sha256=5RHNl7fc3RdYYTFH483ojJl_arGPKkyYziOuGgFbqqg,290
 monoco/features/spike/resources/zh/SKILL.md,sha256=Q82e9lCQOAYIwBs5rGnvlVUDq7bp0pz8yvO10KTWFYQ,1710
-monoco_toolkit-0.3.2.dist-info/METADATA,sha256=9Xyk-ImLkR4WvBAz6eQb8_N-QZiJ7TPu27P3u48Y35c,4866
-monoco_toolkit-0.3.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-monoco_toolkit-0.3.2.dist-info/entry_points.txt,sha256=iYj7FWYBdtClU15-Du1skqD0s6SFSIhJvxJ29VWp8ng,43
-monoco_toolkit-0.3.2.dist-info/licenses/LICENSE,sha256=ACAGGjV6aod4eIlVUTx1q9PZbnZGN5bBwkSs9RHj83s,1071
-monoco_toolkit-0.3.2.dist-info/RECORD,,
+monoco_toolkit-0.3.3.dist-info/METADATA,sha256=GXPy1vr5MxL9afZc7r-vvUUOofmjiShBZe3qA9X9MHc,4866
+monoco_toolkit-0.3.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+monoco_toolkit-0.3.3.dist-info/entry_points.txt,sha256=iYj7FWYBdtClU15-Du1skqD0s6SFSIhJvxJ29VWp8ng,43
+monoco_toolkit-0.3.3.dist-info/licenses/LICENSE,sha256=ACAGGjV6aod4eIlVUTx1q9PZbnZGN5bBwkSs9RHj83s,1071
+monoco_toolkit-0.3.3.dist-info/RECORD,,

monoco/core/agent/__init__.py

@@ -1,3 +0,0 @@
-"""
-Monoco Agent Execution Layer.
-"""

monoco/core/agent/action.py

@@ -1,168 +0,0 @@
-import re
-import yaml
-from pathlib import Path
-from typing import Dict, List, Optional, Any
-from pydantic import BaseModel
-
-
-class ActionContext(BaseModel):
-    """Context information for matching actions."""
-
-    id: Optional[str] = None
-    type: Optional[str] = None
-    stage: Optional[str] = None
-    status: Optional[str] = None
-    file_path: Optional[str] = None
-    project_id: Optional[str] = None
-
-
-class ActionWhen(BaseModel):
-    """Conditions under which an action should be displayed/active."""
-
-    idMatch: Optional[str] = None
-    typeMatch: Optional[str] = None
-    stageMatch: Optional[str] = None
-    statusMatch: Optional[str] = None
-    fileMatch: Optional[str] = None
-
-    def matches(self, context: ActionContext) -> bool:
-        """Evaluate if the context matches these criteria."""
-        if self.idMatch and context.id and not re.match(self.idMatch, context.id):
-            return False
-        if (
-            self.typeMatch
-            and context.type
-            and not re.match(self.typeMatch, context.type)
-        ):
-            return False
-        if (
-            self.stageMatch
-            and context.stage
-            and not re.match(self.stageMatch, context.stage)
-        ):
-            return False
-        if (
-            self.statusMatch
-            and context.status
-            and not re.match(self.statusMatch, context.status)
-        ):
-            return False
-        if (
-            self.fileMatch
-            and context.file_path
-            and not re.match(self.fileMatch, context.file_path)
-        ):
-            return False
-        return True
-
-
-class PromptyAction(BaseModel):
-    name: str
-    description: str
-    version: Optional[str] = "1.0.0"
-    authors: List[str] = []
-    model: Dict[str, Any] = {}
-    inputs: Dict[str, Any] = {}
-    outputs: Dict[str, Any] = {}
-    template: str
-    when: Optional[ActionWhen] = None
-
-    # Monoco specific metadata
-    path: Optional[str] = None
-    provider: Optional[str] = None  # Derived from model.api or explicitly set
-
-
-class ActionRegistry:
-    def __init__(self, project_root: Optional[Path] = None):
-        self.project_root = project_root
-        self._actions: List[PromptyAction] = []
-
-    def scan(self) -> List[PromptyAction]:
-        """Scan user global and project local directories for .prompty files."""
-        self._actions = []
-
-        # 1. User Global: ~/.monoco/actions/
-        user_dir = Path.home() / ".monoco" / "actions"
-        self._scan_dir(user_dir)
-
-        # 2. Project Local: {project_root}/.monoco/actions/
-        if self.project_root:
-            project_dir = self.project_root / ".monoco" / "actions"
-            self._scan_dir(project_dir)
-
-        return self._actions
-
-    def _scan_dir(self, directory: Path):
-        if not directory.exists():
-            return
-
-        for prompty_file in directory.glob("*.prompty"):
-            try:
-                action = self._load_action(prompty_file)
-                if action:
-                    self._actions.append(action)
-            except Exception as e:
-                print(f"Failed to load action {prompty_file}: {e}")
-
-    def _load_action(self, file_path: Path) -> Optional[PromptyAction]:
-        content = file_path.read_text(encoding="utf-8")
-
-        # Prompty Parser (Standard YAML Frontmatter + Body)
-        # We look for the first --- and the second ---
-        parts = re.split(r"^---\s*$", content, maxsplit=2, flags=re.MULTILINE)
-
-        if len(parts) < 3:
-            return None
-
-        frontmatter_raw = parts[1]
-        body = parts[2].strip()
-
-        try:
-            meta = yaml.safe_load(frontmatter_raw)
-            if not meta or "name" not in meta:
-                # Use filename as fallback name if missing? Prompty usually requires name.
-                if not meta:
-                    meta = {}
-                meta["name"] = meta.get("name", file_path.stem)
-
-            # Map Prompty 'when' if present
-            when_data = meta.get("when")
-            when = ActionWhen(**when_data) if when_data else None
-
-            action = PromptyAction(
-                name=meta["name"],
-                description=meta.get("description", ""),
-                version=meta.get("version"),
-                authors=meta.get("authors", []),
-                model=meta.get("model", {}),
-                inputs=meta.get("inputs", {}),
-                outputs=meta.get("outputs", {}),
-                template=body,
-                when=when,
-                path=str(file_path.absolute()),
-                provider=meta.get("provider") or meta.get("model", {}).get("api"),
-            )
-            return action
-
-        except Exception as e:
-            print(f"Invalid Prompty in {file_path}: {e}")
-            return None
-
-    def list_available(
-        self, context: Optional[ActionContext] = None
-    ) -> List[PromptyAction]:
-        if not self._actions:
-            self.scan()
-
-        if not context:
-            return self._actions
-
-        return [a for a in self._actions if not a.when or a.when.matches(context)]
-
-    def get(self, name: str) -> Optional[PromptyAction]:
-        if not self._actions:
-            self.scan()
-        for a in self._actions:
-            if a.name == name:
-                return a
-        return None

monoco/core/agent/adapters.py

@@ -1,133 +0,0 @@
-"""
-CLI Adapters for Agent Frameworks.
-"""
-
-import shutil
-from typing import List
-from pathlib import Path
-from .protocol import AgentClient
-
-
-class BaseCLIClient:
-    def __init__(self, executable: str):
-        self._executable = executable
-
-    @property
-    def name(self) -> str:
-        return self._executable
-
-    async def available(self) -> bool:
-        return shutil.which(self._executable) is not None
-
-    def _build_prompt(self, prompt: str, context_files: List[Path]) -> str:
-        """Concatenate prompt and context files."""
-        # Inject Language Rule
-        try:
-            from monoco.core.config import get_config
-
-            settings = get_config()
-            lang = settings.i18n.source_lang
-            if lang:
-                prompt = f"{prompt}\n\n[SYSTEM: LANGUAGE CONSTRAINT]\nThe project source language is '{lang}'. You MUST use '{lang}' for all thinking and reporting unless explicitly instructed otherwise."
-        except Exception:
-            pass
-
-        full_prompt = [prompt]
-        if context_files:
-            full_prompt.append("\n\n--- CONTEXT FILES ---")
-            for file_path in context_files:
-                try:
-                    full_prompt.append(f"\nFile: {file_path}")
-                    full_prompt.append("```")
-                    # Read file content safely
-                    full_prompt.append(
-                        file_path.read_text(encoding="utf-8", errors="replace")
-                    )
-                    full_prompt.append("```")
-                except Exception as e:
-                    full_prompt.append(f"Error reading {file_path}: {e}")
-            full_prompt.append("--- END CONTEXT ---\n")
-        return "\n".join(full_prompt)
-
-    async def _run_command(self, args: List[str]) -> str:
-        """Run the CLI command and return stdout."""
-        # Using synchronous subprocess in async function for now
-        # Ideally this should use asyncio.create_subprocess_exec
-        import asyncio
-
-        proc = await asyncio.create_subprocess_exec(
-            *args, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
-        )
-
-        stdout, stderr = await proc.communicate()
-
-        if proc.returncode != 0:
-            error_msg = stderr.decode().strip()
-            raise RuntimeError(
-                f"Agent CLI failed (code {proc.returncode}): {error_msg}"
-            )
-
-        return stdout.decode().strip()
-
-
-class GeminiClient(BaseCLIClient, AgentClient):
-    """Adapter for Google Gemini CLI."""
-
-    def __init__(self):
-        super().__init__("gemini")
-
-    async def execute(self, prompt: str, context_files: List[Path] = []) -> str:
-        full_prompt = self._build_prompt(prompt, context_files)
-        # Usage: gemini "prompt"
-        return await self._run_command([self._executable, full_prompt])
-
-
-class ClaudeClient(BaseCLIClient, AgentClient):
-    """Adapter for Anthropic Claude CLI."""
-
-    def __init__(self):
-        super().__init__("claude")
-
-    async def execute(self, prompt: str, context_files: List[Path] = []) -> str:
-        full_prompt = self._build_prompt(prompt, context_files)
-        # Usage: claude -p "prompt"
-        return await self._run_command([self._executable, "-p", full_prompt])
-
-
-class QwenClient(BaseCLIClient, AgentClient):
-    """Adapter for Alibaba Qwen CLI."""
-
-    def __init__(self):
-        super().__init__("qwen")
-
-    async def execute(self, prompt: str, context_files: List[Path] = []) -> str:
-        full_prompt = self._build_prompt(prompt, context_files)
-        # Usage: qwen "prompt"
-        return await self._run_command([self._executable, full_prompt])
-
-
-class KimiClient(BaseCLIClient, AgentClient):
-    """Adapter for Moonshot Kimi CLI."""
-
-    def __init__(self):
-        super().__init__("kimi")
-
-    async def execute(self, prompt: str, context_files: List[Path] = []) -> str:
-        full_prompt = self._build_prompt(prompt, context_files)
-        # Usage: kimi "prompt"
-        return await self._run_command([self._executable, full_prompt])
-
-
-_ADAPTERS = {
-    "gemini": GeminiClient,
-    "claude": ClaudeClient,
-    "qwen": QwenClient,
-    "kimi": KimiClient,
-}
-
-
-def get_agent_client(name: str) -> AgentClient:
-    """Factory to get agent client by name."""
-    if name not in _ADAPTERS:
-        raise ValueError(f"Unknown agent provider: {name}")
-    return _ADAPTERS[name]()

monoco/core/agent/protocol.py

@@ -1,32 +0,0 @@
-"""
-Protocol definition for Agent Clients.
-"""
-
-from typing import Protocol, List
-from pathlib import Path
-
-
-class AgentClient(Protocol):
-    """Protocol for interacting with CLI-based agents."""
-
-    @property
-    def name(self) -> str:
-        """Name of the agent provider (e.g. 'gemini', 'claude')."""
-        ...
-
-    async def available(self) -> bool:
-        """Check if the agent is available in the current environment."""
-        ...
-
-    async def execute(self, prompt: str, context_files: List[Path] = []) -> str:
-        """
-        Execute a prompt against the agent.
-
-        Args:
-            prompt: The main instructions.
-            context_files: List of files to provide as context.
-
-        Returns:
-            The raw string response from the agent.
-        """
-        ...

monoco/core/agent/state.py

@@ -1,106 +0,0 @@
-"""
-Agent State Management.
-
-Handles persistence and retrieval of agent availability state.
-"""
-
-import yaml
-import logging
-from pathlib import Path
-from datetime import datetime, timezone
-from typing import Dict, Optional
-from pydantic import BaseModel
-
-logger = logging.getLogger("monoco.core.agent.state")
-
-
-class AgentProviderState(BaseModel):
-    available: bool
-    path: Optional[str] = None
-    error: Optional[str] = None
-    latency_ms: Optional[int] = None
-
-
-class AgentState(BaseModel):
-    last_checked: datetime
-    providers: Dict[str, AgentProviderState]
-
-    @property
-    def is_stale(self) -> bool:
-        """Check if the state is older than 7 days."""
-        delta = datetime.now(timezone.utc) - self.last_checked
-        return delta.days > 7
-
-
-class AgentStateManager:
-    def __init__(self, state_path: Path = Path.home() / ".monoco" / "agent_state.yaml"):
-        self.state_path = state_path
-        self._state: Optional[AgentState] = None
-
-    def load(self) -> Optional[AgentState]:
-        """Load state from file, returning None if missing or invalid."""
-        if not self.state_path.exists():
-            return None
-
-        try:
-            with open(self.state_path, "r") as f:
-                data = yaml.safe_load(f)
-                if not data:
-                    return None
-                # Handle ISO string to datetime conversion if needed provided by Pydantic mostly
-                return AgentState(**data)
-        except Exception as e:
-            logger.warning(f"Failed to load agent state: {e}")
-            return None
-
-    def get_or_refresh(self, force: bool = False) -> AgentState:
-        """Get current state, refreshing if missing, stale, or forced."""
-        if not force:
-            self._state = self.load()
-            if self._state and not self._state.is_stale:
-                return self._state
-
-        return self.refresh()
-
-    def refresh(self) -> AgentState:
-        """Run diagnostics on all integrations and update state."""
-        logger.info("Refreshing agent state...")
-
-        from monoco.core.integrations import get_all_integrations
-        from monoco.core.config import get_config
-
-        # Load config to get possible overrides
-        # Determine root (hacky for now, should be passed)
-        root = Path.cwd()
-        config = get_config(str(root))
-
-        integrations = get_all_integrations(
-            config_overrides=config.agent.integrations, enabled_only=True
-        )
-
-        providers = {}
-        for key, integration in integrations.items():
-            if not integration.bin_name:
-                continue  # Skip integrations that don't have a binary component
-
-            health = integration.check_health()
-            providers[key] = AgentProviderState(
-                available=health.available,
-                path=health.path,
-                error=health.error,
-                latency_ms=health.latency_ms,
-            )
-
-        state = AgentState(last_checked=datetime.now(timezone.utc), providers=providers)
-
-        # Save state
-        self.state_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(self.state_path, "w") as f:
-            yaml.dump(state.model_dump(mode="json"), f)
-
-        self._state = state
-        return state
-
-    def _find_script(self) -> Optional[Path]:
-        """[Deprecated] No longer used."""
-        return None