refine start time and end time

Author: TimeLovercc

README.md

@@ -280,11 +280,12 @@ The agent automatically monitors your Claude Code Pro plan usage and prevents ta
 **Visibility:**
 - Dashboard: Shows `Pro Usage: X% / Y% limit` in `sle check` (Y = 20% daytime, 80% nighttime)
 - Logs: Each usage check logs Pro plan usage with time-based threshold
-- Config: Adjustable via `claude_code.pause_threshold_day` and `claude_code.pause_threshold_night` in `config.yaml`
+- Config: Adjustable via `claude_code.threshold_day` and `claude_code.threshold_night` in `config.yaml`
 
 **Time-Based Thresholds:**
 - **Daytime (8 AM - 8 PM):** Pause at 20% (saves quota for your manual usage)
 - **Nighttime (8 PM - 8 AM):** Pause at 80% (agent works aggressively while you sleep)
+- Time ranges are configurable via `claude_code.night_start_hour` and `claude_code.night_end_hour` in `config.yaml`
 - ⏸️ New task generation pauses at threshold
 - ✅ Running tasks complete normally
 - 📋 Pending tasks wait in queue
@@ -417,7 +418,7 @@ launchctl list | grep sleepless
 |-------|----------|
 | Bot not responding | Check `.env` tokens, verify Socket Mode enabled, check logs: `tail -f workspace/data/agent.log` |
 | Tasks not executing | Verify Claude Code CLI installed: `npm list -g @anthropic-ai/claude-code`, check workspace permissions |
-| Tasks paused (threshold reached) | Usage has reached time-based threshold (20% daytime / 80% nighttime). Wait for window reset (check logs for reset time), or adjust thresholds in `config.yaml` (`claude_code.pause_threshold_day` / `claude_code.pause_threshold_night`). Run `sle check` to see current usage. |
+| Tasks paused (threshold reached) | Usage has reached time-based threshold (20% daytime / 80% nighttime). Wait for window reset (check logs for reset time), or adjust thresholds in `config.yaml` (`claude_code.threshold_day` / `claude_code.threshold_night`). Run `sle check` to see current usage. |
 | Git commits fail | Install `gh` CLI and authenticate: `gh auth login` |
 | Out of credits | Wait for 5-hour window refresh. Review scheduler logs: `tail -f workspace/data/agent.log | grep credit` |
 | Database locked | Close other connections, try: `rm workspace/data/tasks.db && python -m sleepless_agent.daemon` |

src/sleepless_agent/config.yaml

@@ -1,8 +1,10 @@
 claude_code:
   binary_path: claude
   model: claude-sonnet-4-5-20250929
-  pause_threshold_day: 80.0
-  pause_threshold_night: 80.0
+  night_start_hour: 1
+  night_end_hour: 9
+  threshold_day: 100.0
+  threshold_night: 100.0
   usage_command: claude /usage
 
 git:

src/sleepless_agent/core/daemon.py

@@ -70,8 +70,10 @@ def __init__(self) -> None:
             daily_budget_usd=10.0,
             night_quota_percent=90.0,
             usage_command=self.config.claude_code.usage_command,
-            pause_threshold_day=self.config.claude_code.pause_threshold_day,
-            pause_threshold_night=self.config.claude_code.pause_threshold_night,
+            threshold_day=self.config.claude_code.threshold_day,
+            threshold_night=self.config.claude_code.threshold_night,
+            night_start_hour=self.config.claude_code.night_start_hour,
+            night_end_hour=self.config.claude_code.night_end_hour,
         )
 
         self.auto_generator = AutoTaskGenerator(
@@ -80,8 +82,10 @@ def __init__(self) -> None:
             budget_manager=self.budget_manager,
             default_model=self.config.claude_code.model,
             usage_command=self.config.claude_code.usage_command,
-            pause_threshold_day=self.config.claude_code.pause_threshold_day,
-            pause_threshold_night=self.config.claude_code.pause_threshold_night,
+            threshold_day=self.config.claude_code.threshold_day,
+            threshold_night=self.config.claude_code.threshold_night,
+            night_start_hour=self.config.claude_code.night_start_hour,
+            night_end_hour=self.config.claude_code.night_end_hour,
         )
 
         self.claude = ClaudeCodeExecutor(

src/sleepless_agent/core/executor.py

@@ -995,7 +995,7 @@ async def _execute_evaluator_phase(
                 )
 
                 # Use time-based threshold
-                threshold = config.claude_code.pause_threshold_night if is_nighttime() else config.claude_code.pause_threshold_day
+                threshold = config.claude_code.threshold_night if is_nighttime(night_start_hour=config.claude_code.night_start_hour, night_end_hour=config.claude_code.night_end_hour) else config.claude_code.threshold_day
                 should_pause, reset_time = checker.check_should_pause(
                     threshold_percent=threshold
                 )

src/sleepless_agent/interfaces/cli.py

@@ -52,8 +52,11 @@ def build_context(args: argparse.Namespace) -> CLIContext:
 
     config = get_config()
 
-    db_path = Path(config.agent.db_path)
-    results_path = Path(config.agent.results_path)
+    # Infer paths from workspace_root, similar to WorkspaceSetup._apply_workspace_root
+    workspace_root = Path(config.agent.workspace_root).expanduser().resolve()
+    data_dir = workspace_root / "data"
+    db_path = data_dir / "tasks.db"
+    results_path = data_dir / "results"
     logs_dir = db_path.parent  # Use same directory as db_path for metrics
 
     db_path.parent.mkdir(parents=True, exist_ok=True)
@@ -146,7 +149,7 @@ def command_check(ctx: CLIContext) -> int:
             command=config.claude_code.usage_command,
         )
         usage_percent, _ = checker.get_usage()
