aiwcli 0.9.7 → 0.9.8

package/dist/templates/_shared/lib/context/discovery.py

@@ -19,10 +19,110 @@ from .context_manager import (
     get_context_with_in_flight_work,
 )
 from .event_log import get_current_state, get_pending_tasks, Task
-from ..base.utils import parse_iso_timestamp
+from .auto_state import load_auto_state
+from .task_sync import generate_task_summary
+from ..base.utils import eprint, parse_iso_timestamp
+from ..base.constants import get_context_dir
 from ..templates.formatters import get_status_icon, format_continuation_header, get_mode_display
 
 
+def find_plan_path(context: Context, project_root: Path = None) -> Optional[str]:
+    """
+    Find the most relevant plan path for a context.
+
+    Priority:
+    1. Active plan (in_flight.artifact_path) if file exists
+    2. Most recent archived plan by mtime
+    3. None if no plans found
+
+    Args:
+        context: Context to find plan for
+        project_root: Project root directory
+
+    Returns:
+        Plan file path string or None
+    """
+    # 1. Active plan (in_flight.artifact_path)
+    if context.in_flight and context.in_flight.artifact_path:
+        plan_path = Path(context.in_flight.artifact_path)
+        if plan_path.exists():
+            return str(plan_path)
+
+    # 2. Archived plans (most recent by mtime)
+    plans_dir = get_context_dir(context.id, project_root) / "plans"
+    if plans_dir.exists():
+        plans = sorted(plans_dir.glob("*.md"), key=lambda p: p.stat().st_mtime, reverse=True)
+        if plans:
+            return str(plans[0])
+
+    # 3. No plan found
+    return None
+
+
+def _build_restore_sections(
+    context: Context,
+    project_root: Path = None
+) -> str:
+    """
+    Build restoration context sections from auto-state and task history.
+
+    Used by formatters to inject richer context when resuming work.
+    Returns empty string if no restoration data is available (fresh context).
+
+    Args:
+        context: Context being restored
+        project_root: Project root directory
+
+    Returns:
+        Formatted markdown sections (may be empty)
+    """
+    sections = []
+
+    # Load auto-state for git info and session end metadata
+    auto_state = load_auto_state(context.id, project_root)
+
+    # Add session end info if available
+    if auto_state:
+        saved_at = auto_state.get("saved_at", "")
+        save_reason = auto_state.get("save_reason", "")
+        if saved_at:
+            time_str = format_relative_time(saved_at)
+            reason_display = save_reason.replace("_", " ") if save_reason else "unknown"
+            sections.append(f"**Last session ended:** {time_str} ({reason_display})")
+
+    # Task summary (session-aware)
+    task_summary = generate_task_summary(context.id, project_root)
+    if task_summary and task_summary != "No tasks in this context.":
+        sections.append("")
+        sections.append(task_summary)
+
+    # Plan path
+    plan_path = find_plan_path(context, project_root)
+    if plan_path:
+        sections.append("")
+        sections.append("### Plan")
+        sections.append(f"Read the plan at: `{plan_path}`")
+
+    # Git state from auto-state
+    if auto_state:
+        git_state = auto_state.get("git_state", {})
+        if git_state:
+            branch = git_state.get("branch", "unknown")
+            uncommitted = git_state.get("uncommitted_files", [])
+            last_commit = git_state.get("last_commit_short", "")
+
+            sections.append("")
+            sections.append("### Git State")
+            uncommitted_str = ", ".join(uncommitted[:5]) if uncommitted else "none"
+            if len(uncommitted) > 5:
+                uncommitted_str += f" (+{len(uncommitted) - 5} more)"
+            sections.append(f"Branch: {branch} | Uncommitted: {uncommitted_str}")
+            if last_commit:
+                sections.append(f"Last commit: {last_commit}")
+
+    return "\n".join(sections)
+
+
 def discover_contexts_for_session(
     project_root: Path = None
 ) -> Tuple[List[Context], Optional[Context]]:
@@ -125,7 +225,7 @@ def format_context_list(contexts: List[Context]) -> str:
     return "\n".join(lines)
 
 
