aiwcli 0.9.0 → 0.9.1

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

@@ -1,40 +1,221 @@
 #!/usr/bin/env python3
-"""Save a handoff document and set context status to handoff_pending.
+"""Save a handoff document with folder-based sharding.
 
 Usage:
     python .aiwcli/_shared/scripts/save_handoff.py <context_id> <<'EOF'
-    # Your handoff markdown content here
+    # Your handoff markdown content here (with <!-- SECTION: name --> markers)
     EOF
 
 Or with a file:
     python .aiwcli/_shared/scripts/save_handoff.py <context_id> < handoff.md
 
 This script:
-1. Reads handoff markdown content from stdin
-2. Saves it to _output/contexts/{context_id}/handoffs/HANDOFF-{HHMM}.md
-3. Sets in_flight.mode = "handoff_pending"
-4. Records the event in events.jsonl
-
-The handoff will be automatically picked up by the next session.
+1. Parses sections from incoming markdown using <!-- SECTION: name --> markers
+2. Creates a timestamped folder at _output/contexts/{context_id}/handoffs/{YYYY-MM-DD-HHMM}/
+3. Writes sharded files:
+   - index.md (main entry point with navigation)
+   - completed-work.md, dead-ends.md, decisions.md, pending.md, context.md
+   - plan.md (copy of original plan if it exists)
+4. Records the event in events.jsonl (informational only)
 """
+import json
+import re
+import subprocess
 import sys
 from datetime import datetime
 from pathlib import Path
+from typing import Dict, Optional
 
 # Add parent directories to path for imports
 SCRIPT_DIR = Path(__file__).resolve().parent
 SHARED_ROOT = SCRIPT_DIR.parent
 sys.path.insert(0, str(SHARED_ROOT))
 
-from lib.context.context_manager import update_handoff_status, get_context
-from lib.base.utils import eprint, atomic_write
+from lib.context.context_manager import get_context
+from lib.base.utils import eprint
+from lib.base.atomic_write import atomic_write
+from lib.base.constants import get_handoff_folder_path
+
+
+def parse_frontmatter(content: str) -> tuple[Dict[str, str], str]:
+    """Parse YAML frontmatter from markdown content.
+
+    Returns:
+        Tuple of (frontmatter dict, remaining content)
+    """
+    frontmatter = {}
+    remaining = content
+
+    if content.startswith('---'):
+        parts = content.split('---', 2)
+        if len(parts) >= 3:
+            fm_lines = parts[1].strip().split('\n')
+            for line in fm_lines:
+                if ':' in line:
+                    key, value = line.split(':', 1)
+                    frontmatter[key.strip()] = value.strip()
+            remaining = parts[2].strip()
+
+    return frontmatter, remaining
+
+
+def parse_handoff_sections(content: str) -> Dict[str, str]:
+    """Parse markdown content by section markers.
+
+    Looks for <!-- SECTION: name --> markers and extracts content between them.
+
+    Returns:
+        Dict mapping section names to their content
+    """
+    sections = {}
+    current_section = None
+    current_content = []
+
+    for line in content.split('\n'):
+        if line.strip().startswith('<!-- SECTION:'):
+            # Save previous section
+            if current_section:
+                sections[current_section] = '\n'.join(current_content).strip()
+            # Extract new section name
+            match = re.search(r'<!-- SECTION:\s*(\S+)\s*-->', line)
+            if match:
+                current_section = match.group(1)
+                current_content = []
+        elif current_section:
+            current_content.append(line)
+
+    # Save final section
+    if current_section:
+        sections[current_section] = '\n'.join(current_content).strip()
+
+    return sections
+
+
+def get_git_status() -> str:
+    """Get current git status."""
+    try:
+        result = subprocess.run(
+            ['git', 'status', '--short'],
+            capture_output=True,
+            text=True,
+            timeout=5
+        )
+        return result.stdout.strip() or "(no changes)"
+    except Exception:
+        return "(git status unavailable)"
+
+
+def get_plan_path_from_context(context_id: str, project_root: Path) -> Optional[Path]:
+    """Get the plan path from context.json if available."""
+    context = get_context(context_id, project_root)
+    if not context or not context.in_flight:
+        return None
+
+    artifact_path = context.in_flight.artifact_path
+    if artifact_path:
+        plan_path = Path(artifact_path)
+        if plan_path.exists():
+            return plan_path
+
+    return None
+
+
+def generate_index(
+    frontmatter: Dict[str, str],
+    sections: Dict[str, str],
+    git_status: str,
+    has_plan: bool,
+) -> str:
+    """Generate the index.md file with summary and navigation."""
+    now = datetime.now()
+
+    lines = [
+        "---",
+        "type: handoff",
+        f"context_id: {frontmatter.get('context_id', 'unknown')}",
+        f"created_at: {now.isoformat()}",
+        f"session_id: {frontmatter.get('session_id', 'unknown')}",
+        f"project: {frontmatter.get('project', 'unknown')}",
+        f"plan_path: {frontmatter.get('plan_document', 'none')}",
+        "---",
+        "",
+        f"# Session Handoff - {now.strftime('%Y-%m-%d %H:%M')}",
+        "",
+    ]
+
+    # Summary section
+    summary = sections.get('summary', '').strip()
+    if summary:
+        # Extract just the content (skip the ## Summary header if present)
+        summary_lines = summary.split('\n')
+        summary_text = '\n'.join(
+            line for line in summary_lines
+            if not line.strip().startswith('##')
+        ).strip()
+        lines.extend([
+            "## Summary",
+            summary_text,
+            "",
+        ])
+
+    # Navigation table
+    lines.extend([
+        "## Quick Navigation",
+        "",
+        "| Document | Purpose | Priority |",
+        "|----------|---------|----------|",
+        "| [Dead Ends](./dead-ends.md) | Failed approaches - DO NOT RETRY | Read First |",
+        "| [Pending](./pending.md) | Next steps and blockers | Action Items |",
+        "| [Completed Work](./completed-work.md) | Tasks finished this session | Reference |",
+        "| [Decisions](./decisions.md) | Technical choices and rationale | Reference |",
+    ])
+
+    if has_plan:
+        lines.append("| [Plan](./plan.md) | Original plan being implemented | Reference |")
+
+    lines.extend([
+        "| [Context](./context.md) | External requirements and notes | Reference |",
+        "",
+        "## Continuation Instructions",
+        "",
+        "To continue this work in a new session:",
+        "1. This index document provides the overview",
+        "2. **Read [Dead Ends](./dead-ends.md) first** to avoid repeating failed approaches",
+        "3. Check [Pending](./pending.md) for immediate next steps",
+        "4. Reference other documents as needed",
+        "",
+        "## Git Status at Handoff",
+        "```",
+        git_status,
+        "```",
+        "",
+    ])
+
+    return '\n'.join(lines)
+
+
+def write_section_file(folder: Path, filename: str, title: str, content: str) -> bool:
+    """Write a section file with header."""
+    lines = [
+        f"# {title}",
+        "",
+        content if content else "(No content for this section)",
+        "",
+    ]
+
+    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}")
+        return False
+    return True
 
 
 def main():
     if len(sys.argv) < 2:
         print("Usage: python save_handoff.py <context_id> < content.md", file=sys.stderr)
         print("       python save_handoff.py <context_id> <<'EOF'", file=sys.stderr)
-        print("       ... markdown content ...", file=sys.stderr)
+        print("       ... markdown content with <!-- SECTION: name --> markers ...", file=sys.stderr)
         print("       EOF", file=sys.stderr)
         sys.exit(1)
 
@@ -55,44 +236,109 @@ def main():
         print(f"Error: Context not found: {context_id}", file=sys.stderr)
         sys.exit(1)
 
-    # Create handoffs directory
-    handoffs_dir = project_root / "_output" / "contexts" / context_id / "handoffs"
-    handoffs_dir.mkdir(parents=True, exist_ok=True)
+    # Parse frontmatter and sections
+    frontmatter, body = parse_frontmatter(content)
+    sections = parse_handoff_sections(body)
 
-    # Generate filename with timestamp
-    timestamp = datetime.now().strftime("%H%M")
-    filename = f"HANDOFF-{timestamp}.md"
-    file_path = handoffs_dir / filename
+    eprint(f"[save_handoff] Parsed {len(sections)} sections: {list(sections.keys())}")
 
-    # Handle filename collision (add suffix if file exists)
-    counter = 1
-    while file_path.exists():
-        filename = f"HANDOFF-{timestamp}-{counter}.md"
-        file_path = handoffs_dir / filename
-        counter += 1
+    # 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}")
 
-    # Save the handoff document
-    try:
-        success, error = atomic_write(file_path, content)
-        if not success:
-            print(f"Error: Failed to write handoff: {error}", file=sys.stderr)
-            sys.exit(1)
-    except Exception as e:
-        print(f"Error: Failed to write handoff: {e}", file=sys.stderr)
+    # Get git status
+    git_status = get_git_status()
+
+    # Check for plan
+    plan_path = get_plan_path_from_context(context_id, project_root)
+    has_plan = plan_path is not None
+
+    # Copy plan if exists
+    if plan_path:
+        try:
+            plan_content = plan_path.read_text(encoding='utf-8')
+            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}")
+            else:
+                eprint(f"[save_handoff] Warning: Failed to copy plan: {error}")
+        except Exception as e:
+            eprint(f"[save_handoff] Warning: 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)
         sys.exit(1)
 
-    # Update context status
-    try:
-        update_handoff_status(context_id, str(file_path), project_root)
-    except Exception as e:
-        eprint(f"[save_handoff] Warning: Status update failed: {e}")
-        # Don't exit - file was saved successfully
-
-    # Output success message
-    print(f"✓ Saved handoff: {file_path}")
-    print(f"✓ Set status to handoff_pending for context: {context_id}")
+    # Write section files
+    section_mapping = {
+        'completed': ('completed-work.md', 'Work Completed'),
+        'dead-ends': ('dead-ends.md', 'Dead Ends - Do Not Retry'),
+        'decisions': ('decisions.md', 'Key Decisions'),
+        'pending': ('pending.md', 'Pending Issues'),
+        'next-steps': ('pending.md', None),  # Append to pending.md
+        'files': ('completed-work.md', None),  # Append to completed-work.md
+        'context': ('context.md', 'Context for Future Sessions'),
+    }
+
+    # Track which files we've written with their content
+    file_contents: Dict[str, list] = {}
+
+    for section_name, (filename, title) in section_mapping.items():
+        section_content = sections.get(section_name, '')
+        if not section_content:
+            continue
+
+        if title is None:
+            # Append mode - add to existing content
+            if filename not in file_contents:
+                file_contents[filename] = []
+            file_contents[filename].append(section_content)
+        else:
+            # Write mode - set as main content with title
+            if filename not in file_contents:
+                file_contents[filename] = [f"# {title}", "", section_content]
+            else:
+                # Insert title at beginning if not present
+                file_contents[filename] = [f"# {title}", ""] + file_contents[filename] + ["", section_content]
+
+    # Write all accumulated content
+    for filename, content_parts in file_contents.items():
+        file_path = handoff_folder / filename
+        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}")
+
+    # Ensure all expected files exist (even if empty)
+    expected_files = ['completed-work.md', 'dead-ends.md', 'decisions.md', 'pending.md', 'context.md']
+    titles = {
+        'completed-work.md': 'Work Completed',
+        'dead-ends.md': 'Dead Ends - Do Not Retry',
+        'decisions.md': 'Key Decisions',
+        'pending.md': 'Pending Issues & Next Steps',
+        'context.md': 'Context for Future Sessions',
+    }
+
+    for filename in expected_files:
+        file_path = handoff_folder / filename
+        if not file_path.exists():
+            write_section_file(handoff_folder, filename, titles[filename], "")
+
+    # Output success message (ASCII-safe for Windows)
+    print(f"[OK] Created handoff folder: {handoff_folder}")
+    print(f"  - index.md (entry point with navigation)")
+
+    files_created = [f.name for f in handoff_folder.iterdir() if f.is_file() and f.name != 'index.md']
+    print(f"  - {', '.join(sorted(files_created))}")
+
     print()
-    print("The next session will automatically offer to resume from this handoff.")
+    print("Handoff document saved. Use this folder for context in the next session.")
 
 
 if __name__ == "__main__":

package/dist/templates/_shared/workflows/handoff.md

@@ -52,7 +52,7 @@ If no active context is found, inform the user and stop - handoffs require an ac
 
 ### Step 3: Generate Document
 
-Use this template:
+Use this template. The `<!-- SECTION: name -->` markers are required for the save script to parse sections into sharded files.
 
 ```markdown
 ---
@@ -66,34 +66,40 @@ plan_document: {path to plan if provided, or "none"}
 
 # Session Handoff — {Date}
 
+<!-- SECTION: summary -->
 ## Summary
 {2-3 sentences: what's different now vs. session start}
 
+<!-- SECTION: completed -->
 ## Work Completed
 {Grouped by category if multiple areas. Specific file:function references.}
 
+<!-- SECTION: dead-ends -->
 ## Dead Ends — Do Not Retry
-{Approaches that were tried and failed. Critical for avoiding wasted effort in future sessions.}
 
-### {Problem/Goal attempted}
-| Approach Tried | Why It Failed | Time Spent |
-|----------------|---------------|------------|
-| {What was attempted} | {Specific reason: error, incompatibility, performance, etc.} | {Rough estimate} |
+These approaches were attempted and failed. Do not retry without addressing the root cause.
 
-**What to try instead**: {If known, suggest alternative direction}
+| Approach | Why It Failed | Time Spent | Alternative |
+|----------|---------------|------------|-------------|
+| {What was attempted} | {Specific reason} | {Rough estimate} | {What to try instead} |
 
+<!-- SECTION: decisions -->
 ## Key Decisions
 {Technical choices with rationale. Format: **Decision**: Rationale. Trade-off: X.}
 
+<!-- SECTION: pending -->
 ## Pending Issues
 - [ ] {Issue} — {severity: HIGH/MED/LOW} {optional workaround note}
 
+<!-- SECTION: next-steps -->
 ## Next Steps
 1. {Actionable item with file:line reference if applicable}
 
+<!-- SECTION: files -->
 ## Files Modified
 {Significant changes only. Skip formatting-only edits.}
 
+<!-- SECTION: context -->
 ## Context for Future Sessions
 {Non-obvious context: env quirks, stakeholder requirements}
 
@@ -150,11 +156,12 @@ EOF
 ```
 
 This script:
-1. Saves the handoff to `_output/contexts/{context_id}/handoffs/HANDOFF-{HHMM}.md`
-2. Sets `in_flight.mode = "handoff_pending"`
-3. Records the event in the context's event log
+1. Creates a folder at `_output/contexts/{context_id}/handoffs/{YYYY-MM-DD-HHMM}/`
+2. Parses sections and writes sharded files (index.md, completed-work.md, dead-ends.md, etc.)
+3. Copies the current plan (if any) to plan.md
+4. Records the event in the context's event log (informational only)
 
-The next session will automatically detect the handoff and offer to resume.
+Use the handoff folder for context in the next session.
 
 ## Dead Ends Section Guidelines
 
@@ -185,10 +192,14 @@ This section is critical for preventing context rot across sessions. Be specific
 After creating file, output:
 
 ```
-✓ Created _output/contexts/{context_id}/handoffs/HANDOFF-{HHMM}.md
+✓ Created handoff folder: _output/contexts/{context_id}/handoffs/{YYYY-MM-DD-HHMM}/
+  - index.md (entry point with navigation)
+  - completed-work.md, dead-ends.md, decisions.md, pending.md, context.md
+  - plan.md (copy of current plan, if any)
 
 To continue next session:
-  "Load _output/contexts/{context_id}/handoffs/HANDOFF-{HHMM}.md and continue from next steps"
+  The index.md will be automatically suggested when you start a new session.
+  Read dead-ends.md first to avoid repeating failed approaches.
 
 ⚠️  {N} dead ends documented — avoid re-attempting these approaches
 ```
@@ -203,10 +214,13 @@ If plan was updated:
 
 ## Success Criteria
 
-- [ ] Handoff document created in context's `handoffs/` subfolder
-- [ ] Dead ends section captures all failed approaches with specific details
+- [ ] Handoff folder created at `handoffs/{YYYY-MM-DD-HHMM}/`
+- [ ] index.md contains summary and navigation table
+- [ ] All section files created (completed-work.md, dead-ends.md, etc.)
+- [ ] Dead ends use structured table format for quick scanning
+- [ ] plan.md copied from context if plan exists
 - [ ] Next steps are actionable with file references
-- [ ] Git status reflects current state
+- [ ] Git status included in index.md
 - [ ] If plan provided: checkboxes updated to reflect completion status
 - [ ] If plan provided: Session Progress Log appended
 - [ ] Context state updated to indicate handoff pending

package/dist/templates/cc-native/_cc-native/hooks/cc-native-plan-review.py

@@ -28,6 +28,7 @@ Output: _output/cc-native/plans/{YYYY-MM-DD}/{slug}/reviews/
 """
 
 import json