-        threshold = config.claude_code.pause_threshold_night if is_nighttime() else config.claude_code.pause_threshold_day
+        threshold = config.claude_code.threshold_night if is_nighttime(night_start_hour=config.claude_code.night_start_hour, night_end_hour=config.claude_code.night_end_hour) else config.claude_code.threshold_day
         pro_plan_usage_info = f" • Pro Usage: {usage_percent:.0f}% / {threshold:.0f}% limit"
     except Exception as exc:
         logger.debug(f"Could not fetch Pro plan usage for dashboard: {exc}")

src/sleepless_agent/scheduling/auto_generator.py

@@ -42,17 +42,21 @@ def __init__(
         budget_manager: BudgetManager,
         default_model: str,
         usage_command: str,
-        pause_threshold_day: float,
-        pause_threshold_night: float,
+        threshold_day: float,
+        threshold_night: float,
+        night_start_hour: int = 20,
+        night_end_hour: int = 8,
     ):
         """Initialize auto-generator with database session and config"""
         self.session = db_session
         self.config = config
         self.budget_manager = budget_manager
         self.default_model = default_model
         self.usage_command = usage_command
-        self.pause_threshold_day = pause_threshold_day
-        self.pause_threshold_night = pause_threshold_night
+        self.threshold_day = threshold_day
+        self.threshold_night = threshold_night
+        self.night_start_hour = night_start_hour
+        self.night_end_hour = night_end_hour
 
         # Track generation metadata
         self.last_generation_time: Optional[datetime] = None
@@ -82,7 +86,7 @@ def _should_generate(self) -> bool:
 
         try:
             checker = ProPlanUsageChecker(command=self.usage_command)
-            threshold = self.pause_threshold_night if is_nighttime() else self.pause_threshold_day
+            threshold = self.threshold_night if is_nighttime(night_start_hour=self.night_start_hour, night_end_hour=self.night_end_hour) else self.threshold_day
             should_pause, _ = checker.check_should_pause(threshold_percent=threshold)
 
             # Generate only when NOT paused (i.e., usage < threshold)

src/sleepless_agent/scheduling/scheduler.py

@@ -1,6 +1,6 @@
 """Smart task scheduler with usage tracking and time-based quotas"""
 
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from decimal import Decimal
 from typing import Any, Dict, List, Optional, Tuple
 
@@ -192,8 +192,10 @@ def __init__(
         daily_budget_usd: float = 10.0,
         night_quota_percent: float = 90.0,
         usage_command: str = "/usage",
-        pause_threshold_day: float = 20.0,
-        pause_threshold_night: float = 80.0,
+        threshold_day: float = 20.0,
+        threshold_night: float = 80.0,
+        night_start_hour: int = 20,
+        night_end_hour: int = 8,
     ):
         """Initialize scheduler
 
@@ -203,14 +205,18 @@ def __init__(
             daily_budget_usd: Daily budget in USD (default: $10)
             night_quota_percent: Percentage for night usage (default: 90%)
             usage_command: CLI command to check usage (default: "/usage")
-            pause_threshold_day: Pause threshold during daytime (default: 20%)
-            pause_threshold_night: Pause threshold during nighttime (default: 80%)
+            threshold_day: Pause threshold during daytime (default: 20%)
+            threshold_night: Pause threshold during nighttime (default: 80%)
+            night_start_hour: Hour when night starts (default: 20 for 8 PM)
+            night_end_hour: Hour when night ends (default: 8 for 8 AM)
         """
         self.task_queue = task_queue
         self.max_parallel_tasks = max_parallel_tasks
         self.usage_command = usage_command