-def format_pending_plan_continuation(context: Context) -> str:
+def format_pending_plan_continuation(context: Context, project_root: Path = None) -> str:
     """
     Format output for plan handoff scenario.
 
@@ -135,47 +235,36 @@ def format_pending_plan_continuation(context: Context) -> str:
 
     Args:
         context: Context with pending plan implementation
+        project_root: Project root directory
 
     Returns:
         Formatted instructions for Claude
     """
     lines = [
-        format_continuation_header("context", context.id),
+        f"## Resuming Context: {context.id}",
         "",
         f"**Summary:** {context.summary}",
-        "",
+        f"**Mode:** Pending Implementation",
     ]
 
-    # Add plan info
-    if context.in_flight and context.in_flight.artifact_path:
-        lines.append(f"**Plan pending implementation:**")
-        lines.append(f"`{context.in_flight.artifact_path}`")
-        lines.append("")
-
-    # Add pending tasks if any
-    tasks = get_pending_tasks(context.id)
-    if tasks:
-        lines.append("**Previous tasks:**")
-        for task in tasks:
-            status_icon = get_status_icon(task.status)
-            lines.append(f"  {status_icon} {task.subject}")
-        lines.append("")
+    # Add restore sections (auto-state, tasks, git)
+    restore = _build_restore_sections(context, project_root)
+    if restore:
+        lines.append(restore)
 
     lines.extend([
+        "",
         "---",
         "",
         "**Instructions:**",
-        "1. Read the plan file above",
-        "2. Use TaskCreate to restore any pending tasks from the plan",
-        "3. Begin implementing the approved plan",
-        "",
-        "The context has been loaded. You may begin implementation.",
+        "1. Review the plan and previous work above",
+        "2. Continue from where the previous session left off",
     ])
 
     return "\n".join(lines)
 
 
-def format_implementation_continuation(context: Context) -> str:
+def format_implementation_continuation(context: Context, project_root: Path = None) -> str:
     """
     Format output for ongoing implementation scenario.
 
@@ -184,41 +273,30 @@ def format_implementation_continuation(context: Context) -> str:
 
     Args:
         context: Context with implementation in progress
+        project_root: Project root directory
 
     Returns:
         Formatted instructions for Claude
     """
     lines = [
-        format_continuation_header("implementing", context.id),
+        f"## Resuming Context: {context.id}",
         "",
         f"**Summary:** {context.summary}",
-        "",
+        f"**Mode:** Implementing",
     ]
 
-    # Add plan info
-    if context.in_flight and context.in_flight.artifact_path:
-        lines.append(f"**Plan being implemented:**")
-        lines.append(f"`{context.in_flight.artifact_path}`")
-        lines.append("")
-
-    # Add pending tasks
-    tasks = get_pending_tasks(context.id)
-    if tasks:
-        lines.append("**Pending tasks:**")
-        for task in tasks:
-            status_icon = get_status_icon(task.status)
-            lines.append(f"  {status_icon} {task.subject}")
-        lines.append("")
+    # Add restore sections (auto-state, tasks, git)
+    restore = _build_restore_sections(context, project_root)
+    if restore:
+        lines.append(restore)
 
     lines.extend([
+        "",
         "---",
         "",
         "**Instructions:**",
-        "1. Review the plan and pending tasks above",
-        "2. Use TaskCreate to restore pending tasks",
-        "3. Continue implementing",
-        "",
-        "The context has been loaded. You may continue.",
+        "1. Review the plan and previous work above",
+        "2. Continue from where the previous session left off",
     ])
 
     return "\n".join(lines)
@@ -333,14 +411,23 @@ def format_context_selection_required(contexts: List[Context]) -> str:
     return "\n".join(lines)
 
 
