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

monoco/features/scheduler/models.py

@@ -0,0 +1,24 @@
+from typing import List
+from pydantic import BaseModel, Field
+
+
+class RoleTemplate(BaseModel):
+    name: str = Field(
+        ..., description="Unique identifier for the role (e.g., 'crafter')"
+    )
+    description: str = Field(..., description="Human-readable description of the role")
+    trigger: str = Field(
+        ..., description="Event that triggers this agent (e.g., 'issue.created')"
+    )
+    goal: str = Field(..., description="The primary goal/output of this agent")
+    tools: List[str] = Field(default_factory=list, description="List of allowed tools")
+    system_prompt: str = Field(
+        ..., description="The system prompt template for this agent"
+    )
+    engine: str = Field(
+        default="gemini", description="CLI agent engine (gemini/claude)"
+    )
+
+
+class SchedulerConfig(BaseModel):
+    roles: List[RoleTemplate] = Field(default_factory=list)

monoco/features/scheduler/reliability.py

@@ -0,0 +1,99 @@
+from .manager import SessionManager
+from .session import RuntimeSession
+from .defaults import DEFAULT_ROLES
+
+
+class ApoptosisManager:
+    """
+    Handles the 'Apoptosis' (Programmed Cell Death) lifecycle for agents.
+    Ensures that failing agents are killed, analyzed, and the environment is reset.
+    """
+
+    def __init__(self, session_manager: SessionManager):
+        self.session_manager = session_manager
+        # Find coroner role
+        self.coroner_role = next(
+            (r for r in DEFAULT_ROLES if r.name == "coroner"), None
+        )
+        if not self.coroner_role:
+            raise ValueError("Coroner role not defined!")
+
+    def check_health(self, session: RuntimeSession) -> bool:
+        """
+        Check if a session is healthy.
+        In a real implementation, this would check heartbeat, CPU usage, or token limits.
+        """
+        # Placeholder logic: Random failure or external flag?
+        # For now, always healthy unless explicitly marked 'crashed' (which we can simulate)
+        if hasattr(session, "simulate_crash") and session.simulate_crash:
+            return False
+        return True
+
+    def trigger_apoptosis(self, session_id: str):
+        """
+        Execute the full death and rebirth cycle.
+        """
+        session = self.session_manager.get_session(session_id)
+        if not session:
+            print(f"Session {session_id} not found for apoptosis.")
+            return
+
+        print(f"💀 [Apoptosis] Starting lifecycle for Session {session_id}")
+
+        # 1. Kill
+        self._kill(session)
+
+        # 2. Autopsy
+        try:
+            self._perform_autopsy(session)
+        except Exception as e:
+            print(f"⚠️ Autopsy failed: {e}")
+
+        # 3. Reset
+        self._reset_environment(session)
+
+        print(
+            f"✅ [Apoptosis] Task {session.model.issue_id} has been reset and analyzed."
+        )
+
+    def _kill(self, session: RuntimeSession):
+        print(f"🔪 Killing worker process for {session.model.id}...")
+        session.terminate()
+        session.model.status = "crashed"
+
+    def _perform_autopsy(self, victim_session: RuntimeSession):
+        print(
+            f"🔍 Performing autopsy on {victim_session.model.id} via Coroner agent..."
+        )
+
+        # Start a Coroner session
+        coroner_session = self.session_manager.create_session(
+            victim_session.model.issue_id, self.coroner_role
+        )
+
+        # Context for the coroner
+        context = {
+            "description": f"The previous agent session ({victim_session.model.id}) for role '{victim_session.model.role_name}' crashed. Please analyze the environment and the Issue {victim_session.model.issue_id}, then write a ## Post-mortem section in the issue file."
+        }
+
+        coroner_session.start(context=context)
+        print("📄 Coroner agent finished analysis.")
+
+    def _reset_environment(self, session: RuntimeSession):
+        print("🧹 Resetting environment (simulated git reset --hard)...")
+        # In real impl:
+        # import subprocess
+        # subprocess.run(["git", "reset", "--hard"], check=True)
+        pass
+
+    def _retry(self, session: RuntimeSession):
+        print("🔄 Reincarnating session...")
+        # Create a new session with the same role and issue
+        new_session = self.session_manager.create_session(
+            session.model.issue_id,
+            # We need to find the original role object.
+            # Simplified: assuming we can find it by name or pass it.
+            # For now, just placeholder.
+            session.worker.role,
+        )
+        new_session.start()

monoco/features/scheduler/session.py

