State Management

{
  "session_start": 1709486400.0,
  "last_micro": 1709486400.0,
  "last_full": 1709486400.0,
  "last_hydration": 1709486400.0,
  "reminder_count": 0,
  "last_active": 1709486400.0,
  "last_response_end": 1709486400.0,
  "pending_break": null,
  "tip_index": {
    "micro_break": 0,
    "full_break": 0,
    "hydration": 0
  },
  "last_reminder_fired_at": 0
}

REQUIRED_KEYS = ["session_start", "last_micro", "last_full", "last_hydration",
                 "reminder_count", "last_active", "last_response_end"]

def fresh_state():
    """Return a fresh state dict with all timers set to now."""
    now = time.time()
    return {
        "session_start": now,
        "last_micro": now,
        "last_full": now,
        "last_hydration": now,
        "reminder_count": 0,
        "last_active": now,
        "last_response_end": now,
        "pending_break": None,
        "tip_index": {"micro_break": 0, "full_break": 0, "hydration": 0},
        "last_reminder_fired_at": 0,
    }

def load_state():
    """Load state file, returning fresh state if missing or corrupt."""
    try:
        with open(STATE_PATH, "r") as f:
            state = json.load(f)
        for key in REQUIRED_KEYS:
            if key not in state:
                raise KeyError(key)
        return state
    except (FileNotFoundError, json.JSONDecodeError, KeyError):
        state = fresh_state()
        save_state(state)
        return state

def save_state(state):
    """Write state to disk atomically (temp file + rename)."""
    os.makedirs(os.path.dirname(STATE_PATH), exist_ok=True)
    tmp = STATE_PATH + ".tmp"
    with open(tmp, "w") as f:
        json.dump(state, f, indent=2)
    os.rename(tmp, STATE_PATH)

@contextmanager
def state_lock(blocking=True, timeout=1.0):
    """Context manager for exclusive file locking.

    blocking=True:  wait indefinitely for the lock (sync hooks)
    blocking=False: try for `timeout` seconds, raise TimeoutError if can't acquire
    """
    os.makedirs(os.path.dirname(LOCK_PATH), exist_ok=True)
    lock_fd = open(LOCK_PATH, "a")
    try:
        if blocking:
            fcntl.flock(lock_fd, fcntl.LOCK_EX)
        else:
            deadline = time.time() + timeout
            while True:
                try:
                    fcntl.flock(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
                    break
                except (IOError, OSError):
                    if time.time() >= deadline:
                        lock_fd.close()
                        raise TimeoutError("Could not acquire state lock")
                    time.sleep(0.05)
        yield
    finally:
        try:
            fcntl.flock(lock_fd, fcntl.LOCK_UN)
            lock_fd.close()
        except Exception:
            pass

with state_lock(blocking=True):
    state = load_state()
    # ... modify state ...
    save_state(state)

if existing and (now - existing["last_active"]) < STALE_THRESHOLD:
    existing["last_active"] = now
    state = existing
    msg = (
        "✨ Vibe Check joined an active session. "
        "Health tracking continues where you left off!"
    )

# --- Stale session check ---
# Catches long-running sessions left open overnight
if now - state.get("last_active", now) >= STALE_THRESHOLD:
    state = fresh_state()
    save_state(state)
    return

state["pending_break"] = {"type": "full", "fired_at": now}

if pending:
    break_type = pending.get("type")
    threshold = COMPLIANCE_THRESHOLDS.get(break_type, 120)
    if response_gap >= threshold:
        # User took the break — reset that timer
        if break_type == "full":
            state["last_full"] = now
            state["last_micro"] = now
            state["last_hydration"] = now
    state["pending_break"] = None

# --- Layer 2: Spontaneous break detection ---
elif response_gap >= SPONTANEOUS_BREAK_THRESHOLD:
    state["last_micro"] = now
    state["last_full"] = now
    state["last_hydration"] = now

# --- Cross-session dedup guard ---
DEDUP_WINDOW = 30  # seconds
if now - state.get("last_reminder_fired_at", 0) < DEDUP_WINDOW:
    state["last_active"] = now
    save_state(state)
    return