soothe-cli 0.6.11__tar.gz → 0.6.13__tar.gz

{soothe_cli-0.6.11 → soothe_cli-0.6.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.6.11
+Version: 0.6.13
 Summary: Soothe CLI client - communicates with daemon via WebSocket
 Project-URL: Homepage, https://github.com/mirasoth/soothe
 Project-URL: Documentation, https://soothe.readthedocs.io

{soothe_cli-0.6.11 → soothe_cli-0.6.13}/src/soothe_cli/cli/commands/autopilot_cmd.py

@@ -1,6 +1,6 @@
 """Autopilot CLI subcommands for RFC-204.
 
-Daemon-backed control surface: submit tasks and manage goals via HTTP REST.
+Daemon-backed control surface: submit tasks and manage goals via WebSocket.
 Requires ``soothed start``. Real-time monitoring is via TUI ``/autopilot``.
 """
 
@@ -15,11 +15,9 @@ from pathlib import Path
 
 import typer
 from soothe_sdk.client import (
-    AutopilotHttpClient,
-    ensure_http_rest_available,
-    http_rest_url_from_config,
     is_daemon_live,
     websocket_url_from_config,
+    ws_command_client_from_config,
 )
 from soothe_sdk.client.protocol import preview_first
 
@@ -36,8 +34,8 @@ def _resolve_submit_workspace(explicit: str | None) -> str:
     return str(Path(raw).expanduser().resolve())
 
 
-def _require_daemon_http() -> AutopilotHttpClient:
-    """Return a live HTTP client or exit."""
+def _require_daemon_ws():
+    """Return a live WebSocket command client or exit."""
     from soothe_cli.runtime import load_config
 
     cfg = load_config()
@@ -48,13 +46,7 @@ def _require_daemon_http() -> AutopilotHttpClient:
             err=True,
         )
         sys.exit(1)
-    base_url = http_rest_url_from_config(cfg)
-    try:
-        ensure_http_rest_available(base_url)
-    except RuntimeError as exc:
-        typer.echo(f"Error: {exc}", err=True)
-        sys.exit(1)
-    return AutopilotHttpClient(base_url)
+    return ws_command_client_from_config(cfg)
 
 
 @app.command("run")
