claude-mpm 5.4.96__py3-none-any.whl → 5.6.3__py3-none-any.whl

claude_mpm/core/unified_paths.py

@@ -76,6 +76,7 @@ class DeploymentContext(Enum):
     EDITABLE_INSTALL = "editable_install"
     PIP_INSTALL = "pip_install"
     PIPX_INSTALL = "pipx_install"
+    UV_TOOLS = "uv_tools"
     SYSTEM_PACKAGE = "system_package"
 
 
@@ -190,113 +191,100 @@ class PathContext:
 
         Priority order:
         1. Environment variable override (CLAUDE_MPM_DEV_MODE)
-        2. Current working directory is a claude-mpm development project
-        3. Editable installation detection
-        4. Path-based detection (development, pipx, system, pip)
+        2. Package installation path (uv tools, pipx, site-packages, editable)
+        3. Current working directory (opt-in with CLAUDE_MPM_PREFER_LOCAL_SOURCE)
+
+        This ensures installed packages use their installation paths rather than
+        accidentally picking up development paths from CWD.
         """
-        # Check for environment variable override
+        # 1. Explicit environment variable override
         if os.environ.get("CLAUDE_MPM_DEV_MODE", "").lower() in ("1", "true", "yes"):
             logger.debug(
                 "Development mode forced via CLAUDE_MPM_DEV_MODE environment variable"
             )
             return DeploymentContext.DEVELOPMENT
 
-        # Check if current working directory is a claude-mpm development project
-        # This handles the case where pipx claude-mpm is run from within the dev directory
-        cwd = _safe_cwd()
-        current = cwd
-        for _ in range(5):  # Check up to 5 levels up from current directory
-            if (current / "pyproject.toml").exists() and (
-                current / "src" / "claude_mpm"
-            ).exists():
-                # Check if this is the claude-mpm project
-                try:
-                    pyproject_content = (current / "pyproject.toml").read_text()
-                    if (
-                        'name = "claude-mpm"' in pyproject_content
-                        or '"claude-mpm"' in pyproject_content
-                    ):
-                        logger.debug(
-                            f"Detected claude-mpm development directory at {current}"
-                        )
-                        logger.debug(
-                            "Using development mode for local source preference"
-                        )
-                        return DeploymentContext.DEVELOPMENT
-                except Exception:  # nosec B110
-                    pass
-            if current == current.parent:
-                break
-            current = current.parent
-
+        # 2. Check where the actual package is installed
         try:
             import claude_mpm
 
             module_path = Path(claude_mpm.__file__).parent
+            package_str = str(module_path)
 
-            # First check if this is an editable install, regardless of path
-            # This is important for cases where pipx points to a development installation
-            if PathContext._is_editable_install():
-                logger.debug("Detected editable/development installation")
-                # Check if we should use development paths
-                # This could be because we're in a src/ directory or running from dev directory
-                if module_path.parent.name == "src":
-                    return DeploymentContext.DEVELOPMENT
-                if "pipx" in str(module_path):
-                    # Running via pipx but from within a development directory
-                    # Use development mode to prefer local source over pipx installation
-                    cwd = _safe_cwd()
-                    current = cwd
-                    for _ in range(5):
-                        if (current / "src" / "claude_mpm").exists() and (
-                            current / "pyproject.toml"
-                        ).exists():
-                            logger.debug(
-                                "Running pipx from development directory, using development mode"
-                            )
-                            return DeploymentContext.DEVELOPMENT
-                        if current == current.parent:
-                            break
-                        current = current.parent
-                    return DeploymentContext.EDITABLE_INSTALL
-                return DeploymentContext.EDITABLE_INSTALL
+            # UV tools installation (~/.local/share/uv/tools/)
+            if "/.local/share/uv/tools/" in package_str:
+                logger.debug(f"Detected uv tools installation at {module_path}")
+                return DeploymentContext.UV_TOOLS
 
-            # Check for development mode based on directory structure
-            # module_path is typically /path/to/project/src/claude_mpm
-            if (
-                module_path.parent.name == "src"
-                and (module_path.parent.parent / "src" / "claude_mpm").exists()
-            ):
+            # pipx installation (~/.local/pipx/venvs/)
+            if "/.local/pipx/venvs/" in package_str or "/pipx/" in package_str:
+                logger.debug(f"Detected pipx installation at {module_path}")
+                return DeploymentContext.PIPX_INSTALL
+
+            # site-packages (pip install) - but not editable
+            if "/site-packages/" in package_str and "/src/" not in package_str:
+                logger.debug(f"Detected pip installation at {module_path}")
+                return DeploymentContext.PIP_INSTALL
+
+            # Editable install (pip install -e) - module in src/
+            if module_path.parent.name == "src":
+                # Check if this is truly an editable install
+                if PathContext._is_editable_install():
+                    logger.debug(f"Detected editable installation at {module_path}")
+                    return DeploymentContext.EDITABLE_INSTALL
+                # Module in src/ but not editable - development mode
                 logger.debug(
                     f"Detected development mode via directory structure at {module_path}"
                 )
                 return DeploymentContext.DEVELOPMENT
 
-            # Check for pipx install
-            if "pipx" in str(module_path):
-                logger.debug(f"Detected pipx installation at {module_path}")
-                return DeploymentContext.PIPX_INSTALL
-
-            # Check for system package
-            if "dist-packages" in str(module_path):
+            # dist-packages (system package manager)
+            if "dist-packages" in package_str:
                 logger.debug(f"Detected system package installation at {module_path}")
                 return DeploymentContext.SYSTEM_PACKAGE
 
-            # Check for site-packages (could be pip or editable)
-            if "site-packages" in str(module_path):
-                # Already checked for editable above, so this is a regular pip install
-                logger.debug(f"Detected pip installation at {module_path}")
-                return DeploymentContext.PIP_INSTALL
-
-            # Default to pip install
+            # Default to pip install for any other installation
             logger.debug(f"Defaulting to pip installation for {module_path}")
             return DeploymentContext.PIP_INSTALL
 
         except ImportError:
             logger.debug(
-                "ImportError during context detection, defaulting to development"
+                "ImportError during module path detection, checking CWD as fallback"
             )
-            return DeploymentContext.DEVELOPMENT
+
+        # 3. CWD-based detection (OPT-IN ONLY for explicit development work)
+        # Only use CWD if explicitly requested or no package installation found
+        if os.environ.get("CLAUDE_MPM_PREFER_LOCAL_SOURCE", "").lower() in (
+            "1",
+            "true",
+            "yes",
+        ):
+            cwd = _safe_cwd()
+            current = cwd
+            for _ in range(5):  # Check up to 5 levels up from current directory
+                if (current / "pyproject.toml").exists() and (
+                    current / "src" / "claude_mpm"
+                ).exists():
+                    # Check if this is the claude-mpm project
+                    try:
+                        pyproject_content = (current / "pyproject.toml").read_text()
+                        if (
+                            'name = "claude-mpm"' in pyproject_content
+                            or '"claude-mpm"' in pyproject_content
+                        ):
+                            logger.debug(
+                                f"CLAUDE_MPM_PREFER_LOCAL_SOURCE: Using development directory at {current}"
+                            )
+                            return DeploymentContext.DEVELOPMENT
+                    except Exception:  # nosec B110
+                        pass
+                if current == current.parent:
+                    break
+                current = current.parent
+
+        # Final fallback: assume development mode
+        logger.debug("No installation detected, defaulting to development mode")
+        return DeploymentContext.DEVELOPMENT
 
 
 class UnifiedPathManager:

claude_mpm/experimental/cli_enhancements.py

@@ -58,8 +58,9 @@ class CLIContext:
             else "%(message)s"
         )
 
+        # MUST use stderr to avoid corrupting hook JSON output
         logging.basicConfig(
-            level=level, format=format_str, handlers=[logging.StreamHandler(sys.stdout)]
+            level=level, format=format_str, handlers=[logging.StreamHandler(sys.stderr)]
         )
         self.debug = debug
 

claude_mpm/hooks/claude_hooks/event_handlers.py

@@ -598,7 +598,11 @@ class EventHandlers:
                     threshold_crossed = auto_pause.on_usage_update(metadata["usage"])
                     if threshold_crossed:
                         warning = auto_pause.emit_threshold_warning(threshold_crossed)
-                        print(f"\n⚠️  {warning}", file=sys.stderr)
+                        # CRITICAL: Never write to stderr unconditionally - causes hook errors
+                        # Use _log() instead which only writes to file if DEBUG=true
+                        from . import _log
+
+                        _log(f"⚠️  Auto-pause threshold crossed: {warning}")
 
                         if DEBUG:
                             print(
@@ -949,6 +953,7 @@ class EventHandlers:
         - Provides visibility into new conversation sessions
         - Enables tracking of session lifecycle and duration
         - Useful for monitoring concurrent sessions and resource usage
+        - Auto-inject pending autotodos if enabled in config
         """
         session_id = event.get("session_id", "")
         working_dir = event.get("cwd", "")
