aiwcli 0.9.8 → 0.10.0

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,95 +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,
-        session_id=session_id or "",
-        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")

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

@@ -2,13 +2,7 @@
 """PostToolUse hook - captures TaskUpdate operations for persistence.
 
 This hook runs after Claude uses the TaskUpdate tool and automatically
-records the appropriate event in the context's events.jsonl based on the
-status change.
-
-Status mappings:
-- status: "in_progress" -> record_task_started()
-- status: "completed" -> record_task_completed()
-- blockedBy added -> record_task_blocked()
+records the update in the context's state.json.
 
 Hook input (from Claude Code):
 {
@@ -46,173 +40,106 @@ 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_started,
-    record_task_completed,
-    record_task_blocked,
-    record_task_deleted,
-)
+from lib.base.utils import project_dir
+from lib.context.context_store import get_context_by_session_id
+from lib.context.task_tracker import update_task, delete_task
 
 
 def get_persistent_task_id(
     claude_task_id: str,
     tool_input: Dict[str, Any]
 ) -> str:
-    """
-    Convert Claude's ephemeral task ID to persistent task ID.
-
-    If metadata.persistent_id exists, use that.
-    Otherwise, assume format "aiw-{claude_task_id}".
-
-    Args:
-        claude_task_id: Task ID from Claude (e.g., "1", "2")
-        tool_input: Tool input dict
-
-    Returns:
-        Persistent task ID (e.g., "aiw-1")
-    """
+    """Convert Claude's ephemeral task ID to persistent task ID."""
     metadata = tool_input.get("metadata", {})
     if isinstance(metadata, dict):
         persistent_id = metadata.get("persistent_id")
         if persistent_id:
             return persistent_id
-
-    # Default: aiw-{id}
     return f"aiw-{claude_task_id}"
 
 
 @safe_hook_main("task_update_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", "TaskUpdate"):
         return 0
 
-    # Extract tool input
     tool_input = get_tool_input(payload)
     if not tool_input:
-        eprint("[task_update_capture] Invalid tool_input: not a dict")
+        log_warn("task_update_capture", "Invalid tool_input: not a dict")
         return 0
 
-    # Check for skip_persistence flag
     if check_skip_persistence(payload, "task_update_capture"):
         return 0
 
-    # Get project root and session ID
     project_root = project_dir(payload)
-    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_update_capture"
-    )
-    if not context_id:
-        eprint("[task_update_capture] No context available - skipping persistence")
+    session_id = payload.get("session_id", "")
+
+    # Find context by session ID
+    state = get_context_by_session_id(session_id, project_root)
+    if not state:
+        log_debug("task_update_capture", "No context available - skipping persistence")
         return 0
 
+    context_id = state.id
+
     # Extract task ID
     claude_task_id = tool_input.get("taskId")
     if not claude_task_id:
-        eprint("[task_update_capture] Missing required field: taskId")
+        log_warn("task_update_capture", "Missing required field: taskId")
         return 0
 
-    # Get persistent task ID
     persistent_task_id = get_persistent_task_id(claude_task_id, tool_input)
 
-    # Check for status change
     status = tool_input.get("status")
     metadata = tool_input.get("metadata", {})
-    add_blocked_by = tool_input.get("addBlockedBy", [])
 
-    # Handle different update types
     events_recorded = []
 
-    # Status: in_progress
-    if status == "in_progress":
-        success = record_task_started(
-            context_id=context_id,
-            task_id=persistent_task_id,
-            session_id=session_id or "",
-            project_root=project_root
-        )
-        if success:
-            events_recorded.append("task_started")
-
-    # Status: completed
-    elif status == "completed":
-        # Extract rich completion context from metadata
+    if status == "deleted":
+        if delete_task(context_id, persistent_task_id, project_root):
+            events_recorded.append("task_deleted")
+    elif status:
+        # Extract completion metadata
+        evidence = ""
+        work_summary = ""
+        files_changed = None
         if isinstance(metadata, dict):
-            evidence = metadata.get("evidence", "Task marked completed")
+            evidence = metadata.get("evidence", "")
             work_summary = metadata.get("work_summary", "")