@@ -79,9 +71,9 @@ def run(
     path — distinct from a one-shot agentic query via ``soothe -p``.
     """
     del max_iterations  # daemon owns config for autopilot dispatch
-    client = _require_daemon_http()
+    client = _require_daemon_ws()
     submit_workspace = _resolve_submit_workspace(workspace)
-    result = client.submit(prompt, workspace=submit_workspace)
+    result = client.autopilot_submit(prompt, workspace=submit_workspace)
     goal_id = result.get("goal_id", "")
     typer.echo(f"Submitted goal: {goal_id}")
     if not wait or not goal_id:
@@ -89,7 +81,7 @@ def run(
 
     deadline = time.time() + 600
     while time.time() < deadline:
-        detail = client.get_goal(goal_id)
+        detail = client.autopilot_get_goal(goal_id)
         goal = detail.get("goal") or {}
         status = goal.get("status", "unknown")
         if status in ("completed", "failed", "cancelled", "suspended"):
@@ -114,9 +106,9 @@ def submit(
     ),
 ) -> None:
     """Submit a new task to the daemon autopilot."""
-    client = _require_daemon_http()
+    client = _require_daemon_ws()
     submit_workspace = _resolve_submit_workspace(workspace)
-    result = client.submit(task, priority=priority, workspace=submit_workspace)
+    result = client.autopilot_submit(task, priority=priority, workspace=submit_workspace)
     goal_id = result.get("goal_id", "?")
     typer.echo(f"Task submitted (goal_id={goal_id})")
     typer.echo(f"  Priority: {priority}")
@@ -126,8 +118,8 @@ def submit(
 @app.command("status")
 def status() -> None:
     """Show overall autopilot state and goal DAG summary."""
-    client = _require_daemon_http()
-    data = client.status()
+    client = _require_daemon_ws()
+    data = client.autopilot_status()
     state = data.get("state", data.get("status", "unknown"))
     running = data.get("running", False)
     dreaming = data.get("dreaming", False)
@@ -139,8 +131,8 @@ def status() -> None:
     if isinstance(loop_pool, dict) and loop_pool:
         typer.echo(f"Worker pool: {loop_pool}")
 
-    jobs = client.list_jobs().get("jobs") or []
-    goals = client.list_goals().get("goals") or []
+    jobs = client.autopilot_list_jobs().get("jobs") or []
+    goals = client.autopilot_list_goals().get("goals") or []
     typer.echo(f"\nJobs (root goals): {len(jobs)}")
     if goals:
         counts = Counter(str(g.get("status", "pending")) for g in goals)
@@ -182,8 +174,8 @@ def list_jobs_alias(
 
 
 def _list_jobs_impl(status_filter: str) -> None:
-    client = _require_daemon_http()
-    payload = client.list_jobs()
+    client = _require_daemon_ws()
+    payload = client.autopilot_list_jobs()
     jobs = payload.get("jobs") or []
     if not jobs:
         typer.echo("No jobs found.")
@@ -204,8 +196,8 @@ def list_goals(
     status_filter: str = typer.Option("", "--status", "-s", help="Filter by status."),
 ) -> None:
     """List all goals in the daemon autopilot DAG (including subgoals)."""
-    client = _require_daemon_http()
-    payload = client.list_goals()
+    client = _require_daemon_ws()
+    payload = client.autopilot_list_goals()
     goals = payload.get("goals") or []
     if not goals:
         typer.echo("No goals found.")
@@ -270,9 +262,9 @@ def show_job(
     A job is a root goal submitted by the user. This command shows
     the job's details and the complete goal DAG under it.
     """
-    client = _require_daemon_http()
+    client = _require_daemon_ws()
     try:
-        payload = client.get_job(job_id)
+        payload = client.autopilot_get_job(job_id)
     except RuntimeError as exc:
         typer.echo(str(exc), err=True)
         raise typer.Exit(1) from exc
@@ -314,8 +306,8 @@ def show_goal(
     goal_id: str = typer.Argument(..., help="Goal ID to show details for."),
 ) -> None:
     """Show details for a specific goal."""
-    client = _require_daemon_http()
-    payload = client.get_goal(goal_id)
+    client = _require_daemon_ws()
+    payload = client.autopilot_get_goal(goal_id)
     found = payload.get("goal")
     if not found:
         typer.echo(f"Goal '{goal_id}' not found.")
@@ -336,8 +328,8 @@ def cancel_goal(
     goal_id: str = typer.Argument(..., help="Goal ID to cancel."),
 ) -> None:
     """Cancel a goal via the daemon."""
-    client = _require_daemon_http()
-    result = client.cancel_goal(goal_id)
+    client = _require_daemon_ws()
+    result = client.autopilot_cancel_goal(goal_id)
     typer.echo(f"Cancel result: {result.get('status', result)}")
 
 
@@ -348,9 +340,9 @@ def approve_goal(
     ),
 ) -> None:
     """Approve a MUST-confirmation goal."""
-    client = _require_daemon_http()
+    client = _require_daemon_ws()
     try:
-        result = client.approve(goal_id)
+        result = client.autopilot_approve(goal_id)
     except RuntimeError as exc:
         typer.echo(str(exc), err=True)
         raise typer.Exit(1) from exc
@@ -362,9 +354,9 @@ def reject_goal(
     goal_id: str = typer.Argument(..., help="Confirmation ID to reject."),
 ) -> None:
     """Reject a proposed goal."""
-    client = _require_daemon_http()
+    client = _require_daemon_ws()
     try:
-        result = client.reject(goal_id)
+        result = client.autopilot_reject(goal_id)
     except RuntimeError as exc:
         typer.echo(str(exc), err=True)
         raise typer.Exit(1) from exc
