aiwcli 0.9.1 → 0.9.2

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

@@ -299,13 +299,18 @@ def format_context_picker_stderr(contexts: List[Context]) -> str:
     return "\n".join(lines)
 
 
-def format_command_feedback(ended_contexts: List[Context], selected_context: Optional[Context]) -> str:
+def format_command_feedback(
+    ended_contexts: List[Context],
+    selected_context: Optional[Context],
+    remaining_prompt: Optional[str] = None
+) -> str:
     """
     Format feedback about what context operations were performed.
 
     Args:
         ended_contexts: Contexts that were ended/completed
         selected_context: Context that was selected (if any)
+        remaining_prompt: User's actual request after caret command (if any)
 
     Returns:
         Formatted feedback message
@@ -338,6 +343,14 @@ def format_command_feedback(ended_contexts: List[Context], selected_context: Opt
         lines.append(f'All work belongs to context "{selected_context.id}".')
         lines.append("Tasks created with TaskCreate will be persisted to this context.")
 
+    # Add user's actual request if provided after caret command
+    if remaining_prompt and remaining_prompt.strip():
+        lines.append("")
+        lines.append("---")
+        lines.append("")
+        lines.append("**User's actual request:**")
+        lines.append(f"> {remaining_prompt}")
+
     return "\n".join(lines)
 
 
@@ -345,7 +358,7 @@ def determine_context(
     user_prompt: str,
     project_root: Path = None,
     session_id: str = None
-) -> Tuple[Optional[str], str, Optional[str]]:
+) -> Tuple[Optional[str], str, Optional[str], Optional[str]]:
     """
     Determine which context this prompt belongs to.
 
