diff --git a/docs/reference/cli-options.md b/docs/reference/cli-options.md
index 33b96f3..b49b95c 100644
--- a/docs/reference/cli-options.md
+++ b/docs/reference/cli-options.md
@@ -16,6 +16,7 @@ These options are useful for one-off runs, scripting, or experimentation. They t
 | `--verbose-tools` | Print info messages for tool execution in tools adapter. |
 | `--verbose-agent` | Print info messages for agent event and message part handling. |
 | `-z`, `--zero` | IDE zero mode: disables system prompt & all tools for raw LLM interaction |
+| `-u`, `--unrestricted-paths` | Disable path security: allow tool arguments to use any file/directory path (DANGEROUS) |
 | `-r`, `--read` | Enable tools that require read permissions (default: off) |
 | `-w`, `--write` | Enable tools that require write permissions (default: off) |
 | `-x`, `--exec` | Enable execution/run tools (allows running code or shell tools from the CLI). (default: off) |
@@ -48,7 +49,7 @@ janito -p openai -m gpt-3.5-turbo "Your prompt here"
 janito -p google -m gemini-2.5-flash "Your prompt here"
 janito --list-tools
 janito --web  # Enable clickable file links via web viewer
-
+janito -u -x --read --write "Run a tool with unrestricted paths (DANGEROUS)"
 ```
 
 ### ⚠️ Enabling Execution Tools
@@ -60,6 +61,15 @@ janito -x "Run this code: print('Hello, world!')"
 ```
 > **Warning:** Enabling execution tools allows running arbitrary code or shell commands. Only use `--exec` if you trust your prompt and environment.
 
+### ⚠️ Disabling Path Security
+
+By default, all file and directory arguments to tools are restricted to the working directory (see `--workdir`). To disable this security and allow any path (including system files), use the `-u` or `--unrestricted-paths` flag:
+
+```sh
+janito -u "Do something with C:/Windows/System32/hosts"
+```
+> **Warning:** Disabling path security is extremely dangerous. Only use `--unrestricted-paths` if you trust your prompt, tools, and environment.
+
 _This page is generated from the output of `janito --help`._
 
 ## 🧠 About `--effort`