+import os
 import sys
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime
@@ -43,6 +44,9 @@ try:
     _shared = Path(__file__).parent.parent.parent / "_shared"
     sys.path.insert(0, str(_shared))
 
+    # Import subprocess utilities
+    from lib.base.subprocess_utils import is_internal_call
+
     from utils import (
         DEFAULT_DISPLAY,
         DEFAULT_SANITIZATION,
@@ -79,7 +83,7 @@ try:
         get_all_in_flight_contexts,
         get_all_contexts,
     )
-    from lib.base.constants import get_context_reviews_dir
+    from lib.base.constants import get_context_reviews_dir, get_review_folder_path
 except ImportError as e:
     print(f"[cc-native-plan-review] Failed to import lib: {e}", file=sys.stderr)
     sys.exit(0)  # Non-blocking failure
@@ -133,9 +137,10 @@ def get_active_context_for_review(session_id: str, project_root: Path) -> Option
 
     Strategy:
     1. Find context by session_id
-    2. Fallback: Single in-flight context
-    3. Fallback: Single planning context
-    4. Return None if multiple or no contexts found
+    2. Fallback: Single context in 'planning' mode
+    3. Return None if multiple planning contexts or no planning contexts found
+
+    Only triggers for contexts in 'planning' mode, not 'handoff_pending' or other modes.
 
     Args:
         session_id: Current session ID
