aiwcli 0.9.7 → 0.10.0

package/dist/templates/_shared/hooks/context_monitor.py

@@ -45,292 +45,226 @@ Hook JSON excludes system prompt, tools, MCP tokens. We add a baseline
 to compensate (~22.6k tokens typical). See:
 https://github.com/anthropics/claude-code/issues/13783
 """
-import json
 import sys
 from pathlib import Path
-from typing import Optional, Tuple
+from typing import Optional
 
 # Add parent directories to path for imports
 SCRIPT_DIR = Path(__file__).resolve().parent
 SHARED_LIB = SCRIPT_DIR.parent / "lib"
 sys.path.insert(0, str(SHARED_LIB.parent))
 
-from lib.base.hook_utils import load_hook_input
-from lib.base.utils import eprint, project_dir
-from lib.context.context_manager import (
+from lib.base.hook_utils import emit_context, load_hook_input, get_context_percent_remaining, log_debug, log_info, log_warn, log_error, log_diagnostic
+from lib.base.utils import now_iso, project_dir
+from lib.context.context_store import (
     get_all_contexts,
     get_context_by_session_id,
-    update_plan_status,
+    maybe_activate,
+    save_state,
 )
 
-# Configuration
-LOW_CONTEXT_THRESHOLD = 40  # Warn when below 40% remaining
-CRITICAL_CONTEXT_THRESHOLD = 25  # Urgent warning below 25%
-
-# Context baseline: preloaded tokens not visible to hooks (~22.6k typical)
-# This includes system prompt, tools, MCP tokens that aren't in hook data
-CONTEXT_BASELINE = 22_600
-
-# Default context window size (used when not provided in hook input)
-DEFAULT_CONTEXT_WINDOW = 200_000
+# Module-level flag: only save auto-state once per process lifetime
+_PROGRESSIVE_SAVE_MARKER = ".progressive-save-done"
 
-
-def get_context_tokens_from_hook(hook_input: dict) -> Tuple[Optional[int], Optional[int]]:
-    """
-    Extract actual token counts from Claude Code hook input.
-
-    Claude Code provides context_window data with actual token counts:
-    - cache_read_input_tokens: Tokens read from cache
-    - input_tokens: New input tokens
-    - cache_creation_input_tokens: Tokens written to cache
-    - output_tokens: Model output tokens
-
-    Args:
-        hook_input: Hook input data from Claude Code
-
-    Returns:
-        Tuple of (tokens_used, max_tokens) or (None, None) if not available
-    """
-    context_window = hook_input.get("context_window")
-    if not context_window:
-        return None, None
-
-    current_usage = context_window.get("current_usage")
-    if not current_usage:
-        return None, None
-
-    # Sum all token types
-    cache_read = current_usage.get("cache_read_input_tokens", 0) or 0
-    input_tokens = current_usage.get("input_tokens", 0) or 0
-    cache_creation = current_usage.get("cache_creation_input_tokens", 0) or 0
-    output_tokens = current_usage.get("output_tokens", 0) or 0
-
-    content_tokens = cache_read + input_tokens + cache_creation + output_tokens
-
-    # Add baseline for system prompt, tools, MCP tokens not in hook data
-    tokens_used = content_tokens + CONTEXT_BASELINE
-
-    # Get max context window from hook input
-    max_tokens = context_window.get("context_window_size") or DEFAULT_CONTEXT_WINDOW
-
-    return tokens_used, max_tokens
+# Configuration
+SAVE_STATE_THRESHOLD = 60  # Silently save auto-state at 60% remaining
+HANDOFF_SUGGEST_THRESHOLD = 30  # Gentle nudge at 30% remaining (70% used)
+HANDOFF_PREPARE_THRESHOLD = 20  # Stronger warning at 20% remaining (80% used)
+CRITICAL_CONTEXT_THRESHOLD = 10  # Urgent warning at 10% remaining (90% used)
 
 
 def get_current_context_id(project_root: Path = None) -> Optional[str]:
-    """
-    Determine the current active context.
-
-    Falls back to most recently active context.
-
-    Returns:
-        Context ID or None if no active context
-    """
+    """Determine the current active context (most recently active)."""
     contexts = get_all_contexts(status="active", project_root=project_root)
     if contexts:
-        return contexts[0].id  # Sorted by last_active desc
+        return contexts[0].id
     return None
 
 
 def get_context_warning(
     percent_remaining: int,
-    tokens_used: int,
-    max_tokens: int,
+    tokens_used: Optional[int],
+    max_tokens: Optional[int],
     context_id: Optional[str],
     tool_name: str
 ) -> str:
-    """
-    Generate appropriate warning based on context level.
-
-    Args:
-        percent_remaining: Percentage of context remaining
-        tokens_used: Estimated tokens used
-        max_tokens: Maximum context window
-        context_id: Current context ID (if any)
-        tool_name: Tool that triggered this check
+    """Generate appropriate warning based on context level."""
+    if tokens_used is not None and max_tokens is not None:
+        tokens_used_k = tokens_used // 1000
+        max_tokens_k = max_tokens // 1000
+        usage_line = f"**Estimated usage**: ~{tokens_used_k}k / {max_tokens_k}k tokens"
+    else:
+        usage_line = f"**Estimated usage**: ~{percent_remaining}% remaining"
 