-        self.pause_threshold_day = pause_threshold_day
-        self.pause_threshold_night = pause_threshold_night
+        self.threshold_day = threshold_day
+        self.threshold_night = threshold_night
+        self.night_start_hour = night_start_hour
+        self.night_end_hour = night_end_hour
 
         # Budget management with time-based allocation
         session = self.task_queue.SessionLocal()
@@ -280,7 +286,7 @@ def _check_scheduling_allowed(self) -> Tuple[bool, Dict[str, Any]]:
                 context = {
                     "event": "scheduler.pause.pending",
                     "reason": "usage_pause",
-                    "resume_at": self.usage_pause_until.astimezone().strftime('%Y-%m-%d %H:%M:%S %Z'),
+                    "resume_at": self.usage_pause_until.replace(tzinfo=timezone.utc).astimezone().strftime('%Y-%m-%d %H:%M:%S %Z'),
                     "detail": self._format_remaining(remaining),
                     "decision_logic": "Pausing: in pause window, waiting for resume time",
                 }
@@ -308,7 +314,7 @@ def _check_scheduling_allowed(self) -> Tuple[bool, Dict[str, Any]]:
                     "reason": "usage_threshold",
                     "usage_percent": usage_percent,
                     "threshold_percent": effective_threshold,
-                    "resume_at": pause_until.astimezone().strftime('%Y-%m-%d %H:%M:%S %Z'),
+                    "resume_at": pause_until.replace(tzinfo=timezone.utc).astimezone().strftime('%Y-%m-%d %H:%M:%S %Z'),
                     "detail": self._format_remaining(remaining),
                     "decision_logic": f"Pausing: usage {usage_percent}% >= threshold {effective_threshold}% ({time_period})",
                 }
@@ -337,10 +343,10 @@ def _get_effective_threshold(self) -> float:
 
         Returns:
             Threshold percentage (0-100) from config:
-            - Daytime: pause_threshold_day
-            - Nighttime: pause_threshold_night
+            - Daytime: threshold_day
+            - Nighttime: threshold_night
         """
-        return self.pause_threshold_night if is_nighttime() else self.pause_threshold_day
+        return self.threshold_night if is_nighttime(night_start_hour=self.night_start_hour, night_end_hour=self.night_end_hour) else self.threshold_day
 
     @staticmethod
     def _format_remaining(delta: timedelta) -> str:

src/sleepless_agent/scheduling/time_utils.py

@@ -9,28 +9,40 @@
 NIGHT_END_HOUR = 8     # 8 AM
 
 
-def is_nighttime(dt: Optional[datetime] = None) -> bool:
+def is_nighttime(
+    dt: Optional[datetime] = None,
+    night_start_hour: int = NIGHT_START_HOUR,
+    night_end_hour: int = NIGHT_END_HOUR,
+) -> bool:
     """Return True when the provided datetime falls within the night window."""
     if dt is None:
         dt = datetime.now()
     hour = dt.hour
-    return hour >= NIGHT_START_HOUR or hour < NIGHT_END_HOUR
+    return hour >= night_start_hour or hour < night_end_hour
 
 
-def get_time_label(dt: Optional[datetime] = None) -> str:
+def get_time_label(
+    dt: Optional[datetime] = None,
+    night_start_hour: int = NIGHT_START_HOUR,
+    night_end_hour: int = NIGHT_END_HOUR,
+) -> str:
     """Return a human-readable label for the current time period."""
-    return "night" if is_nighttime(dt) else "daytime"
+    return "night" if is_nighttime(dt, night_start_hour, night_end_hour) else "daytime"
 
 
-def current_period_start(dt: Optional[datetime] = None) -> datetime:
+def current_period_start(
+    dt: Optional[datetime] = None,
+    night_start_hour: int = NIGHT_START_HOUR,
+    night_end_hour: int = NIGHT_END_HOUR,
+) -> datetime:
     """Return the local timestamp marking the start of the current period."""
     dt = dt or datetime.now()
     today = dt.replace(hour=0, minute=0, second=0, microsecond=0)
 
-    if is_nighttime(dt):
-        night_start = today.replace(hour=NIGHT_START_HOUR)
-        if dt.hour < NIGHT_END_HOUR:
-            night_start = (today - timedelta(days=1)).replace(hour=NIGHT_START_HOUR)
+    if is_nighttime(dt, night_start_hour, night_end_hour):
+        night_start = today.replace(hour=night_start_hour)
+        if dt.hour < night_end_hour:
+            night_start = (today - timedelta(days=1)).replace(hour=night_start_hour)
         return night_start
 
-    return today.replace(hour=NIGHT_END_HOUR)
+    return today.replace(hour=night_end_hour)