-def format_active_context_reminder(context: Context) -> str:
+def format_active_context_reminder(
+    context: Context,
+    project_root: Path = None,
+    include_restore: bool = False
+) -> str:
     """
     Format system reminder for active context.
 
-    Used by context enforcer hook to inject context awareness.
+    Called in two situations:
+    1. session_match (every prompt): include_restore=False → lightweight
+    2. auto_selected first bind: include_restore=True → rich restore context
 
     Args:
         context: Active context
+        project_root: Project root directory
+        include_restore: If True, include auto-state/tasks/git restore sections.
+                        Only set True on first bind to avoid per-prompt overhead.
 
     Returns:
         Formatted system reminder
@@ -356,16 +443,39 @@ def format_active_context_reminder(context: Context) -> str:
             # Remove brackets from "[Planning]" to get "Planning"
             mode_display = mode_str.strip("[]")
 
-    lines = [
-        f"## Active Context: {context.id}",
-        "",
-        f"**Summary:** {context.summary}",
-        f"**Mode:** {mode_display}",
-        f"**Last Active:** {time_str}",
-        "",
-        f'All work belongs to context "{context.id}".',
-        "Tasks created with TaskCreate will be persisted to this context.",
-    ]
+    if include_restore:
+        # Rich restore: first bind to existing context in new session
+        lines = [
+            f"## Resuming Context: {context.id}",
+            "",
+            f"**Summary:** {context.summary}",
+            f"**Mode:** {mode_display}",
+        ]
+
+        restore = _build_restore_sections(context, project_root)
+        if restore:
+            lines.append(restore)
+
+        lines.extend([
+            "",
+            "---",
+            "",
+            "**Instructions:**",
+            "1. Review the previous work above",
+            "2. Continue from where the previous session left off",
+        ])
+    else:
+        # Lightweight: subsequent prompts in same session
+        lines = [
+            f"## Active Context: {context.id}",
+            "",
+            f"**Summary:** {context.summary}",
+            f"**Mode:** {mode_display}",
+            f"**Last Active:** {time_str}",
+            "",
+            f'All work belongs to context "{context.id}".',
+            "Tasks created with TaskCreate will be persisted to this context.",
+        ]
 
     return "\n".join(lines)
 

package/dist/templates/_shared/lib/context/event_log.py

@@ -41,6 +41,9 @@ EVENT_PLAN_IMPLEMENTATION_STARTED = "plan_implementation_started"
 EVENT_PLAN_COMPLETED = "plan_completed"
 EVENT_HANDOFF_CREATED = "handoff_created"
 EVENT_HANDOFF_CLEARED = "handoff_cleared"
+EVENT_SESSION_ENDED = "session_ended"
+EVENT_AUTO_STATE_SAVED = "auto_state_saved"
+EVENT_TASK_DELETED = "task_deleted"
 
 
 @dataclass
@@ -248,6 +251,11 @@ def get_current_state(context_id: str, project_root: Path = None) -> ContextStat
                 tasks_map[task_id].status = "blocked"
                 tasks_map[task_id].blocked_reason = event.get("reason", "")
 
+        elif event_type == EVENT_TASK_DELETED:
+            task_id = event.get("task_id")
+            if task_id and task_id in tasks_map:
+                del tasks_map[task_id]
+
         elif event_type == EVENT_NOTE_ADDED:
             note = event.get("content", "")
             if note:

package/dist/templates/_shared/lib/context/task_sync.py

@@ -20,70 +20,91 @@ from .event_log import (
     get_current_state,
     get_pending_tasks,
     append_event,
+    read_events,
     Task,
     EVENT_TASK_ADDED,
     EVENT_TASK_STARTED,
     EVENT_TASK_COMPLETED,
     EVENT_TASK_BLOCKED,
+    EVENT_TASK_DELETED,
     EVENT_SESSION_STARTED,
+    EVENT_SESSION_ENDED,
 )
 from ..base.utils import eprint
 
 
 def generate_task_summary(context_id: str, project_root: Path = None) -> str:
     """
-    Generate a summary of all tasks in a context.
+    Generate a session-aware summary of all tasks in a context.
 
-    Useful for status checks and completion suggestions.
+    Includes session boundary awareness: tasks left in_progress when a session
+    ended are marked as "interrupted" to distinguish from actively worked tasks.
 
     Args:
         context_id: Context identifier
         project_root: Project root directory
 
     Returns:
-        Formatted task summary
+        Formatted task summary with session context
     """
     state = get_current_state(context_id, project_root)
 
     if not state.tasks:
         return "No tasks in this context."
 
+    # Find the latest session_ended event to detect interrupted tasks
+    events = read_events(context_id, project_root)
+    interrupted_task_ids = set()
+    for event in reversed(events):
+        if event.get("event") == EVENT_SESSION_ENDED:
+            interrupted_task_ids = set(event.get("active_tasks", []))
+            break
+
     completed = [t for t in state.tasks if t.status == "completed"]
+    interrupted = [t for t in state.tasks if t.status == "in_progress" and t.id in interrupted_task_ids]
+    in_progress = [t for t in state.tasks if t.status == "in_progress" and t.id not in interrupted_task_ids]
     pending = [t for t in state.tasks if t.status == "pending"]
-    in_progress = [t for t in state.tasks if t.status == "in_progress"]
     blocked = [t for t in state.tasks if t.status == "blocked"]
 
+    # Count sessions from session_ended events
+    session_count = sum(1 for e in events if e.get("event") == EVENT_SESSION_ENDED)
+
+    parts = []
+    if completed:
+        parts.append(f"{len(completed)} completed")
+    if interrupted:
+        parts.append(f"{len(interrupted)} interrupted")
+    if in_progress:
+        parts.append(f"{len(in_progress)} in progress")
+    if pending:
+        parts.append(f"{len(pending)} pending")
+    if blocked:
+        parts.append(f"{len(blocked)} blocked")
+
+    session_info = f" across {session_count} session{'s' if session_count != 1 else ''}" if session_count > 0 else ""
+
     lines = [
-        f"## Task Summary for: {context_id}",
-        "",
-        f"**Total:** {len(state.tasks)} tasks",
-        f"**Completed:** {len(completed)} | **In Progress:** {len(in_progress)} | **Pending:** {len(pending)} | **Blocked:** {len(blocked)}",
+        f"### Previous Work ({len(state.tasks)} tasks{session_info})",
         "",
     ]
 
-    if completed:
-        lines.append("### Completed")
-        for t in completed:
-            lines.append(f"- [x] {t.subject}")
-        lines.append("")
+    for t in completed:
+        work_info = ""
+        if t.work_summary:
+            work_info = f"\n  Work: {t.work_summary}"
+        lines.append(f"- [x] {t.id}: {t.subject}{work_info}")
 
-    if in_progress:
-        lines.append("### In Progress")
-        for t in in_progress:
-            lines.append(f"- [~] {t.subject}")
-        lines.append("")
+    for t in interrupted:
+        lines.append(f"- [~] {t.id}: {t.subject} (in progress when session ended)")
 
-    if pending:
-        lines.append("### Pending")
-        for t in pending:
-            lines.append(f"- [ ] {t.subject}")
-        lines.append("")
+    for t in in_progress:
+        lines.append(f"- [~] {t.id}: {t.subject}")
 
-    if blocked:
-        lines.append("### Blocked")
-        for t in blocked:
-            lines.append(f"- [!] {t.subject}: {t.blocked_reason}")
-        lines.append("")
+    for t in pending:
+        lines.append(f"- [ ] {t.id}: {t.subject}")
+
+    for t in blocked:
+        lines.append(f"- [!] {t.id}: {t.subject}: {t.blocked_reason}")
 
     return "\n".join(lines)
 
@@ -124,6 +145,7 @@ def record_task_created(
     subject: str,
     description: str = "",
     active_form: str = "",
+    session_id: str = "",
     project_root: Path = None
 ) -> bool:
     """