@@ -962,6 +967,39 @@ class EventHandlers:
             "hook_event_name": "SessionStart",
         }
 
+        # Auto-inject pending autotodos if enabled
+        try:
+            from pathlib import Path
+
+            from claude_mpm.cli.commands.autotodos import get_pending_todos
+            from claude_mpm.core.config import Config
+
+            config = Config()
+            auto_inject_enabled = config.get("autotodos.auto_inject_on_startup", True)
+            max_todos = config.get("autotodos.max_todos_per_session", 10)
+
+            if auto_inject_enabled:
+                # Pass working directory from event to avoid Path.cwd() issues
+                working_dir_param = None
+                if working_dir:
+                    working_dir_param = Path(working_dir)
+
+                pending_todos = get_pending_todos(
+                    max_todos=max_todos, working_dir=working_dir_param
+                )
+                if pending_todos:
+                    session_start_data["pending_autotodos"] = pending_todos
+                    session_start_data["autotodos_count"] = len(pending_todos)
+                    if DEBUG:
+                        print(
+                            f"  - Auto-injected {len(pending_todos)} pending autotodos",
+                            file=sys.stderr,
+                        )
+        except Exception as e:  # nosec B110
+            # Auto-injection is optional - continue if it fails
+            if DEBUG:
+                print(f"  - Failed to auto-inject autotodos: {e}", file=sys.stderr)
+
         # Debug logging
         if DEBUG:
             print(

claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -22,7 +22,7 @@ import os
 import re
 import select
 import signal
-import subprocess
+import subprocess  # nosec B404
 import sys
 import threading
 from datetime import datetime, timezone
@@ -62,14 +62,31 @@ except ImportError:
 """
 Debug mode configuration for hook processing.
 
-WHY enabled by default: Hook processing can be complex and hard to debug.
-Having debug output available by default helps diagnose issues during development.
-Production deployments can disable via environment variable.
+WHY disabled by default: Production users should see clean output without debug noise.
+Hook errors appear less confusing when debug output is minimal.
+Development and debugging can enable via CLAUDE_MPM_HOOK_DEBUG=true.
 
 Performance Impact: Debug logging adds ~5-10% overhead but provides crucial
-visibility into event flow, timing, and error conditions.
+visibility into event flow, timing, and error conditions when enabled.
 """
-DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
+DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "false").lower() == "true"
+
+
+def _log(message: str) -> None:
+    """Log message to file if DEBUG enabled. Never write to stderr.
+
+    WHY: Claude Code interprets ANY stderr output as a hook error.
+    Writing to stderr causes confusing "hook error" messages even for debug logs.
+
+    This helper ensures all debug output goes to a log file instead.
+    """
+    if DEBUG:
+        try:
+            with open("/tmp/claude-mpm-hook.log", "a") as f:  # nosec B108
+                f.write(f"[{datetime.now(timezone.utc).isoformat()}] {message}\n")
+        except Exception:  # nosec B110 - intentional silent failure
+            pass  # Never disrupt hook execution
+
 
 """
 Conditional imports with graceful fallbacks for testing and modularity.
@@ -111,6 +128,8 @@ WHY version checking:
 Security: Version checking prevents execution on incompatible environments.
 """
 MIN_CLAUDE_VERSION = "1.0.92"