@@ -0,0 +1,87 @@
+from datetime import datetime
+from typing import Optional
+from pydantic import BaseModel, Field
+from .worker import Worker
+
+
+class Session(BaseModel):
+    """
+    Represents a runtime session of a worker.
+    Persisted state of the session.
+    """
+
+    id: str = Field(..., description="Unique session ID (likely UUID)")
+    issue_id: str = Field(..., description="The Issue ID this session is working on")
+    role_name: str = Field(..., description="Name of the role employed")
+    status: str = Field(
+        default="pending", description="pending, running, suspended, terminated"
+    )
+    branch_name: str = Field(
+        ..., description="Git branch name associated with this session"
+    )
+    created_at: datetime = Field(default_factory=datetime.now)
+    updated_at: datetime = Field(default_factory=datetime.now)
+    # History could be a list of logs or pointers to git commits
+    # For now, let's keep it simple. The git log IS the history.
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
+class RuntimeSession:
+    """
+    The in-memory wrapper around the Session model and the active Worker.
+    """
+
+    def __init__(self, session_model: Session, worker: Worker):
+        self.model = session_model
+        self.worker = worker
+
+    def start(self, context: Optional[dict] = None):
+        print(
+            f"Session {self.model.id}: Starting worker on branch {self.model.branch_name}"
+        )
+        # In real impl, checking out branch happening here
+        self.model.status = "running"
+        self.model.updated_at = datetime.now()
+
+        try:
+            self.worker.start(context)
+            # Async mode: we assume it started running.
+            # Use poll or refresh_status to check later.
+            self.model.status = "running"
+        except Exception:
+            self.model.status = "failed"
+            raise
+        finally:
+            self.model.updated_at = datetime.now()
+
+    def refresh_status(self) -> str:
+        """
+        Polls the worker and updates the session model status.
+        """
+        worker_status = self.worker.poll()
+        self.model.status = worker_status
+        self.model.updated_at = datetime.now()
+        return worker_status
+
+    def suspend(self):
+        print(f"Session {self.model.id}: Suspending worker")
+        self.worker.stop()
+        self.model.status = "suspended"
+        self.model.updated_at = datetime.now()
+        # In real impl, ensure git commit of current state?
+
+    def resume(self):
+        print(f"Session {self.model.id}: Resuming worker")
+        self.worker.start()  # In real impl, might need to re-init process
+
+        # Async mode: assume running
+        self.model.status = "running"
+        self.model.updated_at = datetime.now()
+
+    def terminate(self):
+        print(f"Session {self.model.id}: Terminating")
+        self.worker.stop()
+        self.model.status = "terminated"
+        self.model.updated_at = datetime.now()

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.1.dist-info → monoco_toolkit-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monoco-toolkit
-Version: 0.3.1
+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.1.dist-info → monoco_toolkit-0.3.3.dist-info}/RECORD

@@ -1,33 +1,28 @@
-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=3TpCLNC1s_lIbDfJJBRmmROMoy9sZXu8BOag8M9NXI0,327
-monoco/core/resources/en/SKILL.md,sha256=1PrBqCgjDxT1LMSeu11BzlMhfboo_UlgZxdzBm7Tp9c,2161
-monoco/core/resources/zh/AGENTS.md,sha256=pGQOLt8mcRygJotd5oC8l9604hikQoUiS99QsHCe-UM,298
-monoco/core/resources/zh/SKILL.md,sha256=8py8tD7s23cw2srKFnTjLO_miyuGXb3NLyEbk5gchqA,1886
+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
+monoco/core/resources/zh/SKILL.md,sha256=1D8_FqzDVqowZWk4Qkyx4me53NTd8qihP20gaCH6gJY,3153
 monoco/daemon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monoco/daemon/app.py,sha256=tAtLxzw_aRzU0r6Bk9lhshaCyqZRkQKUJmg5FDi7-1c,15431
 monoco/daemon/commands.py,sha256=2AGsqDZ0edg34KuAGZrTvKlJZ1fhxNXgus7vGn2km4c,1115
@@ -40,22 +35,24 @@ monoco/features/config/commands.py,sha256=i6_fKhSGLeO8RCbWrYKxelFgaHWcPiQERS2uxU
 monoco/features/i18n/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monoco/features/i18n/adapter.py,sha256=-ifDKQ7UH8tDoOdB_fSKoIrNRJROIPNuzZor2FPJVfo,932
 monoco/features/i18n/commands.py,sha256=NJ2lZRRjiTW-3UbqxhEKURdWSDxQPkfnBAUgnwoVCL8,8416
-monoco/features/i18n/core.py,sha256=MZPn6dJCj9CYy1gihHPOOgLlIlsbqwz97Dl9KpAnX-w,9188
+monoco/features/i18n/core.py,sha256=bnEV9D7KgxbC5I3l-1RN1-H8hek1loDL6KFXzmdq0pQ,9658
 monoco/features/i18n/resources/en/AGENTS.md,sha256=zzuF7BW6x8Mj6LZZmeM6wTbG5CSCDMShf4rwtN7XITg,197
 monoco/features/i18n/resources/en/SKILL.md,sha256=Z8fAAqeMvpLDw1D_9AzZIykS5-HLVM9nnlRZLWBTPqM,2203
 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.1.dist-info/METADATA,sha256=PZkujG6T9VUfcKukCNXem8IsQlJ9NruQZW0sWQfsoWI,4866
-monoco_toolkit-0.3.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-monoco_toolkit-0.3.1.dist-info/entry_points.txt,sha256=iYj7FWYBdtClU15-Du1skqD0s6SFSIhJvxJ29VWp8ng,43
-monoco_toolkit-0.3.1.dist-info/licenses/LICENSE,sha256=ACAGGjV6aod4eIlVUTx1q9PZbnZGN5bBwkSs9RHj83s,1071
-monoco_toolkit-0.3.1.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