@@ -137,6 +159,7 @@ def record_task_created(
         subject: Task subject (required)
         description: Task description (optional)
         active_form: Spinner text for in_progress status (optional)
+        session_id: Session ID where task was created (optional)
         project_root: Project root directory
 
     Returns:
@@ -150,6 +173,8 @@ def record_task_created(
         event_data["description"] = description
     if active_form:
         event_data["activeForm"] = active_form
+    if session_id:
+        event_data["session_id"] = session_id
 
     return append_event(
         context_id,
@@ -162,6 +187,7 @@ def record_task_created(
 def record_task_started(
     context_id: str,
     task_id: str,
+    session_id: str = "",
     project_root: Path = None
 ) -> bool:
     """
@@ -172,16 +198,21 @@ def record_task_started(
     Args:
         context_id: Context identifier
         task_id: Persistent task ID
+        session_id: Session ID where task was started (optional)
         project_root: Project root directory
 
     Returns:
         True if event was recorded successfully
     """
+    event_data = {"task_id": task_id}
+    if session_id:
+        event_data["session_id"] = session_id
+
     return append_event(
         context_id,
         EVENT_TASK_STARTED,
         project_root,
-        task_id=task_id
+        **event_data
     )
 
 
@@ -192,6 +223,7 @@ def record_task_completed(
     work_summary: str = "",
     files_changed: Optional[List[str]] = None,
     commit_ref: str = "",
+    session_id: str = "",
     project_root: Path = None
 ) -> bool:
     """
@@ -206,6 +238,7 @@ def record_task_completed(
         work_summary: Summary of work done (optional)
         files_changed: List of files modified (optional)
         commit_ref: Git commit reference (optional)
+        session_id: Session ID where task was completed (optional)
         project_root: Project root directory
 
     Returns:
@@ -221,6 +254,8 @@ def record_task_completed(
         event_data["files_changed"] = files_changed
     if commit_ref:
         event_data["commit_ref"] = commit_ref
+    if session_id:
+        event_data["session_id"] = session_id
 
     return append_event(
         context_id,
@@ -234,6 +269,7 @@ def record_task_blocked(
     context_id: str,
     task_id: str,
     reason: str,
+    session_id: str = "",
     project_root: Path = None
 ) -> bool:
     """
@@ -245,17 +281,98 @@ def record_task_blocked(
         context_id: Context identifier
         task_id: Persistent task ID
         reason: Reason for being blocked
+        session_id: Session ID where task was blocked (optional)
         project_root: Project root directory
 
     Returns:
         True if event was recorded successfully
     """
+    event_data = {
+        "task_id": task_id,
+        "reason": reason,
+    }
+    if session_id:
+        event_data["session_id"] = session_id
+
     return append_event(
         context_id,
         EVENT_TASK_BLOCKED,
         project_root,
-        task_id=task_id,
-        reason=reason
+        **event_data
+    )
+
+
+def record_task_deleted(
+    context_id: str,
+    task_id: str,
+    session_id: str = "",
+    project_root: Path = None
+) -> bool:
+    """
+    Record a task_deleted event in the context's event log.
+
+    Called when Claude deletes a task via TaskUpdate with status="deleted".
+
+    Args:
+        context_id: Context identifier
+        task_id: Persistent task ID
+        session_id: Session ID where task was deleted (optional)
+        project_root: Project root directory
+
+    Returns:
+        True if event was recorded successfully
+    """
+    event_data = {"task_id": task_id}
+    if session_id:
+        event_data["session_id"] = session_id
+
+    return append_event(
+        context_id,
+        EVENT_TASK_DELETED,
+        project_root,
+        **event_data
+    )
+
+
+def record_session_ended(
+    context_id: str,
+    session_id: str,
+    reason: str = "other",
+    active_tasks: Optional[List[str]] = None,
+    pending_tasks: Optional[List[str]] = None,
+    project_root: Path = None
+) -> bool:
+    """
+    Record a session_ended event in the context's event log.
+
+    Creates a session boundary marker. Tasks left in_progress at session end
+    are recorded so they can be identified as "interrupted" during restore.
+
+    Args:
+        context_id: Context identifier
+        session_id: Session ID that ended
+        reason: Why session ended (prompt_input_exit, clear, logout, other)
+        active_tasks: Task IDs that were in_progress at session end
+        pending_tasks: Task IDs still pending at session end
+        project_root: Project root directory
+
+    Returns:
+        True if event was recorded successfully
+    """
+    event_data = {
+        "session_id": session_id,
+        "reason": reason,
+    }
+    if active_tasks:
+        event_data["active_tasks"] = active_tasks
+    if pending_tasks:
+        event_data["pending_tasks"] = pending_tasks
+
+    return append_event(
+        context_id,
+        EVENT_SESSION_ENDED,
+        project_root,
+        **event_data
     )
 
 
@@ -264,6 +381,7 @@ def generate_next_task_id(context_id: str, project_root: Path = None) -> str:
     Generate the next sequential task ID for a context.
 
     Task IDs follow the pattern: aiw-{n} where n starts at 1.
+    Accounts for deleted tasks by scanning all events, not just current state.
 
     Args:
         context_id: Context identifier
@@ -272,19 +390,18 @@ def generate_next_task_id(context_id: str, project_root: Path = None) -> str:
     Returns:
         Next available task ID (e.g., "aiw-3")
     """
-    state = get_current_state(context_id, project_root)
-
-    if not state.tasks:
-        return "aiw-1"
+    # Scan all events to find highest task ID ever used (including deleted)
+    events = read_events(context_id, project_root)
 
-    # Find highest existing task number
     max_num = 0
-    for task in state.tasks:
-        if task.id.startswith("aiw-"):
-            try:
-                num = int(task.id.split("-")[1])
-                max_num = max(max_num, num)
-            except (IndexError, ValueError):
-                pass
+    for event in events:
+        if event.get("event") == EVENT_TASK_ADDED:
+            task_id = event.get("task_id", "")
+            if task_id.startswith("aiw-"):
+                try:
+                    num = int(task_id.split("-")[1])
+                    max_num = max(max_num, num)
+                except (IndexError, ValueError):
+                    pass
 
     return f"aiw-{max_num + 1}"