+# Minimum version for user-invocable skills support
+MIN_SKILLS_VERSION = "2.1.3"
 
 
 def check_claude_version() -> Tuple[bool, Optional[str]]:
@@ -155,7 +174,7 @@ def check_claude_version() -> Tuple[bool, Optional[str]]:
     """
     try:
         # Try to detect Claude Code version
-        result = subprocess.run(  # nosec B603 - Safe: hardcoded claude CLI with --version flag, no user input
+        result = subprocess.run(  # nosec B603 B607 - Safe: hardcoded claude CLI with --version flag, no user input
             ["claude", "--version"],
             capture_output=True,
             text=True,
@@ -186,22 +205,17 @@ def check_claude_version() -> Tuple[bool, Optional[str]]:
                     req_part = required[i] if i < len(required) else 0
 
                     if curr_part < req_part:
-                        if DEBUG:
-                            print(
-                                f"⚠️  Claude Code {version} does not support matcher-based hooks "
-                                f"(requires {MIN_CLAUDE_VERSION}+). Hook monitoring disabled.",
-                                file=sys.stderr,
-                            )
+                        _log(
+                            f"⚠️  Claude Code {version} does not support matcher-based hooks "
+                            f"(requires {MIN_CLAUDE_VERSION}+). Hook monitoring disabled."
+                        )
                         return False, version
                     if curr_part > req_part:
                         return True, version
 
                 return True, version
     except Exception as e:
-        if DEBUG:
-            print(
-                f"Warning: Could not detect Claude Code version: {e}", file=sys.stderr
-            )
+        _log(f"Warning: Could not detect Claude Code version: {e}")
 
     return False, None
 
@@ -242,11 +256,11 @@ class ClaudeHookHandler:
                 )
         except Exception as e:
             self.auto_pause_handler = None
-            if DEBUG:
-                print(f"Auto-pause initialization failed: {e}", file=sys.stderr)
+            _log(f"Auto-pause initialization failed: {e}")
 
         # Backward compatibility properties for tests
-        self.connection_pool = self.connection_manager.connection_pool
+        # Note: HTTP-based connection manager doesn't use connection_pool
+        self.connection_pool = None  # Deprecated: No longer needed with HTTP emission
 
         # Expose state manager properties for backward compatibility
         self.active_delegations = self.state_manager.active_delegations
@@ -275,8 +289,7 @@ class ClaudeHookHandler:
         def timeout_handler(signum, frame):
             """Handle timeout by forcing exit."""
             nonlocal _continue_sent
-            if DEBUG:
-                print(f"Hook handler timeout (pid: {os.getpid()})", file=sys.stderr)
+            _log(f"Hook handler timeout (pid: {os.getpid()})")
             if not _continue_sent:
                 self._continue_execution()
                 _continue_sent = True
@@ -297,11 +310,9 @@ class ClaudeHookHandler:
 
             # Check for duplicate events (same event within 100ms)
             if self.duplicate_detector.is_duplicate(event):
-                if DEBUG:
-                    print(
-                        f"[{datetime.now(timezone.utc).isoformat()}] Skipping duplicate event: {event.get('hook_event_name', 'unknown')} (PID: {os.getpid()})",
-                        file=sys.stderr,
-                    )
+                _log(
+                    f"[{datetime.now(timezone.utc).isoformat()}] Skipping duplicate event: {event.get('hook_event_name', 'unknown')} (PID: {os.getpid()})"
+                )
                 # Still need to output continue for this invocation
                 if not _continue_sent:
                     self._continue_execution()
@@ -309,12 +320,10 @@ class ClaudeHookHandler:
                 return
 
             # Debug: Log that we're processing an event
-            if DEBUG:
-                hook_type = event.get("hook_event_name", "unknown")
-                print(
-                    f"\n[{datetime.now(timezone.utc).isoformat()}] Processing hook event: {hook_type} (PID: {os.getpid()})",
-                    file=sys.stderr,
-                )
+            hook_type = event.get("hook_event_name", "unknown")
+            _log(
+                f"\n[{datetime.now(timezone.utc).isoformat()}] Processing hook event: {hook_type} (PID: {os.getpid()})"
+            )
 
             # Perform periodic cleanup if needed
             if self.state_manager.increment_events_processed():
@@ -323,11 +332,9 @@ class ClaudeHookHandler:
                 from .correlation_manager import CorrelationManager
 
                 CorrelationManager.cleanup_old()
-                if DEBUG:
-                    print(
-                        f"🧹 Performed cleanup after {self.state_manager.events_processed} events",
-                        file=sys.stderr,
-                    )
+                _log(
+                    f"🧹 Performed cleanup after {self.state_manager.events_processed} events"
+                )
 
             # Route event to appropriate handler
             # Handlers can optionally return modified input for PreToolUse events
@@ -367,8 +374,7 @@ class ClaudeHookHandler:
             ready, _, _ = select.select([sys.stdin], [], [], 1.0)
             if not ready:
                 # No data available within timeout
-                if DEBUG:
-                    print("No hook event data received within timeout", file=sys.stderr)
+                _log("No hook event data received within timeout")
                 return None
 
             # Data is available, read it
@@ -379,21 +385,16 @@ class ClaudeHookHandler:
 
             parsed = json.loads(event_data)
             # Debug: Log the actual event format we receive
-            if DEBUG:
-                print(
-                    f"Received event with keys: {list(parsed.keys())}", file=sys.stderr
-                )
-                for key in ["hook_event_name", "event", "type", "event_type"]:
-                    if key in parsed:
-                        print(f"  {key} = '{parsed[key]}'", file=sys.stderr)
+            _log(f"Received event with keys: {list(parsed.keys())}")
+            for key in ["hook_event_name", "event", "type", "event_type"]:
+                if key in parsed:
+                    _log(f"  {key} = '{parsed[key]}'")
             return parsed
         except (json.JSONDecodeError, ValueError) as e:
-            if DEBUG:
-                print(f"Failed to parse hook event: {e}", file=sys.stderr)
+            _log(f"Failed to parse hook event: {e}")
             return None
         except Exception as e:
-            if DEBUG:
-                print(f"Error reading hook event: {e}", file=sys.stderr)
+            _log(f"Error reading hook event: {e}")
             return None
 
     def _route_event(self, event: dict) -> Optional[dict]:
@@ -422,9 +423,9 @@ class ClaudeHookHandler:
         )
 
         # Log the actual event structure for debugging
-        if DEBUG and hook_type == "unknown":
-            print(f"Unknown event format, keys: {list(event.keys())}", file=sys.stderr)
-            print(f"Event sample: {str(event)[:200]}", file=sys.stderr)
+        if hook_type == "unknown":
+            _log(f"Unknown event format, keys: {list(event.keys())}")
+            _log(f"Event sample: {str(event)[:200]}")
 
         # Map event types to handlers
         event_handlers = {
@@ -460,8 +461,7 @@ class ClaudeHookHandler:
             except Exception as e:
                 error_message = str(e)
                 return_value = None
-                if DEBUG:
-                    print(f"Error handling {hook_type}: {e}", file=sys.stderr)
+                _log(f"Error handling {hook_type}: {e}")
             finally:
                 # Calculate duration
                 duration_ms = int((time.time() - start_time) * 1000)
@@ -495,9 +495,12 @@ class ClaudeHookHandler:
         """
         if modified_input is not None:
             # Claude Code v2.0.30+ supports modifying PreToolUse tool inputs
