fix(schedule): Default timezone to system time, evaluate cron in UTC

The schedule system was defaulting to UTC even when users specified
times in their local timezone. Also, cron expressions were being
evaluated in local time which could cause issues if timezone changes.

Changes:
- Add get_system_timezone() to detect system timezone from TZ env,
  /etc/timezone, or /etc/localtime symlink
- Change AshConfig.timezone default from "UTC" to system timezone
- Add timezone field to ScheduleEntry for display purposes
- Always evaluate cron expressions in UTC for consistency
- Move schedule.jsonl to ~/.ash/schedule.jsonl
- Mount schedule file directly in sandbox at /schedule.jsonl
- Improve error message for past times to show parsed value

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: dcramer

packages/ash-sandbox-cli/src/ash_sandbox_cli/commands/schedule.py

@@ -15,7 +15,7 @@
     no_args_is_help=True,
 )
 
-SCHEDULE_FILE = Path("/workspace/schedule.jsonl")
+SCHEDULE_FILE = Path("/schedule.jsonl")
 
 
 def _get_context() -> dict[str, str]:
@@ -173,7 +173,14 @@ def create(
             typer.echo(f"Error: Could not parse time: {at}", err=True)
             raise typer.Exit(1)
         if trigger_time <= datetime.now(UTC):
-            typer.echo(f"Error: --at must be in the future. Got: {at}", err=True)
+            from zoneinfo import ZoneInfo
+
+            tz = ZoneInfo(ctx["timezone"])
+            local_str = trigger_time.astimezone(tz).strftime("%Y-%m-%d %H:%M %Z")
+            typer.echo(
+                f"Error: Time '{at}' parsed as {local_str} which is in the past",
+                err=True,
+            )
             raise typer.Exit(1)
 
     # Validate cron format
@@ -210,6 +217,8 @@ def create(
         entry["user_id"] = ctx["user_id"]
     if ctx["username"]:
         entry["username"] = ctx["username"]
+    # Store timezone so cron expressions are evaluated in the correct local time
+    entry["timezone"] = ctx["timezone"]
 
     entry["created_at"] = datetime.now(UTC).isoformat()
 

src/ash/cli/commands/schedule.py

@@ -70,7 +70,7 @@ def schedule(
     ) -> None:
         """Manage scheduled tasks.
 
-        Scheduled tasks are stored in workspace/schedule.jsonl.
+        Scheduled tasks are stored in ~/.ash/schedule.jsonl.
 
         Examples:
             ash schedule list                  # List all scheduled tasks
@@ -82,10 +82,9 @@ def schedule(
             click.echo(ctx.get_help())
             raise typer.Exit(0)
 
-        from ash.config import load_config
+        from ash.config.paths import get_schedule_file
 
-        config = load_config()
-        schedule_file = config.workspace / "schedule.jsonl"
+        schedule_file = get_schedule_file()
 
         if action == "list":
             _schedule_list(schedule_file)

src/ash/cli/commands/serve.py

@@ -163,9 +163,10 @@ async def _run_server(
         )
 
     # Set up schedule watcher
+    from ash.config.paths import get_schedule_file
     from ash.events import ScheduledTaskHandler, ScheduleWatcher
 
-    schedule_file = ash_config.workspace / "schedule.jsonl"
+    schedule_file = get_schedule_file()
     schedule_watcher = ScheduleWatcher(schedule_file, timezone=ash_config.timezone)
 
     # Build sender map from available providers

src/ash/config/models.py

@@ -14,7 +14,11 @@
     model_validator,
 )
 
-from ash.config.paths import get_database_path, get_workspace_path
+from ash.config.paths import (
+    get_database_path,
+    get_system_timezone,
+    get_workspace_path,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -264,7 +268,8 @@ class AshConfig(BaseModel):
     workspace: Path = Field(default_factory=get_workspace_path)
     # User's timezone (IANA timezone name, e.g., "America/New_York")
     # Used for displaying times and evaluating cron schedules
-    timezone: str = "UTC"
+    # Default: detect from system (TZ env, /etc/timezone, /etc/localtime)
+    timezone: str = Field(default_factory=get_system_timezone)
     # Named model configurations (new style)
     models: dict[str, ModelConfig] = Field(default_factory=dict)
 

src/ash/config/paths.py

@@ -15,6 +15,43 @@
 ENV_VAR = "ASH_HOME"
 
 
+def get_system_timezone() -> str:
+    """Detect system timezone, falling back to UTC.
+
+    Resolution order:
+    1. TZ environment variable (if set)
+    2. /etc/timezone file (Debian/Ubuntu)
+    3. /etc/localtime symlink target (most Linux distros)
+    4. Fallback to UTC
+
+    Returns:
+        IANA timezone name (e.g., "America/Los_Angeles", "Europe/London", "UTC").
+    """
+    # Check TZ environment variable first
+    if tz := os.environ.get("TZ"):
+        return tz
+
+    # Linux: read /etc/timezone (Debian/Ubuntu)
+    try:
+        tz = Path("/etc/timezone").read_text().strip()
+        if tz:
+            return tz
+    except (FileNotFoundError, PermissionError):
+        pass
+
+    # Linux: follow /etc/localtime symlink (most distros)
+    try:
+        link = Path("/etc/localtime").resolve()
+        parts = str(link).split("zoneinfo/")
+        if len(parts) > 1:
+            return parts[1]
+    except (FileNotFoundError, PermissionError):
+        pass
+
+    # Fallback to UTC
+    return "UTC"
+
+
 @lru_cache(maxsize=1)
 def get_ash_home() -> Path:
     """Get the base directory for all Ash data.
@@ -116,6 +153,11 @@ def get_installed_skills_path() -> Path:
     return get_ash_home() / "skills.installed"
 
 
+def get_schedule_file() -> Path:
+    """Get the schedule file path."""
+    return get_ash_home() / "schedule.jsonl"
+
+
 def get_uv_cache_path() -> Path:
     """Get the uv package cache directory path for sandbox."""
     return get_ash_home() / "cache" / "uv"
@@ -158,6 +200,7 @@ def get_all_paths() -> dict[str, Path]:
         "config": get_config_path(),
         "database": get_database_path(),
         "workspace": get_workspace_path(),
+        "schedule": get_schedule_file(),
         "logs": get_logs_path(),
         "run": get_run_path(),
         "chats": get_chats_path(),

src/ash/events/schedule.py

@@ -42,6 +42,9 @@ class ScheduleEntry:
     trigger_at: datetime | None = None  # One-shot
     cron: str | None = None  # Periodic
     last_run: datetime | None = None  # For periodic
+    # Timezone the entry was created in (IANA name)
+    # Used for evaluating cron expressions in the correct local time
+    timezone: str | None = None
     # Context for routing response back
     chat_id: str | None = None
     chat_title: str | None = None  # Friendly name for the chat
@@ -61,7 +64,8 @@ def next_fire_time(self, timezone: str = "UTC") -> datetime | None:
         """Get the next fire time for this entry.
 
         Args:
-            timezone: IANA timezone name for evaluating cron expressions.
+            timezone: Fallback IANA timezone name for evaluating cron expressions.
+                      If the entry has a stored timezone, that takes precedence.
 
         Returns:
             The next fire time in UTC, or None if not schedulable.
@@ -70,18 +74,23 @@ def next_fire_time(self, timezone: str = "UTC") -> datetime | None:
             return self.trigger_at
 
         if self.cron:
-            return self._next_run_time(timezone)
+            # Use stored timezone if available, otherwise fall back to parameter
+            tz = self.timezone or timezone
+            return self._next_run_time(tz)
 
         return None
 
     def is_due(self, timezone: str = "UTC") -> bool:
         """Check if this entry is due for execution.
 
         Args:
-            timezone: IANA timezone name for evaluating cron expressions.
+            timezone: Fallback IANA timezone name for evaluating cron expressions.
+                      If the entry has a stored timezone, that takes precedence.
         """
         now = datetime.now(UTC)
         entry_id = self.id or "?"
+        # Use stored timezone if available, otherwise fall back to parameter
+        tz = self.timezone or timezone
 
         if self.trigger_at:
             is_due = now >= self.trigger_at
@@ -92,15 +101,15 @@ def is_due(self, timezone: str = "UTC") -> bool:
             return is_due
 
         if self.cron:
-            next_run = self._next_run_time(timezone)
+            next_run = self._next_run_time(tz)
             if next_run is None:
                 logger.debug(
                     f"Entry {entry_id}: cron={self.cron}, next_run=None, due=False"
                 )
                 return False
             is_due = now >= next_run
             logger.debug(
-                f"Entry {entry_id}: cron='{self.cron}' (tz={timezone}), "
+                f"Entry {entry_id}: cron='{self.cron}' (tz={tz}), "
                 f"next_run={next_run.isoformat()}, now={now.isoformat()}, due={is_due}"
             )
             return is_due
@@ -110,33 +119,29 @@ def is_due(self, timezone: str = "UTC") -> bool:
     def _next_run_time(self, timezone: str = "UTC") -> datetime | None:
         """Calculate next run time from cron and last_run.
 
-        Cron expressions are evaluated in the user's timezone so that
-        "0 8 * * *" means 8am local time, not 8am UTC.
+        Cron expressions are always evaluated in UTC for consistency.
+        This ensures scheduled times don't shift if system timezone changes.
 
         Args:
-            timezone: IANA timezone name for evaluating cron expressions.
+            timezone: Unused, kept for API compatibility. Cron always uses UTC.
         """
         if not self.cron:
             return None
         try:
-            from zoneinfo import ZoneInfo
-
             from croniter import croniter
 
-            tz = ZoneInfo(timezone)
-
+            # Always use UTC for cron evaluation
             if self.last_run:
-                # Normal case: get next run after last_run
-                # Convert last_run to user timezone for cron evaluation
-                base_time = self.last_run.astimezone(tz)
+                base_time = self.last_run.astimezone(UTC)
             else:
-                # New task: wait for the next scheduled occurrence
-                base_time = datetime.now(UTC).astimezone(tz)
-
-            # croniter evaluates in the timezone of base_time
-            next_local = croniter(self.cron, base_time).get_next(datetime)
-            # Convert back to UTC for comparison
-            return next_local.astimezone(UTC)
+                base_time = datetime.now(UTC)
+
+            # croniter evaluates in UTC
+            next_utc = croniter(self.cron, base_time).get_next(datetime)
+            # Ensure it's UTC-aware
+            if next_utc.tzinfo is None:
+                next_utc = next_utc.replace(tzinfo=UTC)
+            return next_utc
         except Exception as e:
             logger.warning(
                 f"Failed to parse cron expression '{self.cron}' for entry {self.id}: {e}"
@@ -160,6 +165,9 @@ def to_json_line(self) -> str:
             if self.last_run:
                 data["last_run"] = self.last_run.isoformat()
 
+        if self.timezone:
+            data["timezone"] = self.timezone
+
         # Context fields
         if self.chat_id:
             data["chat_id"] = self.chat_id
@@ -208,6 +216,7 @@ def parse_datetime(key: str) -> datetime | None:
                 "trigger_at",
                 "cron",
                 "last_run",
+                "timezone",
                 "chat_id",
                 "chat_title",
                 "user_id",
@@ -223,6 +232,7 @@ def parse_datetime(key: str) -> datetime | None:
                 trigger_at=trigger_at,
                 cron=cron,
                 last_run=last_run,
+                timezone=data.get("timezone"),
                 chat_id=data.get("chat_id"),
                 chat_title=data.get("chat_title"),
                 user_id=data.get("user_id"),

src/ash/sandbox/manager.py

@@ -81,6 +81,9 @@ class SandboxConfig:
     # Chats mounting (for agent to read chat state/participants)
     chats_path: Path | None = None  # Host path to chats directory
 
+    # Schedule file mounting (for schedule.jsonl)
+    schedule_file: Path | None = None  # Host path to schedule.jsonl
+
     # Logs mounting (for agent to inspect server logs)
     logs_path: Path | None = None  # Host path to logs directory
 
@@ -188,6 +191,15 @@ async def create_container(
                 "mode": "ro",
             }
 
+        if self._config.schedule_file:
+            # Create schedule file if it doesn't exist
+            self._config.schedule_file.parent.mkdir(parents=True, exist_ok=True)
+            self._config.schedule_file.touch(exist_ok=True)
+            volumes[str(self._config.schedule_file)] = {
+                "bind": "/schedule.jsonl",
+                "mode": "rw",
+            }
+
         if self._config.logs_path and self._config.logs_path.exists():
             volumes[str(self._config.logs_path)] = {"bind": "/logs", "mode": "ro"}
 

src/ash/tools/base.py

@@ -127,13 +127,15 @@ def build_sandbox_manager_config(
         get_chats_path,
         get_logs_path,
         get_rpc_socket_path,
+        get_schedule_file,
         get_uv_cache_path,
     )
     from ash.sandbox.manager import SandboxConfig as SandboxManagerConfig
     from ash.sessions.manager import get_sessions_path
 
     sessions_path = get_sessions_path()
     chats_path = get_chats_path()
+    schedule_file = get_schedule_file()
     logs_path = get_logs_path()
     rpc_socket_path = get_rpc_socket_path()
     uv_cache_path = get_uv_cache_path()
@@ -144,6 +146,7 @@ def build_sandbox_manager_config(
             network_mode=default_network_mode,
             sessions_path=sessions_path,
             chats_path=chats_path,
+            schedule_file=schedule_file,
             logs_path=logs_path,
             rpc_socket_path=rpc_socket_path,
             uv_cache_path=uv_cache_path,
@@ -163,6 +166,7 @@ def build_sandbox_manager_config(
         sessions_path=sessions_path,
         sessions_access=config.sessions_access,
         chats_path=chats_path,
+        schedule_file=schedule_file,
         logs_path=logs_path,
         rpc_socket_path=rpc_socket_path,
         uv_cache_path=uv_cache_path,