aiwcli 0.9.8 → 0.10.0

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

@@ -26,11 +26,9 @@ 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_context_by_session_id
-from lib.context.event_log import EVENT_AUTO_STATE_SAVED, append_event
-from lib.context.auto_state import save_auto_state
+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():
@@ -45,45 +43,62 @@ def main():
         project_root = project_dir(hook_input)
 
         if not session_id:
-            eprint("[pre_compact] No session_id, skipping")
+            log_debug("pre_compact", "No session_id, skipping")
             return
 
-        eprint(f"[pre_compact] Saving state before compaction: {session_id[:8]}...")
+        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:
-            eprint("[pre_compact] No context bound to this session, skipping")
+            log_debug("pre_compact", "No context bound to this session, skipping")
             return
 
-        context_id = context.id
-        in_flight_mode = context.in_flight.mode if context.in_flight else "none"
-        plan_path = context.in_flight.artifact_path if context.in_flight else None
-        handoff_path = context.in_flight.handoff_path if context.in_flight else None
-
-        saved = save_auto_state(
-            context_id=context_id,
-            session_id=session_id,
-            save_reason="pre_compact",
-            project_root=project_root,
-            in_flight_mode=in_flight_mode,
-            plan_path=plan_path,
-            handoff_path=handoff_path,
-            transcript_path=transcript_path,
-        )
-
-        if saved:
-            append_event(
-                context_id, EVENT_AUTO_STATE_SAVED, project_root,
-                session_id=session_id, save_reason="pre_compact",
+        # 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
             )
-            eprint(f"[pre_compact] Auto-state saved for {context_id}")
+            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:
-        eprint(f"[pre_compact] ERROR: {e}")
         import traceback
-        eprint(traceback.format_exc())
+        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__":
-    main()
+    from lib.base.hook_utils import run_hook
+    run_hook(main, "pre_compact")

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

@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
-"""SessionEnd hook - records session boundary and saves auto-state.
+"""SessionEnd hook - saves session state to state.json.
 
