aiwcli 0.9.7 → 0.10.0

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

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+"""SessionEnd hook - saves session state to state.json.
+
+Fires when session terminates (quit, /clear, logout). Saves last_session
+data directly to state.json for restoration on next session.
+
+Hook input (from Claude Code):
+{
+    "hook_event_name": "SessionEnd",
+    "session_id": "abc123",
+    "source": "prompt_input_exit",  # or "clear", "logout", "compact"
+    "transcript_path": "/path/to/transcript.jsonl",
+    "cwd": "/path/to/project",
+    ...
+}
+
+Hook output:
+- Silent (no stdout output needed for SessionEnd)
+- Logs to stderr for debugging
+"""
+import hashlib
+import subprocess
+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_warn, log_error, log_diagnostic
+from lib.base.utils import now_iso, project_dir
+from lib.context.context_store import get_context_by_session_id, save_state
+from lib.context.plan_manager import find_latest_plan, normalize_plan_content, generate_plan_id, extract_plan_anchors
+
+
+def _get_git_state(project_root: Path) -> dict:
+    """Capture current git state for restoration."""
+    git_state = {}
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            capture_output=True, text=True, cwd=str(project_root), timeout=5,
+        )
+        if result.returncode == 0:
+            git_state["branch"] = result.stdout.strip()
+
+        result = subprocess.run(
+            ["git", "diff", "--name-only"],
+            capture_output=True, text=True, cwd=str(project_root), timeout=5,
+        )
+        if result.returncode == 0:
+            files = [f for f in result.stdout.strip().split("\n") if f]
+            git_state["uncommitted_files"] = files
+
+        result = subprocess.run(
+            ["git", "log", "-1", "--oneline"],
+            capture_output=True, text=True, cwd=str(project_root), timeout=5,
+        )
+        if result.returncode == 0:
+            git_state["last_commit_short"] = result.stdout.strip()
+    except Exception as e:
+        log_warn("session_end", f"Git state capture error (non-fatal): {e}")
+
+    return git_state
+
+
+def main():
+    """Save session state to state.json."""
+    try:
+        hook_input = load_hook_input()
+        if not hook_input:
+            return
+
+        session_id = hook_input.get("session_id", "")
+        source = hook_input.get("source", "other")
+        transcript_path = hook_input.get("transcript_path")
+        project_root = project_dir(hook_input)
+
+        if not session_id:
+            log_debug("session_end", "No session_id, skipping")
+            return
+
+        log_info("session_end", f"Session ending: {session_id[:8]}... reason={source}")
+        log_diagnostic("session_end", "receive", f"session={session_id[:8]}, source={source}",
+                        inputs={"session_id": session_id[:12], "source": source})
+
+        # Find context bound to this session
+        state = get_context_by_session_id(session_id, project_root)
+        if not state:
+            log_debug("session_end", "No context bound to this session, skipping")
+            return
+
+        log_info("session_end", f"Found context: {state.id}")
+
+        # Capture git state
+        git_state = _get_git_state(project_root)
+
+        # Save last_session directly to state.json
+        state.last_session = {
+            "session_id": session_id,
+            "save_reason": source,
+            "saved_at": now_iso(),
+            "transcript_path": transcript_path,
+            "git_state": git_state,
+        }
+        state.last_active = now_iso()
+
+        # Fallback: assign plan fields if PostToolUse:ExitPlanMode didn't fire.
+        # When ExitPlanMode triggers /clear, the session terminates before PostToolUse
+        # hooks can run, so plan_accepted.py never fires. Detect this by checking
+        # for an archived plan that hasn't been assigned yet.
+        if not state.plan_hash:
+            latest_plan_path = find_latest_plan(state.id, project_root)
+            if latest_plan_path:
+                try:
+                    content = Path(latest_plan_path).read_text(encoding="utf-8")
+                    normalized = normalize_plan_content(content)
+                    state.plan_hash = hashlib.sha256(normalized.encode("utf-8")).hexdigest()[:12]
+                    state.plan_path = latest_plan_path
+                    state.plan_signature = content[:200]
+                    state.plan_id = generate_plan_id()
+                    state.plan_anchors = extract_plan_anchors(content)
+                    log_info("session_end", f"Fallback: assigned archived plan for {state.id} (hash: {state.plan_hash})")
+                except Exception as e:
+                    log_warn("session_end", f"Fallback plan assignment failed: {e}")
+
+        # If a plan is assigned and mode is active, stage it for next session
+        if state.plan_hash and state.mode == "active":
+            state.mode = "has_plan"
+            log_info("session_end", f"Staged plan for next session: {state.id} -> has_plan")
+            log_diagnostic("session_end", "decide", f"Staging plan for {state.id}",
+                            decision="stage_plan", reasoning="plan_hash exists and mode was active",
+                            inputs={"plan_hash": state.plan_hash, "mode_transition": "active->has_plan"})
+
+        if save_state(state, project_root):
+            log_info("session_end", f"Saved last_session for {state.id}")
+            log_diagnostic("session_end", "result", f"Saved state for {state.id}",
+                            decision="saved", inputs={"context_id": state.id, "mode": state.mode,
+                                                       "has_plan_hash": bool(state.plan_hash),
+                                                       "git_files": len(git_state.get("uncommitted_files", []))})
+        else:
+            log_error("session_end", f"Failed to save state for {state.id}")
+
+    except Exception as e:
+        import traceback
+        tb = traceback.format_exc()
+        from lib.base.hook_utils import log_hook_error
+        log_hook_error("session_end", e, "SessionEnd", traceback_str=tb)
+
+
+if __name__ == "__main__":
+    from lib.base.hook_utils import run_hook
+    run_hook(main, "session_end")

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

