aiwcli 0.9.7 → 0.10.0

package/dist/templates/_shared/lib/templates/plan_context.py

@@ -1,8 +1,7 @@
 """Plan context templates for add_plan_context hook.
 
 Provides standardized templates for:
-- Evaluation context reminder
-- Clarifying questions offer
+- Evaluation context reminder (injected on plan writes)
 """
 
 
@@ -13,93 +12,40 @@ def get_evaluation_context_reminder() -> str:
         Formatted markdown reminder about adding evaluation context
     """
     return """
-## IMPORTANT: This Plan Will Be Executed in a Fresh Context
+## CRITICAL: Write This Plan for a Different Agent
 
-Your plan will be:
-1. **Reviewed** by agents who have NO access to this conversation
-2. **Executed** by a Claude agent starting with a completely fresh context
+The agent executing this plan has ZERO context from this conversation — no chat history, no memory of files you explored or research you did.
 
-The implementing agent won't have access to your research, file explorations, or any conversation history. Your plan must be **self-contained** and provide everything needed to execute it successfully.
+**Write as if YOU are that agent. What would you need?**
 
-### Required Plan Elements
+### Required Structure
 
-1. **A title line** at the very top: `# Plan: <descriptive title>`
-
-2. **Context Section** near the top with:
-   - **Background**: The bigger picture - why this change is needed and what problem it solves
-   - **Task**: What is being built/changed (specific and actionable)
-   - **Goal**: The underlying problem the user wants solved
-   - **Constraints**: Technical requirements, preferences, or limitations mentioned
-
-3. **Relevant Files** section listing:
-   - Files that will be modified (with brief description of what changes)
-   - Files to reference for patterns/context (with why they're relevant)
-   - Any configuration files that matter
-
-4. **Implementation Details** that are explicit enough for someone unfamiliar with your research:
-   - Don't assume the implementer knows what you discovered
-   - Include specific function names, patterns, or approaches to use
-   - Reference line numbers or code snippets if helpful
-
-### Example
-
-```markdown
-# Plan: Add OAuth2 Authentication
-
-## Context
-**Background**: The app currently only supports username/password auth. Users have requested social login to reduce friction during signup.
-**Task**: Implement OAuth2 flow for user authentication
-**Goal**: Enable secure third-party authentication via Google and GitHub
-**Constraints**: Must integrate with existing session management; no new dependencies preferred
-
-## Relevant Files
-**Modify:**
-- `src/auth/middleware.ts` - Add OAuth callback handlers
-- `src/routes/auth.ts` - Add OAuth routes
-
-**Reference for patterns:**
-- `src/auth/password.ts` - Shows existing auth flow pattern
-- `src/config/index.ts` - Where to add OAuth credentials
-
-## Implementation Steps
-[Detailed steps here...]
 ```
+# Plan: <descriptive title>
 
-This context allows reviewers to assess whether your plan addresses the user's needs, AND enables the implementing agent to execute it without needing to re-discover your research.
-""".strip()
-
-
-def get_questions_offer_template() -> str:
-    """Get the clarifying questions offer template.
-
-    Uses persona-based questioning to surface hidden constraints.
-
-    Returns:
-        Formatted markdown prompt for offering clarifying questions
-    """
-    from .persona_questions import format_questions_for_prompt
+## Background
+Why this change is needed (2-3 sentences)
 
-    persona_questions = format_questions_for_prompt()
+## Task
+What exactly to build/change
 
-    return f"""
-## First Plan Write - Optional Clarifying Questions
-
-Your initial plan has been saved. Before finalizing, ask the user if they'd like to answer clarifying questions to refine it.
-
-**Use AskUserQuestion now:**
-
-Header: "Questions?"
-Question: "I've drafted an initial plan. Would you like to answer a few clarifying questions from different perspectives so I can refine it?"
-Options:
-- "Yes, ask me questions" (description: "I'll ask targeted questions to surface hidden constraints, then update the plan")
-- "No, proceed as-is" (description: "Skip questions and proceed with the current plan")
+## Files
+**Modify:**
+- `exact/path/to/file.py` - What changes (reference line numbers or patterns)
 
-### If user chooses YES:
+**Reference:**
+- `exact/path/to/reference.py` - Why relevant (e.g., "pattern to follow at lines 12-30")
 
-{persona_questions}
+## Steps
+1. [Specific steps with function names, patterns, or code snippets]
+2. [Enough detail for someone who never saw this conversation]
 
-After gathering answers, **update the plan file** with refined content before calling ExitPlanMode.
+## Constraints
+- Technical requirements, preferences, or limitations
+```
 
-### If user chooses NO:
-Proceed directly to ExitPlanMode with the current plan.
+### Self-Check
+- [ ] Could I execute this if I forgot our entire conversation?
+- [ ] Are file paths exact (not "the auth file")?
+- [ ] Are implementation details specific (not "use the approach we discussed")?
 """.strip()

package/dist/templates/_shared/scripts/save_handoff.py

@@ -31,8 +31,8 @@ SCRIPT_DIR = Path(__file__).resolve().parent
 SHARED_ROOT = SCRIPT_DIR.parent
 sys.path.insert(0, str(SHARED_ROOT))
 
-from lib.context.context_manager import get_context
-from lib.base.utils import eprint
+from lib.context.context_store import get_context, save_state, update_mode
+from lib.base.logger import log_info, log_warn, log_error
 from lib.base.atomic_write import atomic_write
 from lib.base.constants import get_handoff_folder_path
 
@@ -106,16 +106,14 @@ def get_git_status() -> str:
 
 
 def get_plan_path_from_context(context_id: str, project_root: Path) -> Optional[Path]:
-    """Get the plan path from context.json if available."""
+    """Get the plan path from state.json if available."""
     context = get_context(context_id, project_root)
-    if not context or not context.in_flight:
+    if not context or not context.plan_path:
         return None
 
-    artifact_path = context.in_flight.artifact_path
-    if artifact_path:
-        plan_path = Path(artifact_path)
-        if plan_path.exists():
-            return plan_path
+    plan_path = Path(context.plan_path)
+    if plan_path.exists():
+        return plan_path
 
     return None
 
@@ -206,7 +204,7 @@ def write_section_file(folder: Path, filename: str, title: str, content: str) ->
     file_path = folder / filename
     success, error = atomic_write(file_path, '\n'.join(lines))
     if not success:
-        eprint(f"[save_handoff] Warning: Failed to write {filename}: {error}")
+        log_warn("save_handoff", f"Failed to write {filename}: {error}")
         return False
     return True
 
@@ -224,7 +222,7 @@ def main():
     # Read content from stdin
     content = sys.stdin.read()
     if not content.strip():
-        print("Error: No content provided via stdin", file=sys.stderr)
+        log_error("save_handoff", "No content provided via stdin")
         sys.exit(1)
 
     # Project root is the parent of .aiwcli
@@ -233,19 +231,19 @@ def main():
     # Verify context exists
     context = get_context(context_id, project_root)
     if not context:
-        print(f"Error: Context not found: {context_id}", file=sys.stderr)
+        log_error("save_handoff", f"Context not found: {context_id}")
         sys.exit(1)
 
     # Parse frontmatter and sections
     frontmatter, body = parse_frontmatter(content)
     sections = parse_handoff_sections(body)
 
-    eprint(f"[save_handoff] Parsed {len(sections)} sections: {list(sections.keys())}")
+    log_info("save_handoff", f"Parsed {len(sections)} sections: {list(sections.keys())}")
 
     # Create handoff folder
     handoff_folder = get_handoff_folder_path(context_id, project_root)
     handoff_folder.mkdir(parents=True, exist_ok=True)
-    eprint(f"[save_handoff] Created folder: {handoff_folder}")
+    log_info("save_handoff", f"Created folder: {handoff_folder}")
 
     # Get git status
     git_status = get_git_status()
@@ -261,18 +259,18 @@ def main():
             plan_dest = handoff_folder / "plan.md"
             success, error = atomic_write(plan_dest, plan_content)
             if success:
-                eprint(f"[save_handoff] Copied plan from {plan_path}")
+                log_info("save_handoff", f"Copied plan from {plan_path}")
             else:
-                eprint(f"[save_handoff] Warning: Failed to copy plan: {error}")
+                log_warn("save_handoff", f"Failed to copy plan: {error}")
         except Exception as e:
-            eprint(f"[save_handoff] Warning: Failed to read plan: {e}")
+            log_warn("save_handoff", f"Failed to read plan: {e}")
 
     # Write index.md
     index_content = generate_index(frontmatter, sections, git_status, has_plan)
     index_path = handoff_folder / "index.md"
     success, error = atomic_write(index_path, index_content)
     if not success:
-        print(f"Error: Failed to write index.md: {error}", file=sys.stderr)
+        log_error("save_handoff", f"Failed to write index.md: {error}")
         sys.exit(1)
 
     # Write section files
@@ -313,7 +311,7 @@ def main():
         full_content = '\n'.join(content_parts) + '\n'
         success, error = atomic_write(file_path, full_content)
         if not success:
-            eprint(f"[save_handoff] Warning: Failed to write {filename}: {error}")
+            log_warn("save_handoff", f"Failed to write {filename}: {error}")
 
     # Ensure all expected files exist (even if empty)
     expected_files = ['completed-work.md', 'dead-ends.md', 'decisions.md', 'pending.md', 'context.md']
@@ -330,6 +328,28 @@ def main():
         if not file_path.exists():
             write_section_file(handoff_folder, filename, titles[filename], "")
 
+    # Set handoff_path so next session auto-detects it
+    try:
+        index_path_str = str(handoff_folder / "index.md")
+        state = get_context(context_id, project_root)
+        if state:
+            state.handoff_path = index_path_str
+            save_state(state, project_root)
+            log_info("save_handoff", f"Set handoff_path: {index_path_str}")
+        else:
+            log_warn("save_handoff", f"Could not load context state for {context_id}")
+    except Exception as e:
+        log_warn("save_handoff", f"Handoff saved but auto-resume won't work (context update failed): {e}")
+
+    # Transition context to idle — handoff is saved, no longer "active work"
+    # This prevents auto-selection in new sessions while keeping the context
+    # accessible via explicit caret commands (^, ^N)
+    try:
+        update_mode(context_id, "idle", project_root=project_root)
+        log_info("save_handoff", f"Set mode to 'idle' (dormant) for context: {context_id}")
+    except Exception as e:
+        log_warn("save_handoff", f"Failed to set dormant mode: {e}")
+
     # Output success message (ASCII-safe for Windows)
     print(f"[OK] Created handoff folder: {handoff_folder}")
     print(f"  - index.md (entry point with navigation)")