-            print(json.dumps({"action": "continue", "tool_input": modified_input}))
+            print(
+                json.dumps({"action": "continue", "tool_input": modified_input}),
+                flush=True,
+            )
         else:
-            print(json.dumps({"action": "continue"}))
+            print(json.dumps({"action": "continue"}), flush=True)
 
     # Delegation methods for compatibility with event_handlers
     def _track_delegation(self, session_id: str, agent_type: str, request_data=None):
@@ -583,11 +586,9 @@ class ClaudeHookHandler:
         # This uses the existing event infrastructure
         self._emit_socketio_event("", "hook_execution", hook_data)
 
-        if DEBUG:
-            print(
-                f"📊 Hook execution event: {hook_type} - {duration_ms}ms - {'✅' if success else '❌'}",
-                file=sys.stderr,
-            )
+        _log(
+            f"📊 Hook execution event: {hook_type} - {duration_ms}ms - {'✅' if success else '❌'}"
+        )
 
     def _generate_hook_summary(self, hook_type: str, event: dict, success: bool) -> str:
         """Generate a human-readable summary of what the hook did.
@@ -670,25 +671,18 @@ def main():
     if not is_compatible:
         # Version incompatible - just continue without processing
         # This prevents errors on older Claude Code versions
-        if DEBUG and version:
-            print(
-                f"Skipping hook processing due to version incompatibility ({version})",
-                file=sys.stderr,
-            )
-        print(json.dumps({"action": "continue"}))
+        if version:
+            _log(f"Skipping hook processing due to version incompatibility ({version})")
+        print(json.dumps({"action": "continue"}), flush=True)
         sys.exit(0)
 
     def cleanup_handler(signum=None, frame=None):
         """Cleanup handler for signals and exit."""
         nonlocal _continue_printed
-        if DEBUG:
-            print(
-                f"Hook handler cleanup (pid: {os.getpid()}, signal: {signum})",
-                file=sys.stderr,
-            )
+        _log(f"Hook handler cleanup (pid: {os.getpid()}, signal: {signum})")
         # Only output continue if we haven't already (i.e., if interrupted by signal)
         if signum is not None and not _continue_printed:
-            print(json.dumps({"action": "continue"}))
+            print(json.dumps({"action": "continue"}), flush=True)
             _continue_printed = True
             sys.exit(0)
 
@@ -702,15 +696,10 @@ def main():
         with _handler_lock:
             if _global_handler is None:
                 _global_handler = ClaudeHookHandler()
-                if DEBUG:
-                    print(
-                        f"✅ Created new ClaudeHookHandler singleton (pid: {os.getpid()})",
-                        file=sys.stderr,
-                    )
-            elif DEBUG:
-                print(
-                    f"♻️ Reusing existing ClaudeHookHandler singleton (pid: {os.getpid()})",
-                    file=sys.stderr,
+                _log(f"✅ Created new ClaudeHookHandler singleton (pid: {os.getpid()})")
+            else:
+                _log(
+                    f"♻️ Reusing existing ClaudeHookHandler singleton (pid: {os.getpid()})"
                 )
 
             handler = _global_handler
@@ -726,13 +715,17 @@ def main():
     except Exception as e:
         # Only output continue if not already printed
         if not _continue_printed:
-            print(json.dumps({"action": "continue"}))
+            print(json.dumps({"action": "continue"}), flush=True)
             _continue_printed = True
         # Log error for debugging
-        if DEBUG:
-            print(f"Hook handler error: {e}", file=sys.stderr)
+        _log(f"Hook handler error: {e}")
         sys.exit(0)  # Exit cleanly even on error
 
 
 if __name__ == "__main__":
-    main()
+    try:
+        main()
+    except Exception:
+        # Catastrophic failure (import error, etc.) - always output valid JSON
+        print(json.dumps({"action": "continue"}), flush=True)
+        sys.exit(0)

claude_mpm/hooks/claude_hooks/hook_wrapper.sh

@@ -48,15 +48,10 @@ echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] PYTHONPATH: $PYTHONPATH" >> /tmp/hook
 echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] Running: $PYTHON_CMD -m claude_mpm.hooks.claude_hooks.hook_handler" >> /tmp/hook-wrapper.log
 echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] SOCKETIO_PORT: $CLAUDE_MPM_SOCKETIO_PORT" >> /tmp/hook-wrapper.log
 
-# Run the Python hook handler as a module with error handling
-# Use exec to replace the shell process, but wrap in error handling
-if ! "$PYTHON_CMD" -m claude_mpm.hooks.claude_hooks.hook_handler "$@" 2>/tmp/hook-error.log; then
-    # If the Python handler fails, always return continue to not block Claude
-    echo '{"action": "continue"}'
-    # Log the error for debugging
-    echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] Hook handler failed, see /tmp/hook-error.log" >> /tmp/hook-wrapper.log
-    exit 0
-fi
+# Run the Python hook handler as a module
+# Python handler is responsible for ALL stdout output (including error fallback)
+# Redirect stderr to log file for debugging
+"$PYTHON_CMD" -m claude_mpm.hooks.claude_hooks.hook_handler "$@" 2>/tmp/hook-error.log
 
-# Success - Python handler already printed continue, just exit
-exit 0
+# Exit with Python's exit code (should always be 0)
+exit $?