-    Returns:
-        System reminder markdown
-    """
-    # Format token counts
-    tokens_used_k = tokens_used // 1000
-    max_tokens_k = max_tokens // 1000
+    context_line = f"\nContext ID: `{context_id}`" if context_id else ""
 
     if percent_remaining <= CRITICAL_CONTEXT_THRESHOLD:
-        urgency = "CRITICAL"
-        instruction = "You MUST wrap up immediately and create a handoff document."
-    else:
-        urgency = "LOW"
-        instruction = "Please wrap up your current task and prepare for handoff."
+        return f"""<system-reminder>
+## CRITICAL CONTEXT WARNING ({percent_remaining}% remaining)
 
-    context_info = ""
-    if context_id:
-        context_info = f"""
-To create a handoff document, use the /handoff command or describe:
-- What you were working on
-- What's completed
-- What still needs to be done
-- Any important decisions or context
+{usage_line}
+**Triggered by**: {tool_name} tool completion
+
+**CRITICAL: Run `/handoff` now before context is compacted.**
+{context_line}
 
-Context ID: `{context_id}`"""
+You are about to lose context. Stop all other work and run `/handoff` immediately.
+</system-reminder>"""
 
-    return f"""<system-reminder>
-## {urgency} CONTEXT WARNING ({percent_remaining}% remaining)
+    elif percent_remaining <= HANDOFF_PREPARE_THRESHOLD:
+        return f"""<system-reminder>
+## LOW CONTEXT WARNING ({percent_remaining}% remaining)
 
-**Estimated usage**: ~{tokens_used_k}k / {max_tokens_k}k tokens
+{usage_line}
 **Triggered by**: {tool_name} tool completion
 
-{instruction}
-{context_info}
+**Context is getting low. Please finish your current task and run `/handoff`.**
+{context_line}
 
 **Actions:**
 1. Complete your current atomic task (if 1-2 steps away)
 2. Do NOT start new multi-step work
-3. Create a handoff document summarizing progress
-4. Ask user: "Context is getting low. I've summarized my progress. Should we continue in a new session?"
+3. Run `/handoff` to generate a handoff document
 </system-reminder>"""
 
+    else:
+        return f"""<system-reminder>
+## CONTEXT NOTICE ({percent_remaining}% remaining)
+
+{usage_line}
+**Triggered by**: {tool_name} tool completion
 
-def check_and_transition_mode(hook_input: dict) -> None:
-    """
-    Check if context needs to transition to implementing mode.
+**Consider preparing a handoff soon. When ready, run `/handoff` to generate a handoff document.**
+{context_line}
 
-    This handles two cases:
-    1. Plan was approved (pending_implementation) and implementation tools are used
-    2. Plan was in planning mode but permission_mode is no longer "plan"
-       (e.g., after /clear which clears permissions and pastes the plan)
+Continue your current work, but avoid starting large new tasks.
+</system-reminder>"""
 
-    If we're seeing tool usage (Edit, Write, Bash) and either:
-    - Context is in "pending_implementation", OR
-    - Context is in "planning" and permission_mode is not "plan"
-    We transition to "implementing".
 
-    Args:
-        hook_input: Hook input data from Claude Code
+def check_and_transition_mode(hook_input: dict) -> None:
     """
-    # Only transition on tools that indicate implementation work
-    implementation_tools = {"Edit", "Write", "Bash", "NotebookEdit"}
-    tool_name = hook_input.get("tool_name", "")
-
-    if tool_name not in implementation_tools:
-        return
+    Check if context mode needs to transition based on tool usage.
 
