aiwcli 0.10.3 → 0.11.1

package/dist/templates/cc-native/_cc-native/lib-ts/verdict.ts

@@ -0,0 +1,72 @@
+/**
+ * Pure verdict aggregation logic.
+ * See cc-native-plan-review-spec.md §4.2
+ */
+
+import type { ReviewDecisionResult, Verdict } from "./types.js";
+
+/**
+ * Return the worst verdict from a list.
+ * Order: pass < warn < fail. skip→pass, error→warn.
+ */
+export function worstVerdict(verdicts: Verdict[]): Verdict {
+  const order: Record<Verdict, number> = {
+    pass: 0,
+    warn: 1,
+    fail: 2,
+    skip: 0,
+    error: 1,
+  };
+
+  let worst: Verdict = "pass";
+  for (const v of verdicts) {
+    if ((order[v] ?? 1) > (order[worst] ?? 0)) {
+      worst = v;
+    }
+  }
+
+  // Normalize error → warn
+  if (worst === "error") return "warn";
+  return worst;
+}
+
+/**
+ * Verdict aggregation: fail veto triggers a block.
+ *
+ * Priority order:
+ * 1. Fail Veto: Any fail → deny (ISO 61508 zero-tolerance)
+ * 2. Acceptable: warns are informational only
+ *
+ * Error exclusion: Detectors that produce no signal (error/skip) are excluded
+ * from the denominator.
+ *
+ * @param allVerdicts - List of verdict strings from all reviewers
+ * @returns ReviewDecisionResult with should_deny, reason, and score
+ */
+export function computeReviewDecision(
+  allVerdicts: Verdict[],
+): ReviewDecisionResult {
+  // Exclude non-signal verdicts
+  const signalVerdicts = allVerdicts.filter(
+    (v) => v === "pass" || v === "warn" || v === "fail",
+  );
+
+  if (signalVerdicts.length === 0) {
+    return { should_deny: false, reason: "no_signal", score: 0.0 };
+  }
+
+  // Fail blocks unconditionally
+  const failCount = signalVerdicts.filter((v) => v === "fail").length;
+  if (failCount > 0) {
+    return { should_deny: true, reason: "fail_veto", score: 1.0 };
+  }
+
+  // Warn also blocks — reviewers flagged concerns worth addressing
+  const warnCount = signalVerdicts.filter((v) => v === "warn").length;
+  const warnRatio = warnCount / signalVerdicts.length;
+  if (warnCount > 0) {
+    return { should_deny: true, reason: "warn_block", score: warnRatio };
+  }
+
+  return { should_deny: false, reason: "acceptable", score: 0.0 };
+}

package/dist/templates/cc-native/_cc-native/plan-review.config.json