-Fires when session terminates (quit, /clear, logout). Creates a session
-boundary marker in events.jsonl and writes auto-state.json for restoration.
+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):
 {
@@ -18,6 +18,8 @@ Hook output:
 - Silent (no stdout output needed for SessionEnd)
 - Logs to stderr for debugging
 """
+import hashlib
+import subprocess
 import sys
 from pathlib import Path
 
@@ -26,16 +28,45 @@ 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_context_by_session_id
-from lib.context.event_log import get_current_state, EVENT_AUTO_STATE_SAVED, append_event
-from lib.context.task_sync import record_session_ended
-from lib.context.auto_state import save_auto_state
+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():
-    """Record session boundary and save auto-state."""
+    """Save session state to state.json."""
     try:
         hook_input = load_hook_input()
         if not hook_input:
@@ -47,65 +78,77 @@ def main():
         project_root = project_dir(hook_input)
 
         if not session_id:
-            eprint("[session_end] No session_id, skipping")
+            log_debug("session_end", "No session_id, skipping")
             return
 
-        eprint(f"[session_end] Session ending: {session_id[:8]}... reason={source}")
+        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
-        context = get_context_by_session_id(session_id, project_root)
-        if not context:
-            eprint("[session_end] No context bound to this session, skipping")
+        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
 
-        context_id = context.id
-        eprint(f"[session_end] Found context: {context_id}")
-
-        # Get current task state for the session boundary marker
-        state = get_current_state(context_id, project_root)
-        active_tasks = [t.id for t in state.tasks if t.status == "in_progress"]
-        pending_tasks = [t.id for t in state.tasks if t.status == "pending"]
-
-        # Record session_ended event in events.jsonl
-        record_session_ended(
-            context_id=context_id,
-            session_id=session_id,
-            reason=source,
-            active_tasks=active_tasks,
-            pending_tasks=pending_tasks,
-            project_root=project_root,
-        )
-        eprint(f"[session_end] Recorded session_ended: active={len(active_tasks)}, pending={len(pending_tasks)}")
-
-        # Save auto-state.json
-        in_flight_mode = context.in_flight.mode if context.in_flight else "none"
-        plan_path = context.in_flight.artifact_path if context.in_flight else None
-        handoff_path = context.in_flight.handoff_path if context.in_flight else None
-
-        saved = save_auto_state(
-            context_id=context_id,
-            session_id=session_id,
-            save_reason=source,
-            project_root=project_root,
-            in_flight_mode=in_flight_mode,
-            plan_path=plan_path,
-            handoff_path=handoff_path,
-            transcript_path=transcript_path,
-        )
-
-        if saved:
-            # Record auto_state_saved event
-            append_event(
-                context_id, EVENT_AUTO_STATE_SAVED, project_root,
-                session_id=session_id, save_reason=source,
-            )
-            eprint(f"[session_end] Auto-state saved for {context_id}")
+        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:
-        eprint(f"[session_end] 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_end", e, "SessionEnd", traceback_str=tb)
 
 
 if __name__ == "__main__":
-    main()
+    from lib.base.hook_utils import run_hook
+    run_hook(main, "session_end")

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

@@ -1,14 +1,17 @@
 #!/usr/bin/env python3
-"""SessionStart hook for mode transitions and post-compaction restore.
+"""SessionStart hook for post-compaction and post-clear restore.
 
 This hook fires when a new session starts. It handles:
 
-1. Mode transition from `pending_implementation` to `implementing` when
-   a session starts after /clear with bypass permissions.
+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.
 
-2. Post-compaction restore: when source="compact", the session is already
-   bound to a context. Load auto-state and inject rich restoration context
-   so Claude can continue seamlessly after compaction.
+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:
 {
@@ -20,7 +23,6 @@ Hook input:
     ...
 }
 """
-import json
 import sys
 from pathlib import Path
 
@@ -29,48 +31,10 @@ 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,
-    get_context_by_session_id,
-    update_plan_status,
-    update_context_session_id,
-)
-from lib.context.auto_state import load_auto_state
-from lib.context.discovery import (
-    _build_restore_sections,
-    find_plan_path,
-    format_relative_time,
-)
-from lib.context.task_sync import generate_task_summary
-
-
-def _handle_clear_transition(hook_input, session_id, project_root):
-    """Handle /clear mode transitions (existing behavior)."""
-    permission_mode = hook_input.get("permission_mode", "default")
-
-    if permission_mode == "plan":
-        eprint("[session_start] Skipping: permission_mode is 'plan' (in planning mode)")
-        return
-
-    in_flight_contexts = get_all_in_flight_contexts(project_root)
-    if not in_flight_contexts:
-        eprint("[session_start] No in-flight contexts found")
-        return
-
-    pending_contexts = [
-        ctx for ctx in in_flight_contexts
-        if ctx.in_flight and ctx.in_flight.mode == "pending_implementation"
-    ]
-    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)
-        update_context_session_id(ctx.id, session_id, project_root)
-        eprint(f"[session_start] Bound session {session_id[:8]}... to context {ctx.id}")
-
-    if pending_contexts:
-        eprint(f"[session_start] Transitioned {len(pending_contexts)} context(s) to implementing")
+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 _handle_compact_restore(hook_input, session_id, project_root):
@@ -78,30 +42,28 @@ 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 auto-state and inject rich restoration context via additionalContext.
+    Load state and inject rich restoration context via additionalContext.
     """
-    context = get_context_by_session_id(session_id, project_root)
-    if not context:
-        eprint("[session_start] No context bound to session after compact")
+    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
 
-    context_id = context.id
-    eprint(f"[session_start] Post-compaction restore for context: {context_id}")
+    log_info("session_start", f"Post-compaction restore for context: {state.id}")
 
     # Build restoration context
-    mode_display = "Active"
-    if context.in_flight and context.in_flight.mode != "none":
-        mode_display = context.in_flight.mode.replace("_", " ").title()
+    mode_display = state.mode.replace("_", " ").title() if state.mode != "idle" else "Active"
 
     lines = [
-        f"## Resuming Context After Compaction: {context_id}",
+        f"## Resuming Context After Compaction: {state.id}",
         "",
-        f"**Summary:** {context.summary}",
+        f"**Summary:** {state.summary}",
         f"**Mode:** {mode_display}",
     ]
 
-    # Add restore sections (auto-state, tasks, git)
-    restore = _build_restore_sections(context, project_root)
+    # 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)
 
@@ -116,21 +78,78 @@ def _handle_compact_restore(hook_input, session_id, project_root):
     ])
 
     restore_context = "\n".join(lines)
-
-    # Output as additionalContext so Claude sees it
-    output = {
-        "hookSpecificOutput": {
-            "additionalContext": restore_context
-        }
-    }
-    print(json.dumps(output, ensure_ascii=False))
-    eprint(f"[session_start] Injected post-compaction restore context for {context_id}")
+    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 main():
+def _handle_clear_restore(hook_input, session_id, project_root):
     """
-    Handle mode transitions and post-compaction restore on session start.
+    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.
+
+    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:
         hook_input = load_hook_input()
         if not hook_input:
@@ -141,20 +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]}...")
+        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 == "clear":
-            _handle_clear_transition(hook_input, session_id, project_root)
-        elif source == "compact":
+        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:
-            eprint(f"[session_start] No action for source='{source}'")
+            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")