+    Handles:
+    - has_plan + implementation tool -> active (started implementing)
+    - idle + implementation tool -> active
+    """
     project_root = project_dir(hook_input)
     session_id = hook_input.get("session_id")
 
     if not session_id:
         return
 
-    # Get context for this session
-    context = get_context_by_session_id(session_id, project_root)
-    if not context:
+    state = get_context_by_session_id(session_id, project_root)
+    if not state:
         return
 
-    if not context.in_flight:
+    # Implementation transitions only trigger on implementation tools
+    implementation_tools = {"Edit", "Write", "Bash", "NotebookEdit"}
+    tool_name = hook_input.get("tool_name", "")
+
+    if tool_name not in implementation_tools:
         return
 
-    current_mode = context.in_flight.mode
     permission_mode = hook_input.get("permission_mode", "default")
+    maybe_activate(state.id, permission_mode, project_root=project_root, caller="context_monitor")
 
-    # Transition from pending_implementation to implementing
-    if current_mode == "pending_implementation":
-        eprint(f"[context_monitor] Transitioning {context.id} from pending_implementation to implementing")
-        update_plan_status(context.id, "implementing", project_root=project_root)
 
-    # Transition from planning to implementing if permission_mode is not "plan"
-    elif current_mode == "planning" and permission_mode != "plan":
-        eprint(f"[context_monitor] Transitioning {context.id} from planning to implementing (permission_mode={permission_mode})")
-        update_plan_status(context.id, "implementing", project_root=project_root)
+def _try_progressive_save(hook_input: dict, percent_remaining: int) -> None:
+    """Silently save state at SAVE_STATE_THRESHOLD (60%)."""
+    try:
+        session_id = hook_input.get("session_id", "")
+        if not session_id:
+            return
 
+        project_root = project_dir(hook_input)
+        state = get_context_by_session_id(session_id, project_root)
+        if not state:
+            return
 
-def check_context_level(hook_input: dict) -> Optional[str]:
-    """
-    Check context level and return warning if low.
+        from lib.base.constants import get_context_dir
+        marker_path = get_context_dir(state.id, project_root) / _PROGRESSIVE_SAVE_MARKER
+        if marker_path.exists():
+            try:
+                saved_session = marker_path.read_text(encoding="utf-8").strip()
+                if saved_session == session_id:
+                    return
+            except OSError:
+                pass
 
-    Optimized for fail-fast: checks cheap conditions first before any file I/O.
+        log_info("context_monitor", f"Progressive save at {percent_remaining}% remaining")
 
-    Args:
-        hook_input: Hook input data from Claude Code
+        # Just update last_active and save state
+        state.last_active = now_iso()
+        save_state(state, project_root)
 