@@ -1,10 +1,22 @@
 {
+  "models": {
+    "providers": {
+      "claude": {
+        "enabled": true,
+        "models": ["sonnet"]
+      },
+      "codex": {
+        "enabled": true,
+        "models": ["gpt-5.1-codex-mini"]
+      }
+    }
+  },
   "planReview": {
     "enabled": true,
     "reviewers": {
       "codex": {
         "enabled": true,
-        "model": "o4-mini",
+        "model": "gpt-5.1-codex-mini",
         "timeout": 120
       },
       "gemini": {
@@ -23,6 +35,7 @@
     "enabled": true,
     "timeout": 180,
     "warnThreshold": 0.01,
+    "maxIssuesPerAgent": 3,
     "orchestrator": {
       "enabled": true,
       "model": "opus",

package/oclif.manifest.json

@@ -416,5 +416,5 @@
       ]
     }
   },
-  "version": "0.10.3"
+  "version": "0.11.1"
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "aiwcli",
   "description": "AI Workflow CLI - Command-line interface for AI-powered workflows",
-  "version": "0.10.3",
+  "version": "0.11.1",
   "author": "jofu-tofu",
   "bin": {
-    "aiw": "./bin/run.js"
+    "aiw": "bin/run.js"
   },
   "bugs": {
     "url": "https://github.com/jofu-tofu/AI-Workflow-CLI/issues"

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

@@ -1,16 +0,0 @@
-"""Shared hooks for AIW CLI templates.
-
-These hooks integrate with Claude Code's hook system to provide:
-- UserPromptSubmit: Context enforcement (ensures work happens in tracked context)
-- PostToolUse: Context monitoring and handoff warnings
-- ExitPlanMode: Plan archival to context
-
-Hooks read JSON input from stdin and output instructions to stdout.
-
-Available hooks:
-- user_prompt_submit.py: Runs on user prompt, enforces context tracking
-- context_monitor.py: Runs on PostToolUse, monitors context and warns when low
-- archive_plan.py: Runs on ExitPlanMode, archives plan to context
-- task_create_capture.py: Runs on TaskCreate, captures task events
-- task_update_capture.py: Runs on TaskUpdate, captures task updates
-"""

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

@@ -1,177 +0,0 @@
-#!/usr/bin/env python3
-"""Plan archival hook for ExitPlanMode PermissionRequest event.
-
-This hook runs when ExitPlanMode is requested (BEFORE user accepts/rejects),
-extracting the plan path from the tool input and archiving it to the
-context's plans/ folder. It does NOT modify state.json plan fields or mode.
-
-Separation of concerns:
-- archive_plan.py (PermissionRequest) -> archives file only, no state.json changes
-- plan_accepted.py (PostToolUse) -> assigns plan fields (hash/signature/path) to state.json
-- session_end.py (SessionEnd) -> transitions active -> has_plan when plan is assigned
-- context_selector.py -> matches plan content, transitions has_plan -> active
-
-Usage in .claude/settings.json:
-{
-  "hooks": {
-    "PermissionRequest": [{
-      "matcher": "ExitPlanMode",
-      "hooks": [{
-        "type": "command",
-        "command": "python .aiwcli/_shared/hooks/archive_plan.py",
-        "timeout": 5000
-      }]
-    }]
-  }
-}
-"""
-import re
-import sys
-from pathlib import Path
-from typing import Optional
-
-# 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.hook_utils import load_hook_input, log_debug, log_info, log_warn, log_error
-from lib.base.utils import project_dir
-from lib.base.constants import get_context_dir
-from lib.context.context_store import get_context_by_session_id
-from lib.context.plan_manager import archive_plan, extract_plan_path_from_result, find_plan_path_in_transcript
-
-# Import debug cleanup function from cc-native lib
-_cc_native_lib = SCRIPT_DIR.parent / "_cc-native" / "lib"
-sys.path.insert(0, str(_cc_native_lib))
-try:
-    from debug import cleanup_debug_folder
-except ImportError:
-    def cleanup_debug_folder(context_path):
-        pass
-
-
-def _find_plan_path(hook_input: dict, project_root: Path) -> Optional[str]:
-    """Find the plan file path from hook input or standard locations."""
-    tool_input = hook_input.get("tool_input", {})
-    tool_result = hook_input.get("tool_result", "")
-    hook_event = hook_input.get("hook_event_name", "")
-    tool_name = hook_input.get("tool_name", "")
-
-    plan_path = None
-
-    # For ExitPlanMode, extract from tool result
-    if tool_name == "ExitPlanMode" and tool_result:
-        plan_path = extract_plan_path_from_result(tool_result)
-        if plan_path:
-            log_info("archive_plan", f"Extracted plan path from result: {plan_path}")
-
-    # Check tool_input for plan path
-    if not plan_path:
-        plan_path = tool_input.get("plan_path") or tool_input.get("planPath")
-
-    # Parse transcript for most recent Write to .claude/plans/
-    if not plan_path:
-        transcript_path = hook_input.get("transcript_path")
-        if transcript_path:
-            plan_path = find_plan_path_in_transcript(transcript_path)
-            if plan_path:
-                log_info("archive_plan", f"Found plan path via transcript: {plan_path}")
-
-    # Search standard locations (mtime-based fallback)
-    if not plan_path:
-        log_debug("archive_plan", "No plan_path found, searching standard locations...")
-        claude_plans_dir = Path.home() / ".claude" / "plans"
-        if claude_plans_dir.exists():
-            claude_plans = sorted(
-                claude_plans_dir.glob("*.md"),
-                key=lambda p: p.stat().st_mtime,
-                reverse=True,
-            )
-            if claude_plans:
-                plan_path = str(claude_plans[0])
-
-    if not plan_path:
-        for fallback in [
-            project_root / "_output" / "cc-native" / "plans" / "current-plan.md",
-            project_root / "_output" / "plans" / "current-plan.md",
-            project_root / "plan.md",
-        ]:
-            if fallback.exists():
-                plan_path = str(fallback)
-                break
-
-    return plan_path
-
-
-def on_plan_archive():
-    """Archive plan on PermissionRequest:ExitPlanMode — file archival only, no state.json changes."""
-    hook_input = load_hook_input()
-    if not hook_input:
-        log_warn("archive_plan", "No valid JSON input")
-        return
-
-    hook_event = hook_input.get("hook_event_name", "unknown")
-    tool_name = hook_input.get("tool_name", "")
-
-    log_info("archive_plan", f"Hook triggered: {hook_event}, tool: {tool_name}")
-
-    # Only handle PermissionRequest for ExitPlanMode
-    if not (hook_event == "PermissionRequest" and tool_name == "ExitPlanMode"):
-        log_debug("archive_plan", "Skipping: not PermissionRequest:ExitPlanMode")
-        return
-
-    if hook_input.get("stop_hook_active", False):
-        log_debug("archive_plan", "Stop hook active, skipping")
-        return
-
-    project_root = project_dir(hook_input)
-    plan_path = _find_plan_path(hook_input, project_root)
-
-    if not plan_path:
-        log_warn("archive_plan", "Could not find plan file, skipping archival")
-        return
-
-    # Resolve plan path
-    plan_file = Path(plan_path)
-    if not plan_file.is_absolute():
-        plan_file = project_root / plan_path
-
-    log_debug("archive_plan", f"Resolved plan file: {plan_file}")
-
-    if not plan_file.exists():
-        log_error("archive_plan", f"Plan file not found: {plan_file}")
-        return
-
-    # Find context by session ID
-    session_id = hook_input.get("session_id", "unknown")
-    state = get_context_by_session_id(session_id, project_root)
-
-    if not state:
-        log_warn("archive_plan", "Could not determine context for session")
-        return
-
-    context_id = state.id
-
-    # Archive the plan file (returns path, hash, signature)
-    archived_path, plan_hash, plan_signature = archive_plan(
-        str(plan_file), context_id, project_root
-    )
-
-    if archived_path:
-        # Clean up debug logs
-        try:
-            context_path = get_context_dir(context_id, project_root)
-            cleanup_debug_folder(context_path)
-        except Exception as e:
-            log_warn("archive_plan", f"could not clean debug folder: {e}")
-
-        log_info("archive_plan", f"SUCCESS: archived plan for {context_id}")
-        log_debug("archive_plan", f"Path: {archived_path}, hash: {plan_hash}")
-    else:
-        log_error("archive_plan", f"Could not archive plan for '{context_id}'")
-
-
-if __name__ == "__main__":
-    from lib.base.hook_utils import run_hook
-    run_hook(on_plan_archive, "archive_plan")

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

@@ -1,270 +0,0 @@
-#!/usr/bin/env python3
-"""Context monitor hook for proactive handoff warnings.
-
-This hook runs on PostToolUse for context-heavy tools and monitors
-context window usage. When context drops below a threshold, it injects
-a system reminder instructing Claude to wrap up and create a handoff document.
-
-Unlike UserPromptSubmit hooks, this fires DURING Claude's work,
-allowing proactive intervention without waiting for user input.
-
-Monitored tools (configured via settings.json matcher):
-- Task: Subagent responses can be huge
-- Read: File content loads into context
-- Bash: Command output can be large
-- WebFetch: Web content loads into context
-
-Hook input (from Claude Code):
-{
-    "hook_event_name": "PostToolUse",
-    "tool_name": "Task",
-    "tool_input": {...},
-    "tool_result": {...},
-    "transcript_path": "/path/to/transcript.jsonl",
-    "session_id": "abc123",
-    "context_window": {
-        "current_usage": {
-            "cache_read_input_tokens": 0,
-            "input_tokens": 12345,
-            "cache_creation_input_tokens": 0,
-            "output_tokens": 6789
-        },
-        "context_window_size": 200000
-    },
-    ...
-}
-
-Hook output:
-- Outputs JSON with additionalContext if context is low
-- This injects a system reminder into Claude's context
-- Plain stdout from PostToolUse only goes to verbose mode, not Claude
-- Using additionalContext ensures Claude sees and responds to the warning
-
-KNOWN LIMITATION: Context percentage won't match /context exactly.
-Hook JSON excludes system prompt, tools, MCP tokens. We add a baseline
-to compensate (~22.6k tokens typical). See:
-https://github.com/anthropics/claude-code/issues/13783
-"""
-import sys
-from pathlib import Path
-from typing import Optional
-
-# 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.hook_utils import emit_context, load_hook_input, get_context_percent_remaining, log_debug, log_info, log_warn, log_error, log_diagnostic
-from lib.base.utils import now_iso, project_dir
-from lib.context.context_store import (
-    get_all_contexts,
-    get_context_by_session_id,
-    maybe_activate,
-    save_state,
-)
-
-# Module-level flag: only save auto-state once per process lifetime
-_PROGRESSIVE_SAVE_MARKER = ".progressive-save-done"
-
-# Configuration
-SAVE_STATE_THRESHOLD = 60  # Silently save auto-state at 60% remaining
-HANDOFF_SUGGEST_THRESHOLD = 30  # Gentle nudge at 30% remaining (70% used)
-HANDOFF_PREPARE_THRESHOLD = 20  # Stronger warning at 20% remaining (80% used)
-CRITICAL_CONTEXT_THRESHOLD = 10  # Urgent warning at 10% remaining (90% used)
-
-
-def get_current_context_id(project_root: Path = None) -> Optional[str]:
-    """Determine the current active context (most recently active)."""
-    contexts = get_all_contexts(status="active", project_root=project_root)
-    if contexts:
-        return contexts[0].id
-    return None
-
-
-def get_context_warning(
-    percent_remaining: int,
-    tokens_used: Optional[int],
-    max_tokens: Optional[int],
-    context_id: Optional[str],
-    tool_name: str
-) -> str:
-    """Generate appropriate warning based on context level."""
-    if tokens_used is not None and max_tokens is not None:
-        tokens_used_k = tokens_used // 1000
-        max_tokens_k = max_tokens // 1000
-        usage_line = f"**Estimated usage**: ~{tokens_used_k}k / {max_tokens_k}k tokens"
-    else:
-        usage_line = f"**Estimated usage**: ~{percent_remaining}% remaining"
-
-    context_line = f"\nContext ID: `{context_id}`" if context_id else ""
-
-    if percent_remaining <= CRITICAL_CONTEXT_THRESHOLD:
-        return f"""<system-reminder>
-## CRITICAL CONTEXT WARNING ({percent_remaining}% remaining)
-
-{usage_line}
-**Triggered by**: {tool_name} tool completion
-
-**CRITICAL: Run `/handoff` now before context is compacted.**
-{context_line}
-
-You are about to lose context. Stop all other work and run `/handoff` immediately.
-</system-reminder>"""
-
-    elif percent_remaining <= HANDOFF_PREPARE_THRESHOLD:
-        return f"""<system-reminder>
-## LOW CONTEXT WARNING ({percent_remaining}% remaining)
-
-{usage_line}
-**Triggered by**: {tool_name} tool completion
-
-**Context is getting low. Please finish your current task and run `/handoff`.**
-{context_line}
-
-**Actions:**
-1. Complete your current atomic task (if 1-2 steps away)
-2. Do NOT start new multi-step work
-3. Run `/handoff` to generate a handoff document
-</system-reminder>"""
-
-    else:
-        return f"""<system-reminder>
-## CONTEXT NOTICE ({percent_remaining}% remaining)
-
-{usage_line}
-**Triggered by**: {tool_name} tool completion
-
-**Consider preparing a handoff soon. When ready, run `/handoff` to generate a handoff document.**
-{context_line}
-
-Continue your current work, but avoid starting large new tasks.
-</system-reminder>"""
-
-
-def check_and_transition_mode(hook_input: dict) -> None:
-    """
-    Check if context mode needs to transition based on tool usage.
-
-    Handles:
-    - has_plan + implementation tool -> active (started implementing)
-    - idle + implementation tool -> active
-    """
-    project_root = project_dir(hook_input)
-    session_id = hook_input.get("session_id")
-
-    if not session_id:
-        return
-
-    state = get_context_by_session_id(session_id, project_root)
-    if not state:
-        return
-
-    # Implementation transitions only trigger on implementation tools
-    implementation_tools = {"Edit", "Write", "Bash", "NotebookEdit"}
-    tool_name = hook_input.get("tool_name", "")
-
-    if tool_name not in implementation_tools:
-        return
-
-    permission_mode = hook_input.get("permission_mode", "default")
-    maybe_activate(state.id, permission_mode, project_root=project_root, caller="context_monitor")
-
-
-def _try_progressive_save(hook_input: dict, percent_remaining: int) -> None:
-    """Silently save state at SAVE_STATE_THRESHOLD (60%)."""
-    try:
-        session_id = hook_input.get("session_id", "")
-        if not session_id:
-            return
-
-        project_root = project_dir(hook_input)
-        state = get_context_by_session_id(session_id, project_root)
-        if not state:
-            return
-
-        from lib.base.constants import get_context_dir
-        marker_path = get_context_dir(state.id, project_root) / _PROGRESSIVE_SAVE_MARKER
-        if marker_path.exists():
-            try:
-                saved_session = marker_path.read_text(encoding="utf-8").strip()
-                if saved_session == session_id:
-                    return
-            except OSError:
-                pass
-
-        log_info("context_monitor", f"Progressive save at {percent_remaining}% remaining")
-
-        # Just update last_active and save state
-        state.last_active = now_iso()
-        save_state(state, project_root)
-
-        try:
-            marker_path.write_text(session_id, encoding="utf-8")
-        except OSError:
-            pass
-
-    except Exception as e:
-        log_warn("context_monitor", f"Progressive save error (non-fatal): {e}")
-
-
-def check_context_level(hook_input: dict) -> Optional[str]:
-    """Check context level and return warning if low."""
-    tool_name = hook_input.get("tool_name", "Unknown")
-    percent_remaining, tokens_used, max_tokens = get_context_percent_remaining(hook_input)
-
-    log_diagnostic("context_monitor", "receive", f"tool={tool_name}, pct_remaining={percent_remaining}",
-                    inputs={"tool_name": tool_name, "percent_remaining": percent_remaining,
-                            "tokens_used": tokens_used, "max_tokens": max_tokens})
-
-    if percent_remaining is None:
-        return None
-
-    if percent_remaining > SAVE_STATE_THRESHOLD:
-        return None
-
-    if percent_remaining > HANDOFF_SUGGEST_THRESHOLD:
-        _try_progressive_save(hook_input, percent_remaining)
-        return None
-
-    if tokens_used is not None and max_tokens is not None:
-        log_info("context_monitor", f"Context: {percent_remaining}% remaining "
-                 f"(~{tokens_used//1000}k/{max_tokens//1000}k tokens)")
-    else:
-        log_info("context_monitor", f"Context: ~{percent_remaining}% remaining (from context.json)")
-
-    project_root = project_dir(hook_input)
-    context_id = get_current_context_id(project_root)
-
-    threshold = ("critical" if percent_remaining <= CRITICAL_CONTEXT_THRESHOLD
-                 else "prepare" if percent_remaining <= HANDOFF_PREPARE_THRESHOLD
-                 else "suggest")
-    log_diagnostic("context_monitor", "decide", f"Threshold={threshold} at {percent_remaining}%",
-                    decision=threshold, reasoning=f"{percent_remaining}% remaining",
-                    inputs={"context_id": context_id, "percent_remaining": percent_remaining})
-
-    return get_context_warning(percent_remaining, tokens_used, max_tokens, context_id, tool_name)
-
-
-def main():
-    """Main entry point for PostToolUse hook."""
-    try:
-        hook_input = load_hook_input()
-        if not hook_input:
-            return
-
-        check_and_transition_mode(hook_input)
-
-        warning = check_context_level(hook_input)
-        if warning:
-            emit_context(warning)
-
-    except Exception as e:
-        import traceback
-        tb = traceback.format_exc()
-        from lib.base.hook_utils import log_hook_error
-        log_hook_error("context_monitor", e, "PostToolUse", traceback_str=tb)
-
-
-if __name__ == "__main__":
-    from lib.base.hook_utils import run_hook
-    run_hook(main, "context_monitor")