@@ -1,18 +1,17 @@
 #!/usr/bin/env python3
-"""SessionStart hook for mode transitions after /clear.
+"""SessionStart hook for post-compaction and post-clear restore.
 
-This hook fires when a new session starts. It handles the critical transition
-from `pending_implementation` to `implementing` when a session starts after
-/clear with bypass permissions.
+This hook fires when a new session starts. It handles:
 
-The flow is:
-1. User approves plan (ExitPlanMode) -> mode = pending_implementation
-2. User clicks "yes and clear and bypass permissions"
-3. SessionStart fires with source="clear" and permission_mode="bypassPermissions"
-4. This hook transitions mode to "implementing"
+1. Post-clear restore (source="clear"): After ExitPlanMode "clear context",
+   Claude Code runs /clear and auto-pastes the plan. The auto-paste bypasses
+   all hooks (UserPromptSubmit never fires), so this hook bridges the gap:
+   find the has_plan context (set by session_end moments ago), bind the new
+   session, transition has_plan → active, and inject restoration context.
 
-Without this hook, the mode stays stuck at pending_implementation because
-UserPromptSubmit may not receive the correct permission_mode after /clear.
+2. Post-compaction restore (source="compact"): The session is already bound
+   to a context. Load state and inject rich restoration context so Claude
+   can continue seamlessly after compaction.
 
 Hook input:
 {
@@ -32,26 +31,127 @@ 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 (
-    get_all_in_flight_contexts,
-    update_plan_status,
-    update_context_session_id,
-)
+from lib.base.hook_utils import emit_context, load_hook_input, log_debug, log_info, log_error, log_diagnostic
+from lib.base.utils import project_dir
+from lib.context.context_store import get_context_by_session_id, get_all_contexts, bind_session, update_mode
+from lib.context.context_formatter import _build_restore_sections
 
 
-def main():
+def _handle_compact_restore(hook_input, session_id, project_root):
+    """
+    Handle post-compaction restore.
+
+    After compaction, the session is already bound to a context.
+    Load state and inject rich restoration context via additionalContext.
     """
-    Handle mode transitions on session start.
+    state = get_context_by_session_id(session_id, project_root)
+    if not state:
+        log_debug("session_start", "No context bound to session after compact")
+        return
+
+    log_info("session_start", f"Post-compaction restore for context: {state.id}")
+
+    # Build restoration context
+    mode_display = state.mode.replace("_", " ").title() if state.mode != "idle" else "Active"
+
+    lines = [
+        f"## Resuming Context After Compaction: {state.id}",
+        "",
+        f"**Summary:** {state.summary}",
+        f"**Mode:** {mode_display}",
+    ]
+
+    # Add restore sections (tasks, git state, plan content)
+    # inline_plan=True because plan content is NOT auto-pasted after compaction
+    restore = _build_restore_sections(state, project_root, inline_plan=True)
+    if restore:
+        lines.append(restore)
+
+    lines.extend([
+        "",
+        "---",
+        "",
+        "**Instructions:**",
+        "Context was compacted to free memory. Your previous conversation has been summarized.",
+        "1. Review the previous work above",
+        "2. Continue from where you left off",
+    ])
+
+    restore_context = "\n".join(lines)
+    emit_context(restore_context)
+    log_info("session_start", f"Injected post-compaction restore context for {state.id}")
+    log_diagnostic("session_start", "result", f"Compact restore complete for {state.id}",
+                    decision="injected", inputs={"context_id": state.id, "mode": state.mode})
+
+
+def _handle_clear_restore(hook_input, session_id, project_root):
+    """
+    Handle plan context restoration after /clear.
+
+    After ExitPlanMode "clear context", Claude Code auto-pastes the plan
+    but the auto-paste bypasses all hooks — UserPromptSubmit never fires.
+    This means the new session is never bound to a context.
 
-    When source is "clear" and permission_mode is "bypassPermissions" or "acceptEdits",
-    transition any pending_implementation context to implementing.
+    Fix: find the has_plan context (set by session_end moments ago),
+    bind the new session to it, and inject restoration context.
     """
+    # Find has_plan contexts (sorted by last_active descending)
+    has_plan = [
+        c for c in get_all_contexts(status="active", project_root=project_root)
+        if c.mode == "has_plan"
+    ]
+
+    if not has_plan:
+        log_debug("session_start", "No has_plan contexts found after /clear")
+        return
+
+    # Pick the most recently active one (first in list, already sorted)
+    target = has_plan[0]
+    log_info("session_start", f"Found has_plan context after /clear: {target.id}")
+
+    # Bind new session to this context
+    bind_session(target.id, session_id, project_root)
+    log_info("session_start", f"Bound session {session_id[:8]}... to {target.id}")
+
+    # Transition has_plan → active (consume the transient state)
+    update_mode(target.id, "active", project_root=project_root)
+    log_info("session_start", f"Transitioned {target.id}: has_plan -> active")
+
+    # Inject restoration context (tasks, git state, plan path reference)
+    # Plan CONTENT is not injected — Claude Code auto-pastes it after /clear
+    mode_display = "Active (Plan Restored)"
+    lines = [
+        f"## Resuming Context After Plan Clear: {target.id}",
+        "",
+        f"**Summary:** {target.summary}",
+        f"**Mode:** {mode_display}",
+    ]
+
+    restore = _build_restore_sections(target, project_root)
+    if restore:
+        lines.append(restore)
+
+    lines.extend([
+        "",
+        "---",
+        "",
+        "**Instructions:**",
+        "Context was cleared for plan implementation. Your plan content has been pasted above.",
+        "1. Review the plan content above",
+        "2. Implement the plan step by step",
+    ])
+
+    restore_context = "\n".join(lines)
+    emit_context(restore_context)
+    log_info("session_start", f"Injected clear-restore context for {target.id}")
+    log_diagnostic("session_start", "result", f"Clear restore complete for {target.id}",
+                    decision="injected", inputs={"context_id": target.id, "mode_transition": "has_plan->active"})
+
+
+def main():
+    """Handle post-compaction and post-clear restore on session start."""
     try:
-        # Read hook input using shared utility
         hook_input = load_hook_input()
-
         if not hook_input:
             return
 
@@ -60,44 +160,30 @@ def main():
         session_id = hook_input.get("session_id", "unknown")
         project_root = project_dir(hook_input)
 
-        eprint(f"[session_start] source={source}, permission_mode={permission_mode}, session={session_id[:8]}...")
-
-        # Only handle /clear with bypass/accept permissions
-        if source != "clear":
-            eprint(f"[session_start] Skipping: source is '{source}', not 'clear'")
-            return
-
-        if permission_mode == "plan":
-            eprint(f"[session_start] Skipping: permission_mode is 'plan' (in planning mode)")
-            return
-
-        # Find contexts in pending_implementation mode
-        in_flight_contexts = get_all_in_flight_contexts(project_root)
-        pending_contexts = [
-            ctx for ctx in in_flight_contexts
-            if ctx.in_flight and ctx.in_flight.mode == "pending_implementation"
-        ]
-
-        if not pending_contexts:
-            eprint("[session_start] No pending_implementation contexts found")
-            return
-
-        # Transition each pending context to implementing
-        for ctx in pending_contexts:
-            eprint(f"[session_start] Transitioning {ctx.id} from pending_implementation to implementing")
-            update_plan_status(ctx.id, "implementing", project_root=project_root)
-
-            # Also bind this session to the context
-            update_context_session_id(ctx.id, session_id, project_root)
-            eprint(f"[session_start] Bound session {session_id[:8]}... to context {ctx.id}")
-
-        eprint(f"[session_start] Transitioned {len(pending_contexts)} context(s) to implementing")
+        log_info("session_start", f"source={source}, permission_mode={permission_mode}, session={session_id[:8]}...")
+        log_diagnostic("session_start", "receive", f"source={source}, session={session_id[:8]}",
+                        inputs={"source": source, "session_id": session_id[:12], "permission_mode": permission_mode})
+
+        if source == "compact":
+            log_diagnostic("session_start", "decide", "Taking compact restore path",
+                            decision="compact_restore", reasoning="source=compact")
+            _handle_compact_restore(hook_input, session_id, project_root)
+        elif source == "clear":
+            log_diagnostic("session_start", "decide", "Taking clear restore path",
+                            decision="clear_restore", reasoning="source=clear, looking for has_plan context")
+            _handle_clear_restore(hook_input, session_id, project_root)
+        else:
+            log_diagnostic("session_start", "decide", f"No action for source={source}",
+                            decision="skip", reasoning=f"source={source} has no handler")
+            log_debug("session_start", f"No action for source='{source}'")
 
     except Exception as e:
-        eprint(f"[session_start] ERROR: {e}")
         import traceback
-        eprint(traceback.format_exc())
+        tb = traceback.format_exc()
+        from lib.base.hook_utils import log_hook_error
+        log_hook_error("session_start", e, "SessionStart", traceback_str=tb)
 
 
 if __name__ == "__main__":
-    main()
+    from lib.base.hook_utils import run_hook
+    run_hook(main, "session_start")

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

@@ -2,7 +2,7 @@
 """PostToolUse hook - captures TaskCreate operations for persistence.
 
 This hook runs after Claude uses the TaskCreate tool and automatically
-records the task creation event in the context's events.jsonl.
+records the task in the context's state.json.
 
 Hook input (from Claude Code):
 {
@@ -38,94 +38,71 @@ from lib.base.hook_utils import (
     check_skip_persistence,
     safe_hook_main,
     run_hook,
+    log_debug,
+    log_info,
+    log_warn,
+    log_error,
 )
-from lib.base.utils import eprint, project_dir
-from lib.context.context_extractor import extract_context_id
-from lib.context.task_sync import record_task_created, generate_next_task_id
+from lib.base.utils import project_dir
+from lib.context.context_store import get_context_by_session_id
+from lib.context.task_tracker import add_task, generate_next_task_id
 
 
 @safe_hook_main("task_create_capture")
 def main() -> int:
-    """
-    Main hook entry point.
-
-    Returns:
-        0 on success, non-zero on failure (but hook is non-blocking)
-    """
-    # Parse hook input
+    """Main hook entry point."""
     payload = load_hook_input()
     if not payload:
         return 0
 
-    # Validate hook type and tool name
     if not validate_hook_event(payload, "PostToolUse", "TaskCreate"):
         return 0
 
-    # Extract tool input
     tool_input = get_tool_input(payload)
     if not tool_input:
-        eprint("[task_create_capture] Invalid tool_input: not a dict")
+        log_warn("task_create_capture", "Invalid tool_input: not a dict")
         return 0
 
-    # Check for skip_persistence flag
     if check_skip_persistence(payload, "task_create_capture"):
         return 0
 
-    # Extract tool response (contains task ID assigned by Claude)
-    tool_response = payload.get("tool_response", {})
-    if not isinstance(tool_response, dict):
-        eprint("[task_create_capture] Invalid tool_response: not a dict")
-        return 0
-
-    # Get project root and session ID
     project_root = project_dir(payload)
-    session_id = payload.get("session_id")
+    session_id = payload.get("session_id", "")
 
-    # Extract context ID using unified extractor
-    context_id = extract_context_id(
-        tool_input,
-        project_root,
-        session_id=session_id,
-        hook_name="task_create_capture",
-        check_persistent_id=True  # TaskCreate uses persistent_id for context hints
-    )
-    if not context_id:
-        eprint("[task_create_capture] No context available - skipping persistence")
-        eprint("[task_create_capture] Task will be ephemeral until context is created")
+    # Find context by session ID
+    state = get_context_by_session_id(session_id, project_root)
+    if not state:
+        log_debug("task_create_capture", "No context available - skipping persistence")
         return 0
 
+    context_id = state.id
+
     # Extract task data
     subject = tool_input.get("subject", "")
     if not subject:
-        eprint("[task_create_capture] Missing required field: subject")
+        log_warn("task_create_capture", "Missing required field: subject")
         return 0
 
     description = tool_input.get("description", "")
     active_form = tool_input.get("activeForm", "")
 
-    # Generate persistent task ID
-    # Claude's native ID is ephemeral (1, 2, 3...)
-    # We need a persistent ID that survives sessions
-    persistent_task_id = generate_next_task_id(context_id, project_root)
-
-    # Record the task creation event
-    success = record_task_created(
+    # Add task to state.json
+    task = add_task(
         context_id=context_id,
-        task_id=persistent_task_id,
         subject=subject,
         description=description,
         active_form=active_form,
-        project_root=project_root
+        session_id=session_id,
+        project_root=project_root,
     )
 
-    if success:
-        eprint(f"[task_create_capture] Recorded task_added: {persistent_task_id} in {context_id}")
+    if task:
+        log_info("task_create_capture", f"Recorded task: {task['id']} in {context_id}")
     else:
-        eprint(f"[task_create_capture] Failed to record task_added: {persistent_task_id}")
+        log_error("task_create_capture", f"Failed to add task in {context_id}")
 
-    # Silent success (no stdout output)
     return 0
 
 
 if __name__ == "__main__":
-    run_hook(main)
+    run_hook(main, "task_create_capture")