-            files_changed = metadata.get("files_changed", [])
-            commit_ref = metadata.get("commit_ref", "")
-        else:
-            evidence = "Task marked completed"
-            work_summary = ""
-            files_changed = []
-            commit_ref = ""
-
-        success = record_task_completed(
+            files_changed = metadata.get("files_changed")
+            if files_changed and not isinstance(files_changed, list):
+                files_changed = None
+
+        success = update_task(
             context_id=context_id,
             task_id=persistent_task_id,
+            status=status,
             evidence=evidence,
             work_summary=work_summary,
-            files_changed=files_changed if isinstance(files_changed, list) else [],
-            commit_ref=commit_ref,
-            session_id=session_id or "",
-            project_root=project_root
-        )
-        if success:
-            events_recorded.append("task_completed")
-
-    # Status: deleted
-    elif status == "deleted":
-        success = record_task_deleted(
-            context_id=context_id,
-            task_id=persistent_task_id,
-            session_id=session_id or "",
-            project_root=project_root
-        )
-        if success:
-            events_recorded.append("task_deleted")
-
-    # Blocked by tasks
-    if add_blocked_by and isinstance(add_blocked_by, list) and len(add_blocked_by) > 0:
-        blocked_reason = f"Blocked by tasks: {', '.join(add_blocked_by)}"
-        success = record_task_blocked(
-            context_id=context_id,
-            task_id=persistent_task_id,
-            reason=blocked_reason,
-            session_id=session_id or "",
-            project_root=project_root
+            files_changed=files_changed,
+            session_id=session_id,
+            project_root=project_root,
         )
         if success:
-            events_recorded.append("task_blocked")
+            events_recorded.append(f"task_{status}")
 
     if events_recorded:
-        eprint(f"[task_update_capture] Recorded {', '.join(events_recorded)} for {persistent_task_id} in {context_id}")
+        log_info("task_update_capture", f"Recorded {', '.join(events_recorded)} for {persistent_task_id} in {context_id}")
     else:
-        eprint(f"[task_update_capture] No relevant status changes detected for {persistent_task_id}")
+        log_debug("task_update_capture", f"No relevant changes for {persistent_task_id}")
 
-    # Silent success (no stdout output)
     return 0
 
 
 if __name__ == "__main__":
-    run_hook(main)
+    run_hook(main, "task_update_capture")

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

@@ -28,72 +28,56 @@ 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 (
-    update_context_session_id,
-    update_plan_status,
+from lib.base.hook_utils import load_hook_input, log_debug, log_info, log_warn, log_error, log_diagnostic
+from lib.base.utils import project_dir
+from lib.context.context_store import (
     get_context,
     get_context_by_session_id,
+    bind_session,
+    maybe_activate,
+    save_state,
 )
-
-# Import the enforcement module
-from hooks.context_enforcer import determine_context, BlockRequest
+from lib.context.context_selector import determine_context, BlockRequest
 
 
 def format_claudemd_reminder() -> str:
     """Generate reminder to update directory-specific CLAUDE.md files."""
     return """
-## CLAUDE.md Decision Capture
-
-**Placement rule:** CLAUDE.md files cascade — subdirectories inherit from parents. Default to updating the nearest existing CLAUDE.md. Only create a new one at a semantic boundary where responsibility genuinely shifts (package roots with their own manifest, technology boundaries, domain boundaries, integration points).
-
-**Before creating a new CLAUDE.md, ask:** "Do the rules here actually differ from the parent?" If not, update the parent instead.
+## CLAUDE.md \u2014 Persistent Memory
 
-**Keep files lean (progressive disclosure):** Each CLAUDE.md should contain only decisions relevant at that directory level. Verbose files become noise that degrades future task quality — every entry competes for attention in the context window. Capture only non-obvious rationale, not descriptions of what the code does.
+CLAUDE.md files are this project's persistent memory across sessions. **After making a significant decision or learning something non-obvious during this task, write it to the nearest CLAUDE.md.** If you don't write it, it's lost when this session ends.
 
-**What to capture** (only when decisions have non-obvious rationale):
-- Architectural choices and their alternatives
+**What to write:**
+- Architectural choices and why alternatives were rejected
 - Non-obvious constraints (what breaks if this changes)
 - Workarounds with context on the underlying issue
-- Learned patterns that prevent future mistakes
+- Patterns that prevent future mistakes
+
+**Placement:** CLAUDE.md files cascade \u2014 subdirectories inherit from parents. Update the nearest existing one. Only create a new one at a genuine semantic boundary (package root, technology boundary, domain boundary).
 
 **Format:**
 
 ```markdown
 ## [Topic]
 **Decision:** [What was decided]
-**Rationale:** [Why — the non-obvious part]
+**Rationale:** [Why \u2014 the non-obvious part]
 ```
+
+**When in doubt, write it.** A lean entry is better than a lost decision.
 """
 
 
 def _update_in_flight_status(context_id: str, hook_input: dict, project_root: Path) -> None:
     """
-    Update context in-flight status based on permission mode.
+    Update context mode based on permission mode.
 
-    - If permission_mode == "plan": set to "planning"
-    - If permission_mode in ["acceptEdits", "bypassPermissions"]: set to "implementing"
+    - permission_mode == "plan": no-op (planning is runtime-only, not persisted)
+    - permission_mode != "plan" and mode == "idle": set to "active"
+    - permission_mode != "plan" and mode == "has_plan": set to "active" (plan was accepted)
     """
-    context = get_context(context_id, project_root)
-    if not context or not context.in_flight:
-        return
-
-    current_mode = context.in_flight.mode
     permission_mode = hook_input.get("permission_mode", "default")
-    eprint(f"[user_prompt_submit] Current mode: {current_mode}, permission_mode: {permission_mode}")
-
-    # Set status based on permission mode
-    if permission_mode == "plan":
-        if current_mode != "planning":
-            update_plan_status(context_id, "planning", project_root=project_root)
-            eprint(f"[user_prompt_submit] Set status to 'planning'")
-    elif permission_mode != "plan":
-        # Any non-plan permission mode transitions pending/planning to implementing
-        # This includes "default" (after /clear) and "acceptEdits"/"bypassPermissions"
-        if current_mode in ["pending_implementation", "planning", "none"]:
-            update_plan_status(context_id, "implementing", project_root=project_root)
-            eprint(f"[user_prompt_submit] Set status to 'implementing' (permission_mode={permission_mode})")
+    log_debug("user_prompt_submit", f"context_id={context_id}, permission_mode={permission_mode}")
+    maybe_activate(context_id, permission_mode, project_root=project_root, caller="user_prompt_submit")
 
 
 def main():
@@ -104,70 +88,86 @@ def main():
     Uses session_id to detect first prompt vs subsequent prompts.
     """
     try:
-        # Read hook input using shared utility
         hook_input = load_hook_input()
-
         if not hook_input:
             return
 
-        # Get user prompt and project root
         user_prompt = hook_input.get("prompt", "")
         project_root = project_dir(hook_input)
         session_id = hook_input.get("session_id", "unknown")
 
+        log_diagnostic("user_prompt_submit", "receive", f"session={session_id[:8]}, prompt_len={len(user_prompt)}",
+                        inputs={"session_id": session_id[:12], "prompt_length": len(user_prompt)})
+
         outputs: List[str] = []
-        active_context_id = None  # Track context for CLAUDE.md reminder
+        active_context_id = None
 
         # First-prompt detection: check if session_id is already bound to a context
         existing_context = get_context_by_session_id(session_id, project_root)
 
         if existing_context:
             # NOT first prompt - session already bound to context
-            # Skip expensive context detection
-            eprint(f"[user_prompt_submit] Session {session_id[:8]}... already bound to {existing_context.id}")
-            # Still update in-flight status based on permission mode
+            log_debug("user_prompt_submit", f"Session {session_id[:8]}... already bound to {existing_context.id}")
+            log_diagnostic("user_prompt_submit", "decide", f"Session already bound to {existing_context.id}",
+                            decision="session_match", reasoning="session_id found in existing context",
+                            inputs={"context_id": existing_context.id, "mode": existing_context.mode})
             _update_in_flight_status(existing_context.id, hook_input, project_root)
             active_context_id = existing_context.id
         elif user_prompt:
             # FIRST prompt - need context detection
             try:
-                context_id, method, context_output = determine_context(user_prompt, project_root, session_id)
-                eprint(f"[user_prompt_submit] Context: {method} -> {context_id}")
+                context_id, method, context_output = determine_context(user_prompt, session_id, project_root)
+                log_info("user_prompt_submit", f"Context: {method} -> {context_id}")
+                log_diagnostic("user_prompt_submit", "decide", f"Context detected via {method}: {context_id}",
+                                decision=method, reasoning=f"determine_context returned method={method}",
+                                inputs={"context_id": context_id, "has_output": bool(context_output)})
 
                 if context_id:
                     # Bind session to context
-                    update_context_session_id(context_id, session_id, project_root)
-                    eprint(f"[user_prompt_submit] Bound session {session_id[:8]}... to context '{context_id}'")
+                    bind_session(context_id, session_id, project_root)
+                    log_info("user_prompt_submit", f"Bound session {session_id[:8]}... to context '{context_id}'")
 
-                    # Update in-flight status based on permission mode
+                    # Update mode based on permission mode
                     _update_in_flight_status(context_id, hook_input, project_root)
                     active_context_id = context_id
 
+                    # Clear handoff_path after it's been injected via context_selector
+                    try:
+                        ctx = get_context(context_id, project_root)
+                        if ctx and ctx.handoff_path:
+                            ctx.handoff_path = None
+                            save_state(ctx, project_root)
+                            log_debug("user_prompt_submit", f"Cleared handoff_path for {context_id}")
+                    except Exception as e:
+                        log_warn("user_prompt_submit", f"Failed to clear handoff_path: {e}")
+
                 if context_output:
                     outputs.append(context_output)
 
             except BlockRequest as e:
-                # Block the request - print to stderr and exit with code 2
-                # This shows the context picker to the user
-                print(e.message, file=sys.stderr)
+                log_error("user_prompt_submit", e.message)
                 sys.exit(2)
 
-        # Inject CLAUDE.md reminder when in implementing mode
+        # Inject CLAUDE.md reminder when in active mode
         if active_context_id:
             context = get_context(active_context_id, project_root)
-            if context and context.in_flight and context.in_flight.mode == "implementing":
+            if context and context.mode == "active":
                 outputs.append(f"<system-reminder>{format_claudemd_reminder()}</system-reminder>")
-                eprint(f"[user_prompt_submit] Injected CLAUDE.md reminder (mode=implementing)")
+                log_debug("user_prompt_submit", "Injected CLAUDE.md reminder (mode=active)")
+
+        log_diagnostic("user_prompt_submit", "result", f"context={active_context_id}, outputs={len(outputs)}",
+                        inputs={"active_context_id": active_context_id, "output_count": len(outputs)})
 
-        # Print output
         if outputs:
             print("\n\n".join(outputs))
 
     except Exception as e:
-        eprint(f"[user_prompt_submit] ERROR: {e}")
         import traceback
-        eprint(traceback.format_exc())
+        tb = traceback.format_exc()
+        from lib.base.hook_utils import log_hook_error
+        log_hook_error("user_prompt_submit", e, "UserPromptSubmit", traceback_str=tb)
 
 
 if __name__ == "__main__":
-    main()
+    from lib.base.hook_utils import run_hook
+    run_hook(main, "user_prompt_submit")

package/dist/templates/_shared/lib/base/__init__.py

@@ -23,6 +23,15 @@ from .utils import (
     sanitize_title,
     generate_context_id,
 )
+from .logger import (
+    hook_log,
+    log_debug,
+    log_info,
+    log_warn,
+    log_error,
+    log_hook_error,
+    set_context_path,
+)
 
 __all__ = [
     "atomic_write",
@@ -46,4 +55,11 @@ __all__ = [
     "sanitize_filename",
     "sanitize_title",
     "generate_context_id",
+    "hook_log",
+    "log_debug",
+    "log_info",
+    "log_warn",
+    "log_error",
+    "log_hook_error",
+    "set_context_path",
 ]