@@ -380,9 +372,9 @@ def resume_goal(
     Reactivates a paused goal back to pending status so the scheduler
     can pick it up for execution. Use 'jobs' to list goals and their status.
     """
-    client = _require_daemon_http()
+    client = _require_daemon_ws()
     try:
-        result = client.resume(goal_id)
+        result = client.autopilot_resume(goal_id)
     except RuntimeError as exc:
         typer.echo(str(exc), err=True)
         raise typer.Exit(1) from exc
@@ -394,16 +386,16 @@ def resume_goal(
 @app.command("wake")
 def wake() -> None:
     """Exit dreaming mode — resume active execution."""
-    client = _require_daemon_http()
-    client.wake()
+    client = _require_daemon_ws()
+    client.autopilot_wake()
     typer.echo("Wake signal sent.")
 
 
 @app.command("dream")
 def dream() -> None:
     """Force enter dreaming mode."""
-    client = _require_daemon_http()
-    client.dream()
+    client = _require_daemon_ws()
+    client.autopilot_dream()
     typer.echo("Dream signal sent.")
 
 

soothe_cli-0.6.13/src/soothe_cli/cli/commands/cron_cmd.py

@@ -0,0 +1,241 @@
+"""Cron CLI subcommands for RFC-229.
+
+Daemon-backed control surface: manage scheduled jobs via WebSocket.
+Requires ``soothed start``.
+
+Commands:
+    soothe cron add <text>        # Add scheduled job (natural language)
+    soothe cron list              # List scheduled jobs
+    soothe cron show <job_id>     # Show job details
+    soothe cron cancel <job_id>   # Cancel a job
+"""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+from datetime import datetime
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from soothe_sdk.client import (
+    is_daemon_live,
+    websocket_url_from_config,
+    ws_command_client_from_config,
+)
+
+from soothe_cli.runtime import load_config
+
+console = Console()
+
+app = typer.Typer(help="Manage scheduled cron jobs — natural language scheduled tasks.")
+
+
+def _require_cron_client():
+    """Return a live WebSocket command client or exit."""
+    cfg = load_config()
+    ws_url = websocket_url_from_config(cfg)
+    if not asyncio.run(is_daemon_live(ws_url, timeout=5.0)):
+        typer.echo(
+            "Error: Daemon not running. Start with 'soothed start'.",
+            err=True,
+        )
+        sys.exit(1)
+    return ws_command_client_from_config(cfg)
+
+
+def _format_next_run(next_run: str) -> str:
+    if not next_run:
+        return "-"
+    try:
+        dt = datetime.fromisoformat(next_run.replace("Z", "+00:00"))
+        now = datetime.now(dt.tzinfo)
+        delta = dt - now
+        if delta.total_seconds() < 0:
+            return "due now"
+        if delta.total_seconds() < 3600:
+            return f"in {int(delta.total_seconds() / 60)}m"
+        if delta.total_seconds() < 86400:
+            return f"in {int(delta.total_seconds() / 3600)}h"
+        return f"in {int(delta.total_seconds() / 86400)}d"
+    except ValueError:
+        return next_run[:19]
+
+
+@app.command("add")
+def add_job(
+    text: Annotated[str, typer.Argument(help="Natural language schedule and task.")],
+    priority: Annotated[
+        int | None,
+        typer.Option("--priority", "-p", help="Job priority (0-100)."),
+    ] = None,
+) -> None:
+    """Add a scheduled cron job via natural language.
+
+    The daemon extracts schedule semantics via LLM and persists the job.
+
+    Example:
+        soothe cron add "in 1 hour remind me to check the deploy"
+        soothe cron add "every weekday at 9am send status report" --priority 70
+    """
+    client = _require_cron_client()
+    try:
+        result = client.cron_add(text, priority=priority)
+    except RuntimeError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        sys.exit(1)
+
+    job = result.get("job") or {}
+    job_id = job.get("id", "?")
+    console.print(
+        Panel(
+            "\n".join(
+                [
+                    f"[bold]ID:[/bold] {job_id}",
+                    f"[bold]Description:[/bold] {job.get('description', '-')}",
+                    f"[bold]Schedule:[/bold] {job.get('schedule_kind', '?')} = {job.get('schedule_value', '?')}",
+                    f"[bold]Next Run:[/bold] [yellow]{str(job.get('next_run', ''))[:19]}[/yellow]",
+                    f"[bold]Status:[/bold] [green]{job.get('status', 'pending')}[/green]",
+                ]
+            ),
+            title="Scheduled Job Created",
+            border_style="green",
+        )
+    )
+
+
+@app.command("list")
+def list_jobs(
+    status: Annotated[
+        str | None,
+        typer.Option(
+            "--status",
+            "-s",
+            help="Filter by status (pending, running, completed, failed, cancelled).",
+        ),
+    ] = None,
+) -> None:
+    """List scheduled cron jobs.
+
+    Shows jobs with their ID, description, status, next run time, and run count.
+
+    Example:
+        soothe cron list
+        soothe cron list --status pending
+    """
+    client = _require_cron_client()
+    try:
+        result = client.cron_list_jobs(status=status)
+    except RuntimeError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        sys.exit(1)
+
+    jobs = result.get("jobs", [])
+    if not jobs:
+        console.print("[info]No scheduled jobs found.[/info]")
+        return
+
+    table = Table(title="Scheduled Jobs")
+    table.add_column("Job ID", style="cyan", width=12)
+    table.add_column("Description", width=40)
+    table.add_column("Status", style="green", width=10)
+    table.add_column("Next Run", style="yellow", width=20)
+    table.add_column("Runs", justify="right", width=6)
+
+    for job in jobs:
+        desc = job.get("description", "")
+        if len(desc) > 40:
+            desc = desc[:37] + "..."
+        table.add_row(
+            job.get("id", "?")[:12],
+            desc,
+            job.get("status", "pending"),
+            _format_next_run(job.get("next_run", "")),
+            str(job.get("run_count", 0)),
+        )
+
+    console.print(table)
+
+
+@app.command("show")
+def show_job(
+    job_id: Annotated[str, typer.Argument(help="Job ID to show details for.")],
+) -> None:
+    """Show details of a scheduled cron job.
+
+    Displays full job information including schedule kind, schedule value,
+    end condition, timestamps, and execution history.
+
+    Example:
+        soothe cron show abc123def456
+    """
+    client = _require_cron_client()
+    try:
+        result = client.cron_show(job_id)
+    except RuntimeError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        sys.exit(1)
+
+    job = result.get("job")
+    if not job:
+        typer.echo(f"Error: Job '{job_id}' not found.", err=True)
+        sys.exit(1)
+
+    details = [
+        f"[bold]ID:[/bold] {job.get('id', '?')}",
+        f"[bold]Description:[/bold] {job.get('description', '-')}",
+        f"[bold]Status:[/bold] [green]{job.get('status', 'pending')}[/green]",
+        f"[bold]Priority:[/bold] {job.get('priority', 50)}",
+        f"[bold]Schedule:[/bold] {job.get('schedule_kind', 'once')} = {job.get('schedule_value', '')}",
+    ]
+    if job.get("end_condition"):
+        details.append(f"[bold]End Condition:[/bold] {job['end_condition']}")
+    next_run = job.get("next_run", "")
+    if next_run:
+        details.append(f"[bold]Next Run:[/bold] [yellow]{next_run[:19]}[/yellow]")
+    last_run = job.get("last_run")
+    if last_run:
+        details.append(f"[bold]Last Run:[/bold] {last_run[:19]}")
+    details.append(f"[bold]Run Count:[/bold] {job.get('run_count', 0)}")
+    created = job.get("created_at", "")
+    if created:
+        details.append(f"[bold]Created:[/bold] [dim]{created[:19]}[/dim]")
+
+    console.print(Panel("\n".join(details), title=f"Cron Job: {job_id[:12]}", border_style="cyan"))
+
+
+@app.command("cancel")
+def cancel_job(
+    job_id: Annotated[str, typer.Argument(help="Job ID to cancel.")],
+) -> None:
+    """Cancel a scheduled cron job.
+
+    Marks the job as cancelled. Only pending jobs can be cancelled.
+
+    Example:
+        soothe cron cancel abc123def456
+    """
+    client = _require_cron_client()
+    try:
+        result = client.cron_cancel(job_id)
+    except RuntimeError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        sys.exit(1)
+
+    if result.get("cancelled"):
+        console.print(f"[success]Cancelled job: {job_id[:12]}[/success]")
+    else:
+        typer.echo(f"Error: Could not cancel job '{job_id}'.", err=True)
+        sys.exit(1)
+
+
+__all__ = [
+    "app",
+    "add_job",
+    "list_jobs",
+    "show_job",
+    "cancel_job",
+]

{soothe_cli-0.6.11 → soothe_cli-0.6.13}/src/soothe_cli/cli/commands/status_cmd.py

@@ -83,12 +83,14 @@ def _render_unified_status_table(
     daemon_pid: int | None = None,
     ready_state: dict[str, Any] | None = None,
     daemon_live: bool = True,
+    daemon_version: str | None = None,
+    core_version: str | None = None,
 ) -> Table:
     """Render unified status table without duplicated info.
 
     Sections:
     - Connection: WebSocket URL, Soothe Home
-    - Daemon: Running, Threads, PID (only when daemon is live)
+    - Daemon: Running, Threads, PID, Versions (only when daemon is live)
     """
     table = Table(title="Soothe Status")
     table.add_column("Section", style="dim", width=12)
@@ -109,6 +111,10 @@ def _render_unified_status_table(
         table.add_row("", "PID", str(daemon_pid))
     if active_threads is not None:
         table.add_row("", "Active Threads", str(active_threads))
+    if daemon_version:
+        table.add_row("", "Daemon Version", daemon_version)
+    if core_version:
+        table.add_row("", "Core Version", core_version)
 
     if ready_state:
         state = ready_state.get("state", "unknown")
@@ -207,6 +213,8 @@ def daemon_status(
             "port_live": status.get("port_live", True),
             "active_threads": status.get("active_threads", 0),
             "daemon_pid": status.get("daemon_pid"),
+            "daemon_version": status.get("daemon_version"),
+            "core_version": status.get("core_version"),
         }
         if ready_state:
             output["readiness_state"] = ready_state.get("state", "unknown")
@@ -219,9 +227,20 @@ def daemon_status(
     port_live = status.get("port_live", True)
     active_threads = status.get("active_threads", 0)
     daemon_pid = status.get("daemon_pid")
+    daemon_version = status.get("daemon_version")
+    core_version = status.get("core_version")
 
     table = _render_unified_status_table(
-        config, ws_url, running, port_live, active_threads, daemon_pid, ready_state
+        config,
+        ws_url,
+        running,
+        port_live,
+        active_threads,
+        daemon_pid,
+        ready_state,
+        daemon_live=True,
+        daemon_version=daemon_version,
+        core_version=core_version,
     )
     console.print(table)
 
@@ -311,6 +330,8 @@ def status_main(
                 output["daemon"]["port_live"] = status.get("port_live", True)
                 output["daemon"]["active_threads"] = status.get("active_threads", 0)
                 output["daemon"]["daemon_pid"] = status.get("daemon_pid")
+                output["daemon"]["daemon_version"] = status.get("daemon_version")
+                output["daemon"]["core_version"] = status.get("core_version")
         console.print_json(json.dumps(output))
         return
 
@@ -338,9 +359,19 @@ def status_main(
     port_live = status.get("port_live", True)
     active_threads = status.get("active_threads", 0)
     daemon_pid = status.get("daemon_pid")
+    daemon_version = status.get("daemon_version")
+    core_version = status.get("core_version")
 
     table = _render_unified_status_table(
-        config, ws_url, running, port_live, active_threads, daemon_pid
+        config,
+        ws_url,
+        running,
+        port_live,
+        active_threads,
+        daemon_pid,
+        daemon_live=True,
+        daemon_version=daemon_version,
+        core_version=core_version,
     )
     console.print(table)
 

{soothe_cli-0.6.11 → soothe_cli-0.6.13}/src/soothe_cli/cli/execution/daemon.py

@@ -15,6 +15,7 @@ from typing import Any
 import typer
 from soothe_sdk.client import (
     WebSocketClient,
+    async_ws_command_client_from_config,
     bootstrap_loop_session,
     connect_websocket_with_retries,
     websocket_url_from_config,
@@ -59,6 +60,22 @@ async def _send_cancel_to_daemon(client: WebSocketClient) -> None:
         logger.warning("Failed to send /cancel to daemon", exc_info=True)
 
 
+def _parse_cron_slash_prompt(prompt: str) -> str | None:
+    """Return natural-language cron text if ``prompt`` is a ``/cron`` slash command.
+
+    Args:
+        prompt: User input (e.g. ``/cron in 1 hour remind me to deploy``).
+
+    Returns:
+        Text after ``/cron``, or ``None`` if not a cron slash command.
+    """
+    stripped = prompt.strip()
+    if not stripped.lower().startswith("/cron"):
+        return None
+    rest = stripped[len("/cron") :].strip()
+    return rest
+
+
 async def _run_headless_session_once(
     cfg: Any,
     prompt: str,
@@ -79,6 +96,24 @@ async def _run_headless_session_once(
     sigint_count = 0
     original_sigint: Any = None
 
+    cron_text = _parse_cron_slash_prompt(prompt)
+    if cron_text is not None:
+        if not cron_text.strip():
+            _emit_headless_error("Usage: /cron <natural language schedule>")
+            return 1, False
+        try:
+            ws_client = async_ws_command_client_from_config(cfg)
+            result = await ws_client.cron_add(cron_text)
+        except RuntimeError as exc:
+            _emit_headless_error(str(exc))
+            return 1, False
+        job = result.get("job") or {}
+        job_id = job.get("id", "?")
+        typer.echo(f"Scheduled cron job: {job_id}")
+        typer.echo(f"  Description: {job.get('description', cron_text)}")
+        typer.echo(f"  Next run: {str(job.get('next_run', ''))[:19]}")
+        return 0, False
+
     try:
         await connect_websocket_with_retries(client)
         cli_ws = os.environ.get("SOOTHE_CLI_WORKSPACE", "").strip() or os.getcwd()

{soothe_cli-0.6.11 → soothe_cli-0.6.13}/src/soothe_cli/cli/main.py

@@ -201,6 +201,7 @@ def main(
 # ---------------------------------------------------------------------------
 
 from soothe_cli.cli.commands.autopilot_cmd import app as _autopilot_app  # noqa: E402
+from soothe_cli.cli.commands.cron_cmd import app as _cron_app  # noqa: E402
 from soothe_cli.cli.commands.loop_cmd import loop_app as _loop_app  # noqa: E402
 from soothe_cli.cli.commands.status_cmd import status_app as _status_app  # noqa: E402
 
@@ -208,6 +209,7 @@ from soothe_cli.cli.commands.status_cmd import status_app as _status_app  # noqa
 for _sub_app, _name in (
     (_loop_app, "loop"),
     (_autopilot_app, "autopilot"),
+    (_cron_app, "cron"),
 ):
     add_help_alias(_sub_app)
     app.add_typer(_sub_app, name=_name)

{soothe_cli-0.6.11 → soothe_cli-0.6.13}/src/soothe_cli/runtime/headless/processor.py

@@ -387,7 +387,7 @@ class EventProcessor:
             self._handle_clear_event(event)
 
     def _handle_command_response(self, event: dict[str, Any]) -> None:
-        """Handle command response from daemon (RFC-404)."""
+        """Handle command response from daemon (RFC-454)."""
         command = event.get("command")
         data = event.get("data")
         error = event.get("error")

{soothe_cli-0.6.11 → soothe_cli-0.6.13}/src/soothe_cli/tui/app/_execution.py

@@ -461,7 +461,7 @@ class _ExecutionMixin:
         )
         from soothe_cli.tui.commands.slash_commands import COMMANDS as _RFC404_COMMANDS
 
-        # RFC-404 daemon *routing* commands (/research, /explore, /plan, optional /«id»):
+        # RFC-454 daemon *routing* commands (/research, /explore, /plan, optional /«id»):
         # send the full line as a normal user turn so ``parse_subagent_from_input``
         # runs in the daemon adapter (same as headless CLI). Without this branch,
         # ``cmd == "/research …"`` never matches the bare single-token handlers below.
@@ -493,7 +493,8 @@ class _ExecutionMixin:
         elif cmd == "/help":
             await self._mount_message(UserMessage(command))
             help_body = (
-                "Commands: /quit, /clear, /editor, /autopilot <task>, /autopilot-dashboard, /mcp, "
+                "Commands: /quit, /clear, /editor, /autopilot <task>, /cron <schedule>, "
+                "/autopilot-dashboard, /mcp, "
                 "/model [--model-params JSON] [--default], /notifications, "
                 "/reload, /skill:<name>, /theme, "
                 "/tokens, /resume, "
@@ -649,6 +650,18 @@ class _ExecutionMixin:
                 )
                 return
             await self._submit_autopilot_job(args)
+        elif cmd == "/cron" or cmd.startswith("/cron "):
+            args = command.strip()[len("/cron") :].strip()
+            if not args:
+                await self._mount_message(UserMessage(command))
+                await self._mount_message(
+                    AppMessage(
+                        "Usage: /cron <natural language schedule>\n"
+                        "Example: /cron in 1 hour remind me to check the deploy"
+                    )
+                )
+                return
+            await self._submit_cron_job(args, slash_input=command)
         elif cmd == "/autopilot-dashboard":
             await self._show_autopilot_dashboard()
         elif cmd == "/autopilot-toggle":