-    Returns:
-        System reminder string if context is low, None otherwise
-    """
-    # === FAST PATH: No I/O, just dict lookups and math ===
+        try:
+            marker_path.write_text(session_id, encoding="utf-8")
+        except OSError:
+            pass
+
+    except Exception as e:
+        log_warn("context_monitor", f"Progressive save error (non-fatal): {e}")
 
-    # 1. Try to get context_window data (fast dict access)
-    tokens_used, max_tokens = get_context_tokens_from_hook(hook_input)
 
-    # 2. If no context_window data, exit immediately - can't monitor accurately
-    if tokens_used is None or max_tokens is None:
-        # Only log if we want to debug
-        # eprint("[context_monitor] context_window data unavailable")
-        return None
+def check_context_level(hook_input: dict) -> Optional[str]:
+    """Check context level and return warning if low."""
+    tool_name = hook_input.get("tool_name", "Unknown")
+    percent_remaining, tokens_used, max_tokens = get_context_percent_remaining(hook_input)
 
-    # 3. Calculate percentage (fast math)
-    remaining = max_tokens - tokens_used
-    percent_remaining = max(0, min(100, int((remaining / max_tokens) * 100)))
+    log_diagnostic("context_monitor", "receive", f"tool={tool_name}, pct_remaining={percent_remaining}",
+                    inputs={"tool_name": tool_name, "percent_remaining": percent_remaining,
+                            "tokens_used": tokens_used, "max_tokens": max_tokens})
+
+    if percent_remaining is None:
+        return None
 
-    # 4. Most common case: context is fine, exit early
-    if percent_remaining > LOW_CONTEXT_THRESHOLD:
+    if percent_remaining > SAVE_STATE_THRESHOLD:
         return None
 
-    # === SLOW PATH: Only reached when context is low (rare) ===
+    if percent_remaining > HANDOFF_SUGGEST_THRESHOLD:
+        _try_progressive_save(hook_input, percent_remaining)
+        return None
 
-    # Log since we're in warning territory
-    eprint(f"[context_monitor] Context: {percent_remaining}% remaining "
-           f"(~{tokens_used//1000}k/{max_tokens//1000}k tokens)")
+    if tokens_used is not None and max_tokens is not None:
+        log_info("context_monitor", f"Context: {percent_remaining}% remaining "
+                 f"(~{tokens_used//1000}k/{max_tokens//1000}k tokens)")
+    else:
+        log_info("context_monitor", f"Context: ~{percent_remaining}% remaining (from context.json)")
 
-    # Get current context for handoff info (file I/O)
     project_root = project_dir(hook_input)
     context_id = get_current_context_id(project_root)
 
-    tool_name = hook_input.get("tool_name", "Unknown")
+    threshold = ("critical" if percent_remaining <= CRITICAL_CONTEXT_THRESHOLD
+                 else "prepare" if percent_remaining <= HANDOFF_PREPARE_THRESHOLD
+                 else "suggest")
+    log_diagnostic("context_monitor", "decide", f"Threshold={threshold} at {percent_remaining}%",
+                    decision=threshold, reasoning=f"{percent_remaining}% remaining",
+                    inputs={"context_id": context_id, "percent_remaining": percent_remaining})
 
-    return get_context_warning(
-        percent_remaining,
-        tokens_used,
-        max_tokens,
-        context_id,
-        tool_name
-    )
+    return get_context_warning(percent_remaining, tokens_used, max_tokens, context_id, tool_name)
 
 
 def main():
-    """
-    Main entry point for PostToolUse hook.
-
-    Reads hook input from stdin, checks for mode transitions,
-    and prints system reminder if context is low.
-    """
+    """Main entry point for PostToolUse hook."""
     try:
-        # Read hook input using shared utility
         hook_input = load_hook_input()
-
         if not hook_input:
             return
 
-        # Always check for mode transitions on implementation tools
-        # This handles the case where /clear pastes the plan with non-plan permission mode
         check_and_transition_mode(hook_input)
 
-        # Check context level
         warning = check_context_level(hook_input)
-
         if warning:
-            # Output JSON with additionalContext so Claude sees the warning
-            # Plain stdout from PostToolUse only goes to verbose mode, not Claude's context
-            output = {
-                "hookSpecificOutput": {
-                    "hookEventName": "PostToolUse",
-                    "additionalContext": warning
-                }
-            }
-            print(json.dumps(output))
+            emit_context(warning)
 
     except Exception as e:
-        eprint(f"[context_monitor] ERROR: {e}")
         import traceback
-        eprint(traceback.format_exc())
+        tb = traceback.format_exc()
+        from lib.base.hook_utils import log_hook_error
+        log_hook_error("context_monitor", e, "PostToolUse", traceback_str=tb)
 
 
 if __name__ == "__main__":
-    main()
+    from lib.base.hook_utils import run_hook
+    run_hook(main, "context_monitor")

package/dist/templates/_shared/hooks/file-suggestion.py

@@ -28,17 +28,17 @@ SCRIPT_DIR = Path(__file__).resolve().parent
 SHARED_LIB = SCRIPT_DIR.parent / "lib"
 sys.path.insert(0, str(SHARED_LIB.parent))
 
-from lib.base.hook_utils import load_hook_input
-from lib.base.utils import eprint, project_dir
+from lib.base.hook_utils import load_hook_input, log_debug, log_info, log_error
+from lib.base.utils import project_dir
 from lib.base.constants import (
     get_context_plans_dir,
     get_context_handoffs_dir,
     get_context_reviews_dir,
     get_context_file_path,
 )
-from lib.context.context_manager import (
+from lib.context.context_store import (
     get_context_by_session_id,
-    get_all_in_flight_contexts,
+    get_all_contexts,
     get_context,
 )
 
@@ -66,7 +66,7 @@ def get_context_files(context_id: str, project_root: Path) -> List[str]:
     context_file = get_context_file_path(context_id, project_root)
     if context_file.exists():
         files.append(str(context_file))
-        eprint(f"[file-suggestion] Found context file for {context_id}")
+        log_debug("file-suggestion", f"Found context file for {context_id}")
 
     # Get plans directory
     plans_dir = get_context_plans_dir(context_id, project_root)
@@ -75,7 +75,7 @@ def get_context_files(context_id: str, project_root: Path) -> List[str]:
         # Sort by modification time, most recent first
         plan_files.sort(key=lambda p: p.stat().st_mtime, reverse=True)
         files.extend([str(p) for p in plan_files])
-        eprint(f"[file-suggestion] Found {len(plan_files)} plans in {context_id}")
+        log_debug("file-suggestion", f"Found {len(plan_files)} plans in {context_id}")
 
     # Get handoffs - prefer folder-based (index.md in subdirectories), fall back to legacy
     handoffs_dir = get_context_handoffs_dir(context_id, project_root)
@@ -92,14 +92,14 @@ def get_context_files(context_id: str, project_root: Path) -> List[str]:
             index_file = handoff_folders[0] / "index.md"
             if index_file.exists():
                 files.append(str(index_file))
-                eprint(f"[file-suggestion] Found handoff folder: {handoff_folders[0].name}")
+                log_debug("file-suggestion", f"Found handoff folder: {handoff_folders[0].name}")
         else:
             # Legacy support: flat .md files directly in handoffs/
             legacy_handoffs = [f for f in handoffs_dir.glob("*.md") if f.is_file()]
             legacy_handoffs.sort(key=lambda p: p.stat().st_mtime, reverse=True)
             if legacy_handoffs:
                 files.append(str(legacy_handoffs[0]))  # Only most recent legacy
-                eprint(f"[file-suggestion] Found {len(legacy_handoffs)} legacy handoffs in {context_id}")
+                log_debug("file-suggestion", f"Found {len(legacy_handoffs)} legacy handoffs in {context_id}")
 
     # Get reviews - prefer folder-based (index.md in subdirectories), fall back to legacy
     reviews_dir = get_context_reviews_dir(context_id, project_root) / "cc-native"
@@ -116,13 +116,13 @@ def get_context_files(context_id: str, project_root: Path) -> List[str]:
             index_file = review_folders[0] / "index.md"
             if index_file.exists():
                 files.append(str(index_file))
-                eprint(f"[file-suggestion] Found review folder: {review_folders[0].name}")
+                log_debug("file-suggestion", f"Found review folder: {review_folders[0].name}")
         else:
             # Legacy support: flat review.md directly in cc-native/
             legacy_review = reviews_dir / "review.md"
             if legacy_review.exists():
                 files.append(str(legacy_review))
-                eprint(f"[file-suggestion] Found legacy review.md in {context_id}")
+                log_debug("file-suggestion", f"Found legacy review.md in {context_id}")
 
     return files
 
@@ -147,16 +147,17 @@ def get_active_context_id(session_id: str, project_root: Path) -> Optional[str]:
     if session_id and session_id != "unknown":
         context = get_context_by_session_id(session_id, project_root)
         if context:
-            eprint(f"[file-suggestion] Found context by session: {context.id}")
+            log_debug("file-suggestion", f"Found context by session: {context.id}")
             return context.id
 
-    # Fall back to single in-flight context
-    in_flight = get_all_in_flight_contexts(project_root)
-    if len(in_flight) == 1:
-        eprint(f"[file-suggestion] Using single in-flight context: {in_flight[0].id}")
-        return in_flight[0].id
+    # Fall back to single active (non-idle) context
+    active = [c for c in get_all_contexts(status="active", project_root=project_root)
+              if c.mode != "idle"]
+    if len(active) == 1:
+        log_debug("file-suggestion", f"Using single active context: {active[0].id}")
+        return active[0].id
 
-    eprint(f"[file-suggestion] No unique context found (in-flight: {len(in_flight)})")
+    log_debug("file-suggestion", f"No unique context found (active: {len(active)})")
     return None
 
 
@@ -179,7 +180,7 @@ def main():
         project_root = project_dir(hook_input)
         session_id = hook_input.get("session_id", "unknown")
 
-        eprint(f"[file-suggestion] Session: {session_id[:8]}..., Project: {project_root}")
+        log_debug("file-suggestion", f"Session: {session_id[:8]}..., Project: {project_root}")
 
         # Determine active context
         context_id = get_active_context_id(session_id, project_root)
@@ -194,19 +195,21 @@ def main():
         # Limit suggestions to prevent overwhelming the context
         MAX_SUGGESTIONS = 10
         if len(suggestions) > MAX_SUGGESTIONS:
-            eprint(f"[file-suggestion] Limiting suggestions to {MAX_SUGGESTIONS} (was {len(suggestions)})")
+            log_debug("file-suggestion", f"Limiting suggestions to {MAX_SUGGESTIONS} (was {len(suggestions)})")
             suggestions = suggestions[:MAX_SUGGESTIONS]
 
         # Output suggestions as JSON array
-        eprint(f"[file-suggestion] Suggesting {len(suggestions)} files")
+        log_info("file-suggestion", f"Suggesting {len(suggestions)} files")
         print(json.dumps(suggestions))
 
     except Exception as e:
-        eprint(f"[file-suggestion] ERROR: {e}")
         import traceback
-        eprint(traceback.format_exc())
+        tb = traceback.format_exc()
+        from lib.base.hook_utils import log_hook_error
+        log_hook_error("file-suggestion", e, "SessionStart", traceback_str=tb)
         print("[]")
 
 
 if __name__ == "__main__":
-    main()
+    from lib.base.hook_utils import run_hook
+    run_hook(main, "file_suggestion")

package/dist/templates/_shared/hooks/pre_compact.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""PreCompact hook - saves auto-state before context compaction.
+
+Critical: saves state before context compaction destroys token history.
+After compaction, SessionStart fires with source="compact" and the
+restored auto-state provides continuity context.
+
+Hook input (from Claude Code):
+{
+    "hook_event_name": "PreCompact",
+    "session_id": "abc123",
+    "transcript_path": "/path/to/transcript.jsonl",
+    "cwd": "/path/to/project",
+    ...
+}
+
+Hook output:
+- Silent (no stdout output needed)
+- Logs to stderr for debugging
+"""
+import sys
+from pathlib import Path
+
+# Add parent directories to path for imports
+SCRIPT_DIR = Path(__file__).resolve().parent
+SHARED_LIB = SCRIPT_DIR.parent / "lib"
+sys.path.insert(0, str(SHARED_LIB.parent))
+
+from lib.base.hook_utils import load_hook_input, log_debug, log_info, log_error
+from lib.base.utils import project_dir
+from lib.context.context_store import get_context_by_session_id, save_state
+
+
+def main():
+    """Save auto-state before compaction."""
+    try:
+        hook_input = load_hook_input()
+        if not hook_input:
+            return
+
+        session_id = hook_input.get("session_id", "")
+        transcript_path = hook_input.get("transcript_path")
+        project_root = project_dir(hook_input)
+
+        if not session_id:
+            log_debug("pre_compact", "No session_id, skipping")
+            return
+
+        log_info("pre_compact", f"Saving state before compaction: {session_id[:8]}...")
+
+        # Find context bound to this session
+        context = get_context_by_session_id(session_id, project_root)
+        if not context:
+            log_debug("pre_compact", "No context bound to this session, skipping")
+            return
+
+        # Save last_session snapshot directly to state.json
+        import subprocess
+        git_state = {}
+        try:
+            branch = subprocess.run(
+                ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+                capture_output=True, text=True, timeout=5
+            )
+            git_state["branch"] = branch.stdout.strip() if branch.returncode == 0 else "unknown"
+
+            status = subprocess.run(
+                ["git", "status", "--short"],
+                capture_output=True, text=True, timeout=5
+            )
+            if status.returncode == 0 and status.stdout.strip():
+                git_state["uncommitted_files"] = [
+                    line.split(None, 1)[-1] for line in status.stdout.strip().split("\n")[:10]
+                ]
+
+            log = subprocess.run(
+                ["git", "log", "-1", "--format=%h %s"],
+                capture_output=True, text=True, timeout=5
+            )
+            if log.returncode == 0:
+                git_state["last_commit_short"] = log.stdout.strip()
+        except Exception:
+            pass
+
+        from lib.base.utils import now_iso
+        context.last_session = {
+            "session_id": session_id,
+            "saved_at": now_iso(),
+            "save_reason": "pre_compact",
+            "git_state": git_state,
+        }
+        save_state(context, project_root)
+        log_info("pre_compact", f"State saved for {context.id}")
+
+    except Exception as e:
+        import traceback
+        tb = traceback.format_exc()
+        from lib.base.hook_utils import log_hook_error
+        log_hook_error("pre_compact", e, "PreCompact", traceback_str=tb)
+
+
+if __name__ == "__main__":
+    from lib.base.hook_utils import run_hook
+    run_hook(main, "pre_compact")