@@ -150,23 +155,21 @@ def get_active_context_for_review(session_id: str, project_root: Path) -> Option
         eprint(f"[cc-native-plan-review] Found context by session_id: {context.id}")
         return context
 
-    # Strategy 2: Single in-flight context
+    # Strategy 2: Single planning context (only planning mode)
     in_flight = get_all_in_flight_contexts(project_root)
-    if len(in_flight) == 1:
-        eprint(f"[cc-native-plan-review] Found single in-flight context: {in_flight[0].id}")
-        return in_flight[0]
-
-    # Strategy 3: Single planning context
     planning_contexts = [c for c in in_flight if c.in_flight and c.in_flight.mode == "planning"]
     if len(planning_contexts) == 1:
         eprint(f"[cc-native-plan-review] Found single planning context: {planning_contexts[0].id}")
         return planning_contexts[0]
 
-    # Multiple or no contexts found
-    if len(in_flight) > 1:
-        eprint(f"[cc-native-plan-review] Multiple in-flight contexts ({len(in_flight)}), falling back to legacy")
+    # Multiple or no planning contexts found
+    if len(planning_contexts) > 1:
+        eprint(f"[cc-native-plan-review] Multiple planning contexts ({len(planning_contexts)}), cannot determine which to use")
+    elif len(in_flight) > 0:
+        modes = [c.in_flight.mode if c.in_flight else "none" for c in in_flight]
+        eprint(f"[cc-native-plan-review] Found {len(in_flight)} in-flight context(s) with modes {modes}, but none in 'planning' mode")
     else:
-        eprint("[cc-native-plan-review] No in-flight contexts found, falling back to legacy")
+        eprint("[cc-native-plan-review] No in-flight contexts found")
     return None
 
 
@@ -423,6 +426,11 @@ def load_agent_library(proj_dir: Path, settings: Optional[Dict[str, Any]] = None
 def main() -> int:
     eprint("[cc-native-plan-review] Unified hook started (PreToolUse)")
 
+    # Skip if internal subprocess call (orchestrator, agents)
+    if is_internal_call():
+        eprint("[cc-native-plan-review] Skipping: internal subprocess call")
+        return 0
+
     try:
         payload = json.load(sys.stdin)
     except json.JSONDecodeError as e:
@@ -582,11 +590,8 @@ def main() -> int:
                 # Use orchestrator result from phase 1
                 detected_complexity = orch_result.complexity
 
-                if orch_result.complexity == "simple" and not orch_result.selected_agents:
-                    eprint("[cc-native-plan-review] Orchestrator determined: simple complexity, no agent review needed")
-                else:
-                    selected_names = set(orch_result.selected_agents)
-                    selected_agents = [a for a in enabled_agents if a.name in selected_names]
+                selected_names = set(orch_result.selected_agents)
+                selected_agents = [a for a in enabled_agents if a.name in selected_names]
 
                     if not selected_agents and selected_names:
                         eprint(f"[cc-native-plan-review] Warning: orchestrator selected unknown agents: {selected_names}")
@@ -659,9 +664,20 @@ def main() -> int:
     display_settings = {**plan_settings.get("display", {}), **agent_settings.get("display", {})}
     combined_settings = {"display": display_settings}
 
+    # Get current iteration number for folder naming
+    current_iteration = 1
+    if iteration_state:
+        current_iteration = iteration_state.get("current", 1)
+
+    # Create review folder with datetime and iteration in name
+    review_folder = get_review_folder_path(active_context.id, current_iteration, base)
+    review_folder.mkdir(parents=True, exist_ok=True)
+    eprint(f"[cc-native-plan-review] Created review folder: {review_folder}")
+
     review_file = write_combined_artifacts(
         base, plan, combined_result, payload, combined_settings,
-        context_reviews_dir=reviews_dir
+        review_folder=review_folder,
+        iteration=current_iteration,
     )
     eprint(f"[cc-native-plan-review] Saved review: {review_file}")
 
@@ -704,6 +720,11 @@ def main() -> int:
         else:
             # Final iteration - increment current and save state
             iteration_state["current"] = iteration_state.get("current", 1) + 1
+            # Also increment max by 1 to allow another review cycle if the user rejects
+            # the plan and requests changes. Without this, once iterations are exhausted,
+            # the hook would skip review entirely (line ~498) even if the user sent the
+            # planner back to revise. This ensures rejected plans can always be re-reviewed.
+            iteration_state["max"] = iteration_state.get("max", 1) + 1
             save_iteration_state(reviews_dir, iteration_state)
 
     # Build output with correct Claude Code hook format

package/dist/templates/cc-native/_cc-native/lib/orchestrator.py

@@ -18,6 +18,11 @@ sys.path.insert(0, str(_lib_dir))
 from utils import OrchestratorResult, eprint, parse_json_maybe
 from reviewers.base import AgentConfig, OrchestratorConfig
 
+# Import shared subprocess utilities
+_shared_lib = Path(__file__).resolve().parent.parent.parent / "_shared" / "lib" / "base"
+sys.path.insert(0, str(_shared_lib))
+from subprocess_utils import get_internal_subprocess_env
+
 
 # ---------------------------
 # Constants
@@ -199,6 +204,9 @@ PLAN:
 
     eprint(f"[orchestrator] Running with model: {config.model}, timeout: {config.timeout}s")
 
+    # Get environment for internal subprocess (bypasses hooks)
+    env = get_internal_subprocess_env()
+
     try:
         p = subprocess.run(
             cmd_args,
@@ -208,6 +216,7 @@ PLAN:
             timeout=config.timeout,
             encoding="utf-8",
             errors="replace",
+            env=env,
         )
     except subprocess.TimeoutExpired:
         eprint(f"[orchestrator] TIMEOUT after {config.timeout}s, falling back to medium complexity")

package/dist/templates/cc-native/_cc-native/lib/reviewers/agent.py

@@ -18,6 +18,11 @@ sys.path.insert(0, str(_lib_dir))
 from utils import ReviewerResult, eprint, parse_json_maybe, coerce_to_review
 from .base import AgentConfig, AGENT_REVIEW_PROMPT_PREFIX
 
+# Import shared subprocess utilities
+_shared_lib = Path(__file__).resolve().parent.parent.parent.parent / "_shared" / "lib" / "base"
+sys.path.insert(0, str(_shared_lib))
+from subprocess_utils import get_internal_subprocess_env
+
 
 def _parse_claude_output(raw: str) -> Optional[Dict[str, Any]]:
     """Parse Claude CLI JSON output, handling various formats.
@@ -125,6 +130,9 @@ PLAN:
 
     eprint(f"[{agent.name}] Running with model: {agent.model}, timeout: {timeout}s, max-turns: {max_turns}")
 
+    # Get environment for internal subprocess (bypasses hooks)
+    env = get_internal_subprocess_env()
+
     try:
         p = subprocess.run(
             cmd_args,
@@ -134,6 +142,7 @@ PLAN:
             timeout=timeout,
             encoding="utf-8",
             errors="replace",
+            env=env,
         )
     except subprocess.TimeoutExpired:
         eprint(f"[{agent.name}] TIMEOUT after {timeout}s")