Replace stop/handoff with warn-only — compaction continues session

Sessions never stop. Context pressure is handled by Claude Code's
built-in compaction. Session limits and drift detection only warn
so the agent wraps up current work instead of starting new tasks.

Removed: grace periods, stopped states, auto-handoff triggers from
session_limits. PostCompact just increments counter and warns.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: jvalin17

hooks/session_limits.py

@@ -1,9 +1,12 @@
-"""Session limit enforcement (grace period, handoff triggers) for PreToolUse."""
+"""Session limit enforcement — warn only, never stop.
+
+Sessions continue through compaction. Limits produce warnings
+so the agent prioritizes current work over starting new tasks.
+No handoff, no stop, no restart — compaction handles context pressure.
+"""
 
-from auto_handoff import trigger_auto_handoff
 from session_state import (
     FALLBACK_MAX_EXCHANGES,
-    GRACE_TOOL_CALLS,
     HARD_THRESHOLD_BYTES,
     SessionState,
     check_thresholds,
@@ -12,81 +15,29 @@
 
 
 def apply_session_limits(state: SessionState) -> tuple:
-    """Apply byte/time/compaction limits. Returns (state, response_message).
+    """Apply byte/time limits. Returns (state, response_message).
 
-    When continue_mode is False, limits only warn — no handoff, no stop.
-    Stopping a session without auto-restart is pointless.
+    Never stops the session. Warns once when thresholds are hit
+    so the agent wraps up current work instead of starting new tasks.
+    Compaction handles context pressure naturally.
     """
     triggered, stop_reason = check_thresholds(state)
 
-    if triggered and not state.continue_mode:
-        # No auto-restart — just warn, don't kill the session
-        if not state.warned:
-            state.warned = True
-            return state, (
-                f"SESSION LIMIT WARNING: {stop_reason}. "
-                f"Auto-continuation is off, so the session will continue. "
-                f"Quality may degrade. Consider wrapping up current work."
-            )
-        return state, ""
-
-    if triggered:
-        return _handle_limit_triggered(state, stop_reason)
+    if triggered and not state.warned:
+        state.warned = True
+        return state, (
+            f"SESSION LIMIT: {stop_reason}. "
+            f"The session will continue (compaction handles context pressure). "
+            f"Quality may degrade. Wrap up current work before starting new tasks."
+        )
 
     if should_warn(state) and not state.warned:
         state.warned = True
-        response = (
+        return state, (
             f"SESSION WARNING: {state.exchanges}/{FALLBACK_MAX_EXCHANGES} exchanges, "
             f"{state.cumulative_output_bytes:,}/{HARD_THRESHOLD_BYTES:,} bytes. "
-            f"You are approaching the session limit. Finish current work "
+            f"Approaching session limit. Finish current work "
             f"and do not start new slabs or features."
         )
-        return state, response
 
     return state, ""
-
-
-def _handle_limit_triggered(state: SessionState, stop_reason: str) -> tuple:
-    """Handle limit when continue_mode is True — write handoff and stop."""
-    is_time_triggered = "minutes" in stop_reason
-
-    if is_time_triggered and state.stopped < 2:
-        state.stopped = 2
-        trigger_auto_handoff(state, stop_reason)
-        return state, (
-            f"SESSION TIME LIMIT: {stop_reason}.\n\n"
-            f"HANDOFF.md has been written automatically by the hook.\n"
-            f"A fresh session will be launched automatically.\n"
-            f"Finish your current task, then write HANDOFF.md."
-        )
-
-    if state.stopped == 0:
-        state.stopped = 1
-        state.stop_at_tool_call = state.tool_calls + GRACE_TOOL_CALLS
-        return state, (
-            f"SESSION LIMIT REACHED: {stop_reason}. "
-            f"You have {GRACE_TOOL_CALLS} tool calls remaining to wrap up.\n\n"
-            f"Finish your current task, then IMMEDIATELY:\n"
-            f"1. Write HANDOFF.md — current status, what's done (commits), "
-            f"what's next (spec text copied, not summarized), decisions, "
-            f"code change plan for next slab\n"
-            f"2. Update project-state.md Resume section\n"
-            f"3. A fresh session will be launched automatically after this one ends.\n\n"
-            f"Do NOT start new tasks. Finish current task and hand off."
-        )
-
-    grace_remaining = state.stop_at_tool_call - state.tool_calls
-    if grace_remaining <= 0:
-        if state.stopped != 2:
-            state.stopped = 2
-            trigger_auto_handoff(state, stop_reason)
-        return state, (
-            f"HARD STOP: Grace period exhausted. {stop_reason}.\n\n"
-            f"HANDOFF.md has been written automatically by the hook.\n"
-            f"A fresh session will be launched automatically."
-        )
-
-    return state, (
-        f"SESSION LIMIT: {grace_remaining} tool calls remaining "
-        f"before hard stop. Finish current work and write HANDOFF.md."
-    )

hooks/session_monitor.py

@@ -73,19 +73,11 @@ def _strict_integrity_response(state: SessionState) -> Optional[str]:
         f"- Drift score: {drift:.2f}\n"
     )
     if drift > 0.8:
-        if state.continue_mode:
-            response += (
-                "\nCRITICAL DRIFT: Score exceeds 0.8. SESSION RESTART required.\n"
-                "Write HANDOFF.md immediately and exit. "
-                "A fresh session will be launched automatically."
-            )
-            state.stopped = 2
-        else:
-            response += (
-                "\nCRITICAL DRIFT: Score exceeds 0.8. "
-                "Query the real system before continuing. "
-                "Quality is degrading."
-            )
+        response += (
+            "\nCRITICAL DRIFT: Score exceeds 0.8. "
+            "Query the real system before continuing. "
+            "Quality is degrading."
+        )
     elif drift > 0.6:
         response += (
             "\nHIGH DRIFT: Score exceeds 0.6. "
@@ -206,20 +198,17 @@ def handle_post_tool_use(
 
 
 def handle_post_compact(state: SessionState) -> tuple:
-    """Handle PostCompact event. Context was compressed — trigger auto-handoff."""
-    state.compactions += 1
+    """Handle PostCompact event. Context was compressed — session continues.
 
-    stop_reason = (
-        f"Context compacted ({state.compactions} time(s)) "
-        f"— context window is full"
-    )
-    trigger_auto_handoff(state, stop_reason)
-    state.stopped = 2
+    Compaction is normal. The session keeps running with compressed context.
+    We just note it and warn that quality may degrade.
+    """
+    state.compactions += 1
 
     response = (
-        "CONTEXT COMPACTED: Context window was compressed by Claude Code. "
-        "HANDOFF.md has been written automatically by the hook. "
-        "Finish your current task, then write HANDOFF.md."
+        f"CONTEXT COMPACTED ({state.compactions}x): Claude Code compressed the context. "
+        f"The session continues. Quality may degrade with repeated compactions. "
+        f"Consider wrapping up current work."
     )
     return state, response