@@ -355,6 +368,7 @@ def determine_context(
         - method: How context was determined (session_match, in_flight, caret_select,
                   auto_created, single_context, blocked)
         - output: System reminder to inject, or None
+        - remaining_prompt: Actual user request after caret command, or None
 
     Raises:
         BlockRequest: When request should be blocked to show picker to user
@@ -362,7 +376,7 @@ def determine_context(
     # 0. Skip context creation for internal subprocess calls (orchestrator, agents)
     if is_internal_call():
         eprint("[context_enforcer] Skipping: internal subprocess call")
-        return (None, "skip_internal", None)
+        return (None, "skip_internal", None, None)
 
     # 1. Check if session already belongs to a context (HIGHEST PRIORITY)
     # This prevents context switching on subsequent prompts - one context per session
@@ -373,11 +387,20 @@ def determine_context(
             return (
                 session_context.id,
                 "session_match",
-                format_active_context_reminder(session_context)
+                format_active_context_reminder(session_context),
+                None
             )
 
     # 2. Check for bare "^" - show context picker
     if user_prompt.strip() == "^":
+        # Pre-transition: Move any pending_implementation contexts to implementing
+        # This ensures they appear selectable when user opens the picker
+        in_flight = get_all_in_flight_contexts(project_root)
+        for ctx in in_flight:
+            if ctx.in_flight and ctx.in_flight.mode == "pending_implementation":
+                update_plan_status(ctx.id, "implementing", project_root=project_root)
+                eprint(f"[context_enforcer] Pre-transitioned {ctx.id} to implementing (bare caret)")
+
         contexts = get_all_contexts(status="active", project_root=project_root)
         if not contexts:
             raise BlockRequest(
@@ -407,7 +430,7 @@ def determine_context(
 
         # Don't auto-create for greetings or help commands
         if any(prompt_lower.startswith(p) or prompt_lower == p for p in skip_patterns):
-            return (None, "no_context_needed", None)
+            return (None, "no_context_needed", None, None)
 
         # Auto-create context from prompt
         try:
@@ -419,11 +442,12 @@ def determine_context(
             return (
                 new_context.id,
                 "auto_created",
-                format_context_created(new_context)
+                format_context_created(new_context),
+                None
             )
         except Exception as e:
             eprint(f"[context_enforcer] Failed to create context: {e}")
-            return (None, "creation_failed", None)
+            return (None, "creation_failed", None, None)
 
     elif len(in_flight_contexts) == 1:
         # Single in-flight context - auto-select it
@@ -431,6 +455,15 @@ def determine_context(
         mode = ctx.in_flight.mode if ctx.in_flight else "none"
         eprint(f"[context_enforcer] Auto-selected single in-flight context: {ctx.id} (mode={mode})")
 
+        # Auto-transition pending_implementation to implementing
+        # This ensures state updates immediately when context is selected,
+        # rather than waiting for _update_in_flight_status() which has conditions
+        if mode == "pending_implementation":
+            update_plan_status(ctx.id, "implementing", project_root=project_root)
+            ctx.in_flight.mode = "implementing"  # Update local copy for display
+            mode = "implementing"  # Update local var for formatter selection
+            eprint(f"[context_enforcer] Transitioned {ctx.id} to implementing")
+
         # Use mode-specific formatter for better continuation context
         if mode == "pending_implementation":
             output = format_pending_plan_continuation(ctx)
@@ -439,7 +472,7 @@ def determine_context(
         else:
             output = format_active_context_reminder(ctx)
 
-        return (ctx.id, "auto_selected", output)
+        return (ctx.id, "auto_selected", output, None)
 
     else:
         # Multiple in-flight contexts - block and show picker
@@ -455,7 +488,7 @@ def _handle_caret_command(
     user_prompt: str,
     contexts: List[Context],
     project_root: Path
-) -> Tuple[Optional[str], str, Optional[str]]:
+) -> Tuple[Optional[str], str, Optional[str], Optional[str]]:
     """
     Handle explicit caret commands (^E, ^S, ^0, ^N).
 
@@ -465,7 +498,7 @@ def _handle_caret_command(
         project_root: Project root directory
 
     Returns:
-        Tuple of (context_id, method, output)
+        Tuple of (context_id, method, output, remaining_prompt)
 
     Raises:
         BlockRequest: When command is invalid or selection needed
@@ -505,7 +538,8 @@ def _handle_caret_command(
             return (
                 new_context.id,
                 "caret_new",
-                format_context_created(new_context)
+                format_context_created(new_context),
+                None
             )
         except Exception as e:
             eprint(f"[context_enforcer] Failed to create context: {e}")
@@ -542,7 +576,8 @@ def _handle_caret_command(
             return (
                 new_context.id,
                 "caret_new",
-                output
+                output,
+                None
             )
         except Exception as e:
             eprint(f"[context_enforcer] Failed to create context: {e}")
@@ -552,11 +587,24 @@ def _handle_caret_command(
     if cmd.select:
         selected_ctx = contexts[cmd.select - 1]  # 1-indexed
         eprint(f"[context_enforcer] Caret-selected context: {selected_ctx.id}")
-        output = format_command_feedback(ended_contexts, selected_ctx)
+
+        # Auto-transition pending_implementation to implementing
+        mode = selected_ctx.in_flight.mode if selected_ctx.in_flight else "none"
+        if mode == "pending_implementation":
+            update_plan_status(selected_ctx.id, "implementing", project_root=project_root)
+            selected_ctx.in_flight.mode = "implementing"
+            eprint(f"[context_enforcer] Transitioned {selected_ctx.id} to implementing")
+
+        output = format_command_feedback(
+            ended_contexts,
+            selected_ctx,
+            cmd.remaining_prompt if cmd.remaining_prompt else None
+        )
         return (
             selected_ctx.id,
             "caret_select",
-            output
+            output,
+            cmd.remaining_prompt if cmd.remaining_prompt else None
         )
 
     # Only ended contexts, no selection - refresh context list and block
@@ -600,8 +648,10 @@ def main():
         project_root = project_dir(hook_input)
 
         try:
-            context_id, method, output = determine_context(user_prompt, project_root)
+            context_id, method, output, remaining_prompt = determine_context(user_prompt, project_root)
             eprint(f"[context_enforcer] Method: {method}, Context: {context_id}")
+            if remaining_prompt:
+                eprint(f"[context_enforcer] Remaining prompt: {remaining_prompt[:50]}...")
 
             if output:
                 print(output)

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

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+"""SessionStart hook for mode transitions after /clear.
+
+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.
+
+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"
+
+Without this hook, the mode stays stuck at pending_implementation because
+UserPromptSubmit may not receive the correct permission_mode after /clear.
+
+Hook input:
+{
+    "hook_event_name": "SessionStart",
+    "session_id": "abc123",
+    "source": "clear",  # or "startup", "resume", "compact"
+    "permission_mode": "bypassPermissions",
+    "model": "...",
+    ...
+}
+"""
+import json
+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.utils import eprint, project_dir
+from lib.context.context_manager import (
+    get_all_in_flight_contexts,
+    update_plan_status,
+    update_context_session_id,
+)
+
+
+def main():
+    """
+    Handle mode transitions on session start.
+
+    When source is "clear" and permission_mode is "bypassPermissions" or "acceptEdits",
+    transition any pending_implementation context to implementing.
+    """
+    try:
+        # Read hook input from stdin
+        input_data = sys.stdin.read().strip()
+
+        if not input_data:
+            return
+
+        try:
+            hook_input = json.loads(input_data)
+        except json.JSONDecodeError:
+            return
+
+        source = hook_input.get("source", "unknown")
+        permission_mode = hook_input.get("permission_mode", "default")
+        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")
+
+    except Exception as e:
+        eprint(f"[session_start] ERROR: {e}")
+        import traceback
+        eprint(traceback.format_exc())
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""PreToolUse hook for TaskCreate - assesses atomicity and forkability via inference.
+
+Ensures tasks contain sufficient self-contained context for independent execution,
+especially when delegated to subagents with zero conversation history.
+
+Non-blocking: Warns but allows creation even if atomicity is poor.
+"""
+
+import json
+import sys
+from pathlib import Path
+
+# Path setup
+_hook_dir = Path(__file__).resolve().parent
+_shared_lib = _hook_dir.parent / "lib"
+sys.path.insert(0, str(_shared_lib))
+
+from base.utils import eprint
+from base.subprocess_utils import is_internal_call
+from base.inference import inference
+
+# Prompt engineered per Prompting/Standards.md:
+# - Markdown-only (no XML)
+# - Positive framing (tell what TO do)
+# - 1-3 clear examples matching desired output
+# - Direct imperative instructions
+# - Explicit JSON output format
+
+ASSESSMENT_SYSTEM_PROMPT = """You assess task descriptions for atomicity and forkability.
+
+## Definitions
+
+**Atomic Task:** Contains ALL context needed for independent execution without reading prior conversation.
+
+**Forkable Task:** Can be delegated to a subagent with ZERO conversation history and still be completed successfully.
+
+## Signs of Non-Atomic Tasks
+
+Look for these indicators:
+- Contextual references: "the file above", "as discussed", "the mentioned function", "this bug"
+- Vague descriptions assuming prior knowledge: "fix the bug", "update it", "finish the work"
+- Missing specifics: which file? what function? what expected behavior? what error?
+- Pronouns without antecedents: "it", "they", "the issue" without explicit definition
+
+## Signs of Atomic Tasks
+
+Well-specified tasks include:
+- Explicit file paths: "Edit src/utils/parser.py"
+- Specific function names: "Modify the validate_input() function"
+- Clear expected behavior: "Should return 404 when user not found"
+- Complete error context: "TypeError on line 45 when input is None"
+
+## Examples
+
+**Example 1: Non-Atomic Task**
+Subject: "Fix the bug"
+Description: "The issue we discussed earlier needs to be resolved"
+Assessment: NOT atomic (no file, no function, no error details, references "discussed earlier")
+
+**Example 2: Atomic Task**
+Subject: "Fix null pointer in user lookup"
+Description: "In src/services/user.py, the get_user_by_id() function raises TypeError when user_id is None. Add null check at line 23 that returns None early instead of calling database.query()."
+Assessment: Atomic (file path, function name, specific error, exact fix location, expected behavior)
+
+**Example 3: Partially Atomic Task**
+Subject: "Add validation to form"
+Description: "Add email validation to the signup form. Return error message if invalid."
+Assessment: NOT fully atomic (missing: which file contains the form? what validation rules? where to display error?)
+
+## Output Format
+
+Respond with valid JSON only:
+{
+  "atomic": true/false,
+  "forkable": true/false,
+  "issues": ["specific issue 1", "specific issue 2"],
+  "recommendation": "brief actionable suggestion if issues exist, or 'Task is well-specified' if good"
+}"""
+
+ASSESSMENT_USER_TEMPLATE = """Assess this task for atomicity and forkability:
+
+**Subject:** {subject}
+
+**Description:** {description}
+
+Evaluate whether a subagent with zero prior context could execute this task successfully."""
+
+
+def main() -> int:
+    # Skip internal calls (prevents recursion from orchestrator/inference)
+    if is_internal_call():
+        return 0
+
+    try:
+        payload = json.load(sys.stdin)
+    except json.JSONDecodeError:
+        return 0
+
+    # Only process TaskCreate
+    if payload.get("tool_name") != "TaskCreate":
+        return 0
+
+    tool_input = payload.get("tool_input", {})
+    subject = tool_input.get("subject", "")
+    description = tool_input.get("description", "")
+
+    # Skip very short tasks (likely intentionally brief or simple acknowledgments)
+    if len(description.strip()) < 15:
+        return 0
+
+    # Call inference to assess atomicity and forkability
+    try:
+        result = inference(
+            system_prompt=ASSESSMENT_SYSTEM_PROMPT,
+            user_prompt=ASSESSMENT_USER_TEMPLATE.format(
+                subject=subject,
+                description=description
+            ),
+            level="fast",  # Use Haiku for minimal latency (~1-2s)
+            timeout=12,    # Allow up to 12s for inference
+        )
+
+        if not result.success:
+            eprint(f"[task-create-atomicity] Inference failed: {result.error}")
+            return 0  # Non-blocking on failure
+
+        # Parse JSON response
+        try:
+            # Handle potential markdown code blocks in response
+            output = result.output.strip()
+            if output.startswith("```"):
+                # Extract JSON from code block
+                lines = output.split("\n")
+                json_lines = []
+                in_block = False
+                for line in lines:
+                    if line.startswith("```") and not in_block:
+                        in_block = True
+                        continue
+                    elif line.startswith("```") and in_block:
+                        break
+                    elif in_block:
+                        json_lines.append(line)
+                output = "\n".join(json_lines)
+
+            assessment = json.loads(output)
+        except json.JSONDecodeError:
+            eprint(f"[task-create-atomicity] Failed to parse inference response: {result.output[:100]}")
+            return 0
+
+        # Extract assessment fields
+        atomic = assessment.get("atomic", True)
+        forkable = assessment.get("forkable", True)
+        issues = assessment.get("issues", [])
+        recommendation = assessment.get("recommendation", "")
+
+        # Build context message based on assessment
+        if atomic and forkable:
+            # Task is good - minimal positive feedback
+            context_msg = "Task Assessment: Well-specified and forkable."
+        else:
+            # Task has issues - inject detailed warning
+            status_parts = []
+            if not atomic:
+                status_parts.append("NOT ATOMIC")
+            if not forkable:
+                status_parts.append("NOT FORKABLE")
+
+            issues_text = "\n".join(f"- {issue}" for issue in issues) if issues else "- See recommendation below"
+
+            context_msg = f"""**TASK ATOMICITY WARNING** ({', '.join(status_parts)})
+
+This task may lack sufficient context for independent execution by a subagent.
+
+**Issues detected:**
+{issues_text}
+
+**Recommendation:** {recommendation}
+
+Consider adding specific file paths, function names, expected behaviors, or error details before creating this task."""
+
+        # Output hook response with additionalContext
+        out = {
+            "hookSpecificOutput": {
+                "hookEventName": "PreToolUse",
+                "additionalContext": context_msg
+            }
+        }
+        print(json.dumps(out, ensure_ascii=False))
+        return 0
+
+    except Exception as e:
+        eprint(f"[task-create-atomicity] Error: {e}")
+        return 0  # Non-blocking on error
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -125,10 +125,10 @@ def main() -> int:
             eprint("[task_create_capture] Invalid tool_input: not a dict")
             return 0
 
-        # Check for skip_persistence flag (used during hydration to avoid duplicates)
+        # Check for skip_persistence flag (for programmatic task creation)
         metadata = tool_input.get("metadata", {})
         if isinstance(metadata, dict) and metadata.get("skip_persistence"):
-            eprint("[task_create_capture] Skipping persistence (hydration mode)")
+            eprint("[task_create_capture] Skipping persistence (skip_persistence flag set)")
             return 0
 
         # Extract tool response (contains task ID assigned by Claude)

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

@@ -151,10 +151,10 @@ def main() -> int:
             eprint("[task_update_capture] Invalid tool_input: not a dict")
             return 0
 
-        # Check for skip_persistence flag (used during hydration to avoid duplicates)
+        # Check for skip_persistence flag (for programmatic task updates)
         metadata = tool_input.get("metadata", {})
         if isinstance(metadata, dict) and metadata.get("skip_persistence"):
-            eprint("[task_update_capture] Skipping persistence (hydration mode)")
+            eprint("[task_update_capture] Skipping persistence (skip_persistence flag set)")
             return 0
 
         # Get project root and session ID

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

@@ -36,12 +36,50 @@ from lib.context.context_manager import (
     get_context,
     get_context_by_session_id,
 )
-from lib.context.task_sync import generate_hydration_instructions
 
 # Import the enforcement module
 from hooks.context_enforcer import determine_context, BlockRequest
 
 
+def format_claudemd_reminder() -> str:
+    """Generate reminder to update directory-specific CLAUDE.md files."""
+    return """
+## CLAUDE.md Decision Capture
+
+When implementing changes, consider whether this work involves decisions with non-obvious rationale. If so, update or create a CLAUDE.md in the relevant directory.
+
+**When to update CLAUDE.md:**
+- Architectural choices (why this pattern over alternatives)
+- Non-obvious constraints (why something MUST be done a certain way)
+- Learned patterns (discovered issues that future work should avoid)
+- Integration decisions (why components connect this way)
+- Workarounds (temporary solutions with context on the underlying issue)
+
+**What to capture (use this format):**
+
+```markdown
+## [Topic]
+
+**Decision:** [What was decided]
+**Rationale:** [Why this approach was chosen]
+**Constraint:** [What breaks if this changes]
+```
+
+**Directory-specific:** Place CLAUDE.md in the directory closest to the affected code. If no CLAUDE.md exists, create one with a descriptive header.
+
+**Example new CLAUDE.md:**
+
+```markdown
+# Component Name
+
+Development decisions and patterns for this component.
+
+## [First Decision Topic]
+...
+```
+"""
+
+
 def _update_in_flight_status(context_id: str, hook_input: dict, project_root: Path) -> None:
     """
     Update context in-flight status based on permission mode.
@@ -62,11 +100,12 @@ def _update_in_flight_status(context_id: str, hook_input: dict, project_root: Pa
         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 in ["acceptEdits", "bypassPermissions"]:
-        # Only transition to implementing if we have pending work
+    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"]:
             update_plan_status(context_id, "implementing", project_root=project_root)
-            eprint(f"[user_prompt_submit] Set status to 'implementing'")
+            eprint(f"[user_prompt_submit] Set status to 'implementing' (permission_mode={permission_mode})")
 
 
 def main():
@@ -94,21 +133,25 @@ def main():
         session_id = hook_input.get("session_id", "unknown")
 
         outputs: List[str] = []
+        active_context_id = None  # Track context for CLAUDE.md reminder
 
         # 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 and task hydration
+            # 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
             _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 and potentially task hydration
+            # FIRST prompt - need context detection
             try:
-                context_id, method, context_output = determine_context(user_prompt, project_root, session_id)
+                context_id, method, context_output, remaining_prompt = determine_context(user_prompt, project_root, session_id)
                 eprint(f"[user_prompt_submit] Context: {method} -> {context_id}")
+                if remaining_prompt:
+                    eprint(f"[user_prompt_submit] Actual request: {remaining_prompt[:50]}...")
 
                 if context_id:
                     # Bind session to context
@@ -117,12 +160,7 @@ def main():
 
                     # Update in-flight status based on permission mode
                     _update_in_flight_status(context_id, hook_input, project_root)
-
-                    # Task hydration - restore pending tasks from events.jsonl
-                    hydration_instructions = generate_hydration_instructions(context_id, project_root)
-                    if hydration_instructions and "No pending tasks" not in hydration_instructions:
-                        outputs.append(hydration_instructions)
-                        eprint(f"[user_prompt_submit] Generated task hydration instructions")
+                    active_context_id = context_id
 
                 if context_output:
                     outputs.append(context_output)
@@ -133,6 +171,13 @@ def main():
                 print(e.message, file=sys.stderr)
                 sys.exit(2)
 
+        # Inject CLAUDE.md reminder when in implementing 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":
+                outputs.append(f"<system-reminder>{format_claudemd_reminder()}</system-reminder>")
+                eprint(f"[user_prompt_submit] Injected CLAUDE.md reminder (mode=implementing)")
+
         # Print output
         if outputs:
             print("\n\n".join(outputs))