diff --git a/janito/cli/core/runner.py b/janito/cli/core/runner.py
index da52ac4..7e981d6 100644
--- a/janito/cli/core/runner.py
+++ b/janito/cli/core/runner.py
@@ -117,7 +117,11 @@ def handle_runner(args, provider, llm_driver_config, agent_role, verbose_tools=F
     # Store the default permissions for later restoration (e.g., on /restart)
     from janito.tools.permissions import set_default_allowed_permissions
     set_default_allowed_permissions(allowed_permissions)
+    unrestricted_paths = getattr(args, "unrestricted_paths", False)
     adapter = janito.tools.get_local_tools_adapter(workdir=getattr(args, "workdir", None))
+    if unrestricted_paths:
+        # Patch: disable path security enforcement for this adapter instance
+        setattr(adapter, "unrestricted_paths", True)
 
     # Print allowed permissions in verbose mode
     if getattr(args, "verbose", False):
diff --git a/janito/cli/main_cli.py b/janito/cli/main_cli.py
index 40308a2..740d90c 100644
--- a/janito/cli/main_cli.py
+++ b/janito/cli/main_cli.py
@@ -14,6 +14,14 @@ from janito.cli.core.event_logger import (
 )
 
 definition = [
+    (
+        ["-u", "--unrestricted-paths"],
+        {
+            "action": "store_true",
+            "help": "Disable path security: allow tool arguments to use any file/directory path (DANGEROUS)",
+        },
+    ),
+
     (
         ["--profile"],
         {
diff --git a/janito/cli/rich_terminal_reporter.py b/janito/cli/rich_terminal_reporter.py
index abc67de..b189ed6 100644
--- a/janito/cli/rich_terminal_reporter.py
+++ b/janito/cli/rich_terminal_reporter.py
@@ -30,7 +30,8 @@ class RichTerminalReporter(EventHandlerBase):
         self.raw_mode = raw_mode
         import janito.report_events as report_events
 
-        super().__init__(driver_events, report_events)
+        import janito.tools.tool_events as tool_events
+        super().__init__(driver_events, report_events, tool_events)
         self._waiting_printed = False
 
     def on_RequestStarted(self, event):
@@ -102,7 +103,27 @@ class RichTerminalReporter(EventHandlerBase):
                 self.console.file.flush()
         # No output if not raw_mode or if response is None
 
+    def on_ToolCallError(self, event):
+        # Optionally handle tool call errors in a user-friendly way
+        error = getattr(event, "error", None)
+        tool = getattr(event, "tool_name", None)
+        if error and tool:
+            self.console.print(f"[bold red]Tool Error ({tool}):[/] {error}")
+            self.console.file.flush()
+
     def on_ReportEvent(self, event):
+        # Special handling for security-related report events
+        subtype = getattr(event, "subtype", None)
+        msg = getattr(event, "message", None)
+        action = getattr(event, "action", None)
+        tool = getattr(event, "tool", None)
+        context = getattr(event, "context", None)
+        if subtype == ReportSubtype.ERROR and msg and "[SECURITY] Path access denied" in msg:
+            # Highlight security errors with a distinct style
+            self.console.print(Panel(f"{msg}", title="[red]SECURITY VIOLATION[/red]", style="bold red"))
+            self.console.file.flush()
+            return
+
         msg = event.message if hasattr(event, "message") else None
         subtype = event.subtype if hasattr(event, "subtype") else None
         if not msg or not subtype:
diff --git a/janito/tools/adapters/local/adapter.py b/janito/tools/adapters/local/adapter.py
index 8e897a9..1e466a4 100644
--- a/janito/tools/adapters/local/adapter.py
+++ b/janito/tools/adapters/local/adapter.py
@@ -18,16 +18,51 @@ class LocalToolsAdapter(ToolsAdapter):
     """
 
     def __init__(self, tools=None, event_bus=None, workdir=None):
+        """Create a new LocalToolsAdapter.
+
+        Parameters
+        ----------
+        tools : list, optional
+            An optional iterable with tool *classes* (not instances) that should
+            be registered immediately.
+        event_bus : janito.event_bus.bus.EventBus, optional
+            The event bus to which tool-related events will be published.  When
+            *None* (default) the **global** :pydata:`janito.event_bus.bus.event_bus`
+            singleton is used so that CLI components such as the
+            :class:`janito.cli.rich_terminal_reporter.RichTerminalReporter` will
+            receive security violation or execution events automatically.
+        workdir : str | pathlib.Path, optional
+            Base directory that path-security checks will allow.  Defaults to
+            the current working directory at the time of instantiation.
+        """
+        # Fall back to the global event bus so that ReportEvents emitted from
+        # the tools adapter (for example path-security violations) are visible
+        # to UI components even if the caller did not supply a custom bus.
+        if event_bus is None:
+            from janito.event_bus.bus import event_bus as global_event_bus
+            event_bus = global_event_bus
+
         super().__init__(tools=tools, event_bus=event_bus)
+
+        # Internal registry structure: { tool_name: {"class": cls, "instance": obj, "function": obj.run} }
         self._tools: Dict[str, Dict[str, Any]] = {}
-        self.workdir = workdir
-        if self.workdir:
-            import os
-            os.chdir(self.workdir)
+
+        import os
+        self.workdir = workdir or os.getcwd()
+        # Ensure *some* workdir is set – fallback to CWD.
+        if not self.workdir:
+            self.workdir = os.getcwd()
+        # Normalise by changing the actual process working directory for
+        # consistency with many file-system tools.
+        os.chdir(self.workdir)
+
         if tools:
             for tool in tools:
                 self.register_tool(tool)
 
+    # ---------------------------------------------------------------------
+    # Registration helpers
+    # ---------------------------------------------------------------------
     def register_tool(self, tool_class: Type):
         instance = tool_class()
         if not hasattr(instance, "run") or not callable(instance.run):
@@ -54,28 +89,43 @@ class LocalToolsAdapter(ToolsAdapter):
     def disable_tool(self, name: str):
         self.unregister_tool(name)
 
+    # ------------------------------------------------------------------
+    # Lookup helpers used by ToolsAdapterBase
+    # ------------------------------------------------------------------
     def get_tool(self, name: str):
         return self._tools[name]["instance"] if name in self._tools else None
 
     def list_tools(self):
-        return [name for name, entry in self._tools.items() if self.is_tool_allowed(entry["instance"])]
+        return [
+            name
+            for name, entry in self._tools.items()
+            if self.is_tool_allowed(entry["instance"])
+        ]
 
     def get_tool_classes(self):
-        return [entry["class"] for entry in self._tools.values() if self.is_tool_allowed(entry["instance"])]
+        return [
+            entry["class"]
+            for entry in self._tools.values()
+            if self.is_tool_allowed(entry["instance"])
+        ]
 
     def get_tools(self):
-        return [entry["instance"] for entry in self._tools.values() if self.is_tool_allowed(entry["instance"])]
-
-
+        return [
+            entry["instance"]
+            for entry in self._tools.values()
+            if self.is_tool_allowed(entry["instance"])
+        ]
+
+    # ------------------------------------------------------------------
+    # Convenience methods
+    # ------------------------------------------------------------------
     def add_tool(self, tool):
-        # Register by instance (useful for hand-built objects)
+        """Register an *instance* (instead of a class) as a tool."""
         if not hasattr(tool, "run") or not callable(tool.run):
             raise TypeError(f"Tool '{tool}' must implement a callable 'run' method.")
         tool_name = getattr(tool, "tool_name", None)
         if not tool_name or not isinstance(tool_name, str):
-            raise ValueError(
-                f"Tool '{tool}' must provide a 'tool_name' (str) attribute."
-            )
+            raise ValueError(f"Tool '{tool}' must provide a 'tool_name' (str) attribute.")
         if tool_name in self._tools:
             raise ValueError(f"Tool '{tool_name}' is already registered.")
         self._tools[tool_name] = {
@@ -85,17 +135,28 @@ class LocalToolsAdapter(ToolsAdapter):
         }
 
 
-# Optional: a local-tool decorator
-
+# -------------------------------------------------------------------------
+# Decorator helper for quick registration of local tools
+# -------------------------------------------------------------------------
 
 def register_local_tool(tool=None):
+    """Class decorator that registers the tool on the *singleton* adapter.
+
+    Example
+    -------
+    >>> @register_local_tool
+    ... class MyTool(BaseTool):
+    ...     ...
+    """
+
     def decorator(cls):
-        from janito.tools.tool_base import ToolPermissions
-        from janito.tools.permissions import get_global_allowed_permissions
+                # Register the tool on a *fresh* adapter instance to avoid circular
+        # import issues during package initialisation.  This keeps behaviour
+        # identical to the original implementation while still allowing
+        # immediate use via the singleton in janito.tools.adapters.local.
         LocalToolsAdapter().register_tool(cls)
         return cls
 
     if tool is None:
         return decorator
     return decorator(tool)
-
diff --git a/janito/tools/adapters/local/create_file.py b/janito/tools/adapters/local/create_file.py
index fc48a2c..27b31c7 100644
--- a/janito/tools/adapters/local/create_file.py
+++ b/janito/tools/adapters/local/create_file.py
@@ -48,7 +48,7 @@ class CreateFileTool(ToolBase):
         if is_overwrite:
             # Overwrite branch: log only overwrite warning (no create message)
             self.report_action(
-                tr("⚠️ Overwriting file '{disp_path}'", disp_path=disp_path),
+                tr("⚠️  Overwriting file '{disp_path}'", disp_path=disp_path),
                 ReportAction.CREATE,
             )
         dir_name = os.path.dirname(path)
diff --git a/janito/tools/adapters/local/replace_text_in_file.py b/janito/tools/adapters/local/replace_text_in_file.py
index 19262a9..70bf515 100644
--- a/janito/tools/adapters/local/replace_text_in_file.py
+++ b/janito/tools/adapters/local/replace_text_in_file.py
@@ -144,14 +144,14 @@ class ReplaceTextInFileTool(ToolBase):
             warning = tr(" [Warning: Search text not found in file]")
         if not file_changed:
             self.report_warning(
-                tr(" ℹ️ No changes made. (not found)"), ReportAction.CREATE
+                tr(" ℹ️  No changes made. (not found)"), ReportAction.CREATE
             )
             concise_warning = tr(
                 "No changes made. The search text was not found. Expand your search context with surrounding lines if needed."
             )
         if occurrences > 1 and replaced_count == 0:
             self.report_warning(
-                tr(" ℹ️ No changes made. (not unique)"), ReportAction.CREATE
+                tr(" ℹ️  No changes made. (not unique)"), ReportAction.CREATE
             )
             concise_warning = tr(
                 "No changes made. The search text is not unique. Expand your search context with surrounding lines to ensure uniqueness."
diff --git a/janito/tools/tools_adapter.py b/janito/tools/tools_adapter.py
index 3dbff07..805fe36 100644
--- a/janito/tools/tools_adapter.py
+++ b/janito/tools/tools_adapter.py
@@ -167,6 +167,34 @@ class ToolsAdapterBase:
         if validation_error:
             return validation_error
 
+        # --- SECURITY: Path restriction enforcement ---
+        if not getattr(self, 'unrestricted_paths', False):
+            workdir = getattr(self, 'workdir', None)
+            # Ensure workdir is always set; default to current working directory.
+            if not workdir:
+                import os
+                workdir = os.getcwd()
+            from janito.tools.path_security import validate_paths_in_arguments, PathSecurityError
+            schema = getattr(tool, 'schema', None)
+            try:
+                validate_paths_in_arguments(arguments, workdir, schema=schema)
+            except PathSecurityError as sec_err:
+                # Publish both a ToolCallError and a user-facing ReportEvent for path security errors
+                self._publish_tool_call_error(tool_name, request_id, str(sec_err), arguments)
+                if self._event_bus:
+                    from janito.report_events import ReportEvent, ReportSubtype, ReportAction
+                    self._event_bus.publish(
+                        ReportEvent(
+                            subtype=ReportSubtype.ERROR,
+                            message=f"[SECURITY] Path access denied: {sec_err}",
+                            action=ReportAction.EXECUTE,
+                            tool=tool_name,
+                            context={"arguments": arguments, "request_id": request_id}
+                        )
+                    )
+                return f"Security error: {sec_err}"
+        # --- END SECURITY ---
+
         self._publish_tool_call_started(tool_name, request_id, arguments)
         self._print_verbose(f"[tools-adapter] Executing tool: {tool_name} with arguments: {arguments}")
         try:
