fix(schedule): Default timezone to system time, store per-entry

The schedule system was defaulting to UTC even when users specified
times in their local timezone (e.g., "7:45am PST"). This caused tasks
to trigger at the wrong time or appear to never run.

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 so entries remember what
  timezone they were created in
- Move schedule.jsonl to ~/.ash/schedule.jsonl (root of ash home)
- 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
@@ -160,6 +169,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 +220,7 @@ def parse_datetime(key: str) -> datetime | None:
                 "trigger_at",
                 "cron",
                 "last_run",
+                "timezone",
                 "chat_id",
                 "chat_title",
                 "user_id",
@@ -223,6 +236,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,

tests/test_cli.py

@@ -254,49 +254,27 @@ def test_schedule_list_empty(self, cli_runner, monkeypatch, tmp_path):
         assert "No scheduled tasks" in result.stdout
 
     def test_schedule_list_with_entries(self, cli_runner, monkeypatch, tmp_path):
-        from ash.config import models
-
-        workspace = tmp_path / "workspace"
-        workspace.mkdir()
-        schedule_file = workspace / "schedule.jsonl"
+        schedule_file = tmp_path / "schedule.jsonl"
         schedule_file.write_text(
             '{"trigger_at": "2026-01-12T09:00:00+00:00", "message": "Test task"}\n'
         )
         monkeypatch.setattr(
-            "ash.config.load_config",
-            lambda: models.AshConfig(
-                models={
-                    "default": models.ModelConfig(
-                        provider="anthropic", model="claude-3-sonnet"
-                    )
-                },
-                workspace=workspace,
-            ),
+            "ash.config.paths.get_schedule_file",
+            lambda: schedule_file,
         )
 
         result = cli_runner.invoke(app, ["schedule", "list"])
         assert result.exit_code == 0
         assert "Test task" in result.stdout
 
     def test_schedule_cancel_success(self, cli_runner, monkeypatch, tmp_path):
-        from ash.config import models
-
-        workspace = tmp_path / "workspace"
-        workspace.mkdir()
-        schedule_file = workspace / "schedule.jsonl"
+        schedule_file = tmp_path / "schedule.jsonl"
         schedule_file.write_text(
             '{"id": "abc12345", "trigger_at": "2026-01-12T09:00:00+00:00", "message": "Task to cancel"}\n'
         )
         monkeypatch.setattr(
-            "ash.config.load_config",
-            lambda: models.AshConfig(
-                models={
-                    "default": models.ModelConfig(
-                        provider="anthropic", model="claude-3-sonnet"
-                    )
-                },
-                workspace=workspace,
-            ),
+            "ash.config.paths.get_schedule_file",
+            lambda: schedule_file,
         )
 
         result = cli_runner.invoke(app, ["schedule", "cancel", "--id", "abc12345"])
@@ -307,25 +285,14 @@ def test_schedule_cancel_success(self, cli_runner, monkeypatch, tmp_path):
         assert schedule_file.read_text().strip() == ""
 
     def test_schedule_clear_with_force(self, cli_runner, monkeypatch, tmp_path):
-        from ash.config import models
-
-        workspace = tmp_path / "workspace"
-        workspace.mkdir()
-        schedule_file = workspace / "schedule.jsonl"
+        schedule_file = tmp_path / "schedule.jsonl"
         schedule_file.write_text(
             '{"trigger_at": "2026-01-12T09:00:00+00:00", "message": "Task 1"}\n'
             '{"trigger_at": "2026-01-13T09:00:00+00:00", "message": "Task 2"}\n'
         )
         monkeypatch.setattr(
-            "ash.config.load_config",
-            lambda: models.AshConfig(
-                models={
-                    "default": models.ModelConfig(
-                        provider="anthropic", model="claude-3-sonnet"
-                    )
-                },
-                workspace=workspace,
-            ),
+            "ash.config.paths.get_schedule_file",
+            lambda: schedule_file,
         )
 
         result = cli_runner.invoke(app, ["schedule", "clear", "--force"])