pascal-agent 0.3.4__tar.gz → 0.3.6__tar.gz

{pascal_agent-0.3.4 → pascal_agent-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pascal-agent
-Version: 0.3.4
+Version: 0.3.6
 Summary: Pascal — autonomous AI employee runtime with 4-layer safety
 Project-URL: Homepage, https://gitlab.com/laum0621/pascal
 Project-URL: Repository, https://gitlab.com/laum0621/pascal

{pascal_agent-0.3.4 → pascal_agent-0.3.6}/pyproject.toml

@@ -7,7 +7,7 @@ packages = ["src/pascal"]
 
 [project]
 name = "pascal-agent"
-version = "0.3.4"
+version = "0.3.6"
 description = "Pascal — autonomous AI employee runtime with 4-layer safety"
 readme = "README.md"
 license = {text = "MIT"}

{pascal_agent-0.3.4 → pascal_agent-0.3.6}/src/pascal/__init__.py

@@ -1,3 +1,3 @@
 """Pascal -- autonomous AI employee built on a working-document loop."""
 
-__version__ = "0.3.4"
+__version__ = "0.3.5"

{pascal_agent-0.3.4 → pascal_agent-0.3.6}/src/pascal/actions.py

@@ -17,7 +17,7 @@ from typing import Any, Callable
 from pascal.effect import classify_command, check_allowed, get_max_effect, escalation_message, effect_to_int
 from pascal.mcp import MCPManager
 from pascal.receipts import Ledger
-from pascal.sandbox import SandboxManager
+from pascal.sandbox import SandboxManager, decode_subprocess_output
 from pascal.state import PascalStore
 from pascal.tools import (
     execute_tool, TOOL_REGISTRY, TOOL_EFFECTS,
@@ -503,7 +503,12 @@ async def _handle_handle_notification(ctx: ActionContext, decision: dict[str, An
     ctx.store.handle_notification(notif_id)
     if notif and reply_sent:
         ctx.store.push_conversation_turn(notif["source"] if notif else "unknown", "assistant", reply_text)
-    return {"handled": notif_id, "response": response, "reply_sent": reply_sent}
+    return {
+        "handled": notif_id,
+        "response": response,
+        "reply_text": reply_text,
+        "reply_sent": reply_sent,
+    }
 
 
 async def _handle_dismiss_notification(ctx: ActionContext, decision: dict[str, Any]) -> dict[str, Any]:
@@ -832,8 +837,8 @@ async def _handle_delegate(ctx: ActionContext, decision: dict[str, Any]) -> dict
                 await refresh_task
             except asyncio.CancelledError:
                 pass
-        stdout = (stdout_bytes or b"").decode("utf-8", errors="replace")
-        stderr = (stderr_bytes or b"").decode("utf-8", errors="replace")
+        stdout = decode_subprocess_output(stdout_bytes)
+        stderr = decode_subprocess_output(stderr_bytes)
         ok = proc.returncode == 0
     except asyncio.TimeoutError:
         try:

{pascal_agent-0.3.4 → pascal_agent-0.3.6}/src/pascal/loop.py

@@ -71,6 +71,27 @@ _SYSTEM_PROMPT_NO_DESKTOP = _strip_prompt_section(
 )
 
 
+def _tool_calls_from_text_response(text: str, *, iteration: int, round_idx: int) -> list[ToolCall]:
+    """Backward-compatible fallback for providers/tests that still return action JSON as text."""
+    raw = text.strip()
+    if not raw:
+        return []
+    if raw.startswith("```"):
+        raw = raw.strip("`")
+        if raw.startswith("json"):
+            raw = raw[4:].strip()
+    try:
+        payload = json.loads(raw)
+    except (json.JSONDecodeError, TypeError, ValueError):
+        return []
+    if not isinstance(payload, dict) or "action" not in payload:
+        return []
+    action = str(payload.pop("action") or "").strip().lower()
+    if not action:
+        return []
+    return [ToolCall(id=f"text_{iteration}_{round_idx}", name=action, params=payload)]
+
+
 # ── Loop State ─────────────────────────────────────────────
 
 @dataclass
@@ -554,6 +575,12 @@ class LoopRunner:
 
             # Extract tool_calls from function calling response
             tool_calls = list(response.tool_calls or [])
+            if not tool_calls and response.text:
+                tool_calls = _tool_calls_from_text_response(
+                    response.text,
+                    iteration=iteration,
+                    round_idx=_round,
+                )
             self.state.consecutive_errors = 0
 
             # No tool_calls = text response → show to user and done
@@ -767,7 +794,7 @@ class LoopRunner:
                         continue
 
                 # Non-terminal stops
-                if result.stop_reason in ("stagnation", "max_errors"):
+                if result.stop_reason in ("text_response", "stagnation", "max_errors"):
                     break
 
                 # Context management

{pascal_agent-0.3.4 → pascal_agent-0.3.6}/src/pascal/prompt.py

@@ -33,7 +33,7 @@ Action semantics:
 - plan: create or repair a structured execution plan.
 - pick_task: choose the task to work on now.
 - create_task / create_subtask: create new tracked work items.
-- handle_notification / dismiss_notification: respond to inbound events.
+- handle_notification / dismiss_notification: ONLY for replying to the sender. This action does NOT execute anything. If a notification requests an action (e.g. "open Chrome", "create a file"), you MUST execute that action first via execute, then handle_notification to confirm the result. Never set response to claim an action was performed unless you already executed it in a prior step.
 - pause_task / block_task / fail_task / complete_task: update task state honestly.
 - add_todo / complete_todo: track fine-grained steps for the active task.
 - memorize: save a durable fact, lesson, preference, or procedure after learning something.
@@ -113,7 +113,7 @@ Priority rules:
 Memory and working files:
 - Reuse matching procedures via plan.
 - After new multi-step work, memorize it as a procedure.
-- Use reply_text in handle_notification when you need to answer a human.
+- Use reply_text in handle_notification when you need to answer a human. Remember: handle_notification is reply-only — execute the requested action BEFORE calling handle_notification.
 - For long research or multi-step work, write intermediate results to files (write_file) instead of keeping everything in memory. Files cost 0 tokens until read. Use set_context only for small, frequently needed values.
 - If context was compacted, a scratch file path may be provided. Read it only if you need prior context.
 - Policy rules MUST be followed.

{pascal_agent-0.3.4 → pascal_agent-0.3.6}/src/pascal/sandbox.py

@@ -4,10 +4,11 @@ Docker (if available) → RestrictedSandbox (fallback).
 Ported from Dorothy2. Zero framework dependencies.
 """
 
-from __future__ import annotations
-
-import logging
-import os
+from __future__ import annotations
+
+import locale
+import logging
+import os
 import re
 import shlex
 import subprocess
@@ -82,9 +83,8 @@ class DockerSandbox:
             cmd += ["-v", f"{os.path.realpath(self._workspace)}:/workspace", "-w", "/workspace"]
         cmd += [self._image, "sh", "-c", command]
 
-        try:
-            result = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout,
-                                     encoding="utf-8", errors="replace")
+        try:
+            result = subprocess.run(cmd, capture_output=True, timeout=timeout)
         except subprocess.TimeoutExpired:
             return SandboxResult(ok=False, elapsed_ms=(time.time() - t0) * 1000,
                                  sandbox_type="docker", error=f"Timeout ({timeout}s)")
@@ -92,8 +92,9 @@ class DockerSandbox:
             return SandboxResult(ok=False, elapsed_ms=(time.time() - t0) * 1000,
                                  sandbox_type="docker", error=f"Docker error: {e}")
 
-        stdout, stderr = _truncate(result.stdout or ""), _truncate(result.stderr or "")
-        return SandboxResult(
+        stdout = _truncate(decode_subprocess_output(result.stdout))
+        stderr = _truncate(decode_subprocess_output(result.stderr))
+        return SandboxResult(
             ok=result.returncode == 0, stdout=stdout, stderr=stderr,
             return_code=result.returncode, elapsed_ms=(time.time() - t0) * 1000,
             sandbox_type="docker",
@@ -150,8 +151,45 @@ def _check_paths_in_command(command: str, workspace: str) -> str | None:
 
 
 # Track temp directories created by make_safe_env for cleanup
-_sandbox_temp_dirs: list[str] = []
-_SANDBOX_TEMP_MAX = 50  # trigger cleanup when this many accumulate
+_sandbox_temp_dirs: list[str] = []
+_SANDBOX_TEMP_MAX = 50  # trigger cleanup when this many accumulate
+
+
+def decode_subprocess_output(data: bytes | None, *, preferred_encoding: str | None = None) -> str:
+    """Decode subprocess bytes without assuming Windows commands emit UTF-8."""
+    if not data:
+        return ""
+
+    candidates: list[str] = []
+    seen: set[str] = set()
+
+    def _add(encoding: str | None) -> None:
+        if not encoding:
+            return
+        normalized = encoding.strip()
+        if not normalized:
+            return
+        key = normalized.lower()
+        if key in seen:
+            return
+        seen.add(key)
+        candidates.append(normalized)
+
+    _add("utf-8")
+    _add(preferred_encoding)
+    _add(locale.getpreferredencoding(False))
+    if os.name == "nt":
+        _add("cp949")
+        _add("mbcs")
+
+    for encoding in candidates:
+        try:
+            return data.decode(encoding)
+        except (LookupError, UnicodeDecodeError):
+            continue
+
+    fallback = candidates[-1] if candidates else "utf-8"
+    return data.decode(fallback, errors="replace")
 
 
 def make_safe_env() -> tuple[dict[str, str], str]:
@@ -170,12 +208,14 @@ def make_safe_env() -> tuple[dict[str, str], str]:
     tmp_home = tempfile.mkdtemp(prefix="pascal_sandbox_")
     _sandbox_temp_dirs.append(tmp_home)
     # Proactive cleanup: remove old temp dirs when too many accumulate
-    if len(_sandbox_temp_dirs) > _SANDBOX_TEMP_MAX:
-        cleanup_sandbox_temps(keep_last=5)
-    safe_env["HOME"] = tmp_home
-    safe_env["TMPDIR"] = tmp_home
-    # Windows: also override user profile and temp directories
-    if os.name == "nt":
+    if len(_sandbox_temp_dirs) > _SANDBOX_TEMP_MAX:
+        cleanup_sandbox_temps(keep_last=5)
+    safe_env["HOME"] = tmp_home
+    safe_env["TMPDIR"] = tmp_home
+    safe_env.setdefault("PYTHONUTF8", "1")
+    safe_env.setdefault("PYTHONIOENCODING", "utf-8")
+    # Windows: also override user profile and temp directories
+    if os.name == "nt":
         safe_env["USERPROFILE"] = tmp_home
         safe_env["TEMP"] = tmp_home
         safe_env["TMP"] = tmp_home
@@ -229,12 +269,11 @@ class RestrictedSandbox:
                 # Malformed command -- fall back to platform-appropriate shell
                 cmd = ["cmd", "/c", command] if os.name == "nt" else ["sh", "-c", command]
 
-        try:
-            result = subprocess.run(
-                cmd, shell=False, capture_output=True, text=True,
-                timeout=timeout, cwd=cwd, env=safe_env,
-                encoding="utf-8", errors="replace",
-            )
+        try:
+            result = subprocess.run(
+                cmd, shell=False, capture_output=True,
+                timeout=timeout, cwd=cwd, env=safe_env,
+            )
         except subprocess.TimeoutExpired:
             return SandboxResult(ok=False, elapsed_ms=(time.time() - t0) * 1000,
                                  sandbox_type="restricted", error=f"Timeout ({timeout}s)")
@@ -255,8 +294,9 @@ class RestrictedSandbox:
             except Exception:
                 pass
 
-        stdout, stderr = _truncate(result.stdout or ""), _truncate(result.stderr or "")
-        return SandboxResult(
+        stdout = _truncate(decode_subprocess_output(result.stdout))
+        stderr = _truncate(decode_subprocess_output(result.stderr))
+        return SandboxResult(
             ok=result.returncode == 0, stdout=stdout, stderr=stderr,
             return_code=result.returncode, elapsed_ms=(time.time() - t0) * 1000,
             sandbox_type="restricted",

{pascal_agent-0.3.4 → pascal_agent-0.3.6}/src/pascal/tools.py

@@ -11,13 +11,16 @@ Visual tools return ContentBlock attachments → loop.py passes to LLM → LLM s
 
 from __future__ import annotations
 
-import base64
-import io
-import logging
-from pathlib import Path
-from typing import Any
-
-from pascal.types import ContentBlock
+import base64
+import io
+import logging
+import os
+import shutil
+from pathlib import Path
+from typing import Any
+
+from pascal.sandbox import decode_subprocess_output
+from pascal.types import ContentBlock
 
 logger = logging.getLogger(__name__)
 
@@ -539,29 +542,110 @@ async def clipboard_set(params: dict[str, Any]) -> dict[str, Any]:
         return {"ok": False, "output": "", "error": str(e)}
 
 
-# ── App lifecycle tools ──────────────────────────────────────────
-
-async def app_launch(params: dict[str, Any]) -> dict[str, Any]:
-    """Launch an application by name or path."""
-    import subprocess
-    target = params.get("name") or params.get("path") or ""
-    if not target:
-        return {"ok": False, "output": "", "error": "name or path is required"}
-    args = params.get("args", [])
-    if isinstance(args, str):
-        args = args.split()
-    try:
-        cmd = [target] + args
-        subprocess.Popen(cmd, shell=False)
-        return {"ok": True, "output": f"Launched: {target}", "error": ""}
-    except FileNotFoundError:
-        # Try via shell start (Windows)
-        try:
-            import os
-            os.startfile(target)
-            return {"ok": True, "output": f"Opened: {target}", "error": ""}
-        except Exception as e:
-            return {"ok": False, "output": "", "error": f"Cannot launch '{target}': {e}"}
+# ── App lifecycle tools ──────────────────────────────────────────
+
+def _resolve_app(target: str) -> str | None:
+    """Resolve common Windows app names to an executable path when possible."""
+    if not target:
+        return None
+
+    resolved = shutil.which(target)
+    if resolved:
+        return resolved
+
+    target_path = Path(target).expanduser()
+    if target_path.exists():
+        return str(target_path)
+
+    if os.name != "nt":
+        return None
+
+    name = target_path.stem.lower()
+    alias_commands = {
+        "chrome": ["chrome.exe", "chrome"],
+        "firefox": ["firefox.exe", "firefox"],
+        "edge": ["msedge.exe", "msedge"],
+        "notepad": ["notepad.exe", "notepad"],
+        "explorer": ["explorer.exe", "explorer"],
+        "code": ["code", "Code.exe"],
+        "terminal": ["wt.exe", "wt", "WindowsTerminal.exe"],
+        "cmd": ["cmd.exe", "cmd"],
+        "powershell": ["powershell.exe", "powershell"],
+    }
+    for command in alias_commands.get(name, []):
+        resolved = shutil.which(command)
+        if resolved:
+            return resolved
+
+    install_paths = {
+        "chrome": [
+            ("ProgramFiles", "Google/Chrome/Application/chrome.exe"),
+            ("ProgramFiles(x86)", "Google/Chrome/Application/chrome.exe"),
+            ("LOCALAPPDATA", "Google/Chrome/Application/chrome.exe"),
+        ],
+        "firefox": [
+            ("ProgramFiles", "Mozilla Firefox/firefox.exe"),
+            ("ProgramFiles(x86)", "Mozilla Firefox/firefox.exe"),
+        ],
+        "edge": [
+            ("ProgramFiles", "Microsoft/Edge/Application/msedge.exe"),
+            ("ProgramFiles(x86)", "Microsoft/Edge/Application/msedge.exe"),
+            ("LOCALAPPDATA", "Microsoft/Edge/Application/msedge.exe"),
+        ],
+        "notepad": [
+            ("SystemRoot", "System32/notepad.exe"),
+        ],
+        "explorer": [
+            ("SystemRoot", "explorer.exe"),
+        ],
+        "code": [
+            ("LOCALAPPDATA", "Programs/Microsoft VS Code/Code.exe"),
+            ("ProgramFiles", "Microsoft VS Code/Code.exe"),
+            ("ProgramFiles(x86)", "Microsoft VS Code/Code.exe"),
+        ],
+        "terminal": [
+            ("LOCALAPPDATA", "Microsoft/WindowsApps/wt.exe"),
+            ("ProgramFiles", "WindowsApps/wt.exe"),
+        ],
+        "cmd": [
+            ("SystemRoot", "System32/cmd.exe"),
+        ],
+        "powershell": [
+            ("SystemRoot", "System32/WindowsPowerShell/v1.0/powershell.exe"),
+        ],
+    }
+    for env_var, relative_path in install_paths.get(name, []):
+        base_dir = os.environ.get(env_var)
+        if not base_dir:
+            continue
+        candidate = Path(base_dir) / relative_path
+        if candidate.exists():
+            return str(candidate)
+
+    return None
+
+
+async def app_launch(params: dict[str, Any]) -> dict[str, Any]:
+    """Launch an application by name or path."""
+    import subprocess
+    target = params.get("name") or params.get("path") or ""
+    if not target:
+        return {"ok": False, "output": "", "error": "name or path is required"}
+    args = params.get("args", [])
+    if isinstance(args, str):
+        args = args.split()
+    resolved_target = _resolve_app(target) or target
+    try:
+        cmd = [resolved_target] + args
+        subprocess.Popen(cmd, shell=False)
+        return {"ok": True, "output": f"Launched: {target}", "error": ""}
+    except FileNotFoundError:
+        # Try via shell start (Windows)
+        try:
+            os.startfile(resolved_target)
+            return {"ok": True, "output": f"Opened: {target}", "error": ""}
+        except Exception as e:
+            return {"ok": False, "output": "", "error": f"Cannot launch '{target}': {e}"}
     except Exception as e:
         return {"ok": False, "output": "", "error": str(e)}
 
@@ -582,15 +666,15 @@ async def app_list(params: dict[str, Any]) -> dict[str, Any]:
         return {"ok": True, "output": "\n".join(lines[:50]) or "(no visible windows)", "error": ""}
     except ImportError:
         # Fallback: tasklist on Windows
-        import subprocess
-        try:
-            result = subprocess.run(
-                ["tasklist", "/FI", "STATUS eq RUNNING", "/FO", "CSV", "/NH"],
-                capture_output=True, text=True, timeout=5,
-            )
-            return {"ok": True, "output": result.stdout[:4000], "error": ""}
-        except Exception as e:
-            return {"ok": False, "output": "", "error": str(e)}
+        import subprocess
+        try:
+            result = subprocess.run(
+                ["tasklist", "/FI", "STATUS eq RUNNING", "/FO", "CSV", "/NH"],
+                capture_output=True, timeout=5,
+            )
+            return {"ok": True, "output": decode_subprocess_output(result.stdout)[:4000], "error": ""}
+        except Exception as e:
+            return {"ok": False, "output": "", "error": str(e)}
 
 
 async def app_close(params: dict[str, Any]) -> dict[str, Any]:

{pascal_agent-0.3.4 → pascal_agent-0.3.6}/tests/test_bugfixes.py

@@ -6,12 +6,13 @@ import json
 
 from conftest import MockLLM, j
 
-from pascal.actions import execute_action
-from pascal.desk import Desk
-from pascal.effect import classify_command
-from pascal.loop import run_loop, _detect_stagnation
-from pascal.state import PascalStore
-from pascal.tools import set_workspace
+from pascal.actions import execute_action
+from pascal.desk import Desk
+from pascal.effect import classify_command
+from pascal.loop import run_loop, _detect_stagnation
+from pascal.sandbox import decode_subprocess_output
+from pascal.state import PascalStore
+from pascal.tools import set_workspace
 
 
 class TestBug1StagnationNewestFirst:
@@ -258,8 +259,8 @@ class TestBug9NestedToolInputTrustScan:
         store.close()
 
 
-class TestBug10SilentSuccessCompletionGuard:
-    """Successful commands with no stdout should not block task completion."""
+class TestBug10SilentSuccessCompletionGuard:
+    """Successful commands with no stdout should not block task completion."""
 
     async def test_complete_task_allows_successful_silent_executes(self, tmp_path):
         store = PascalStore(str(tmp_path / "t.db"))
@@ -286,6 +287,72 @@ class TestBug10SilentSuccessCompletionGuard:
 
         assert result.get("completed") == tid
         task = store.connection.execute("SELECT status, result FROM tasks WHERE id = ?", (tid,)).fetchone()
-        assert task["status"] == "done"
-        assert task["result"] == "Workspace prepared"
-        store.close()
+        assert task["status"] == "done"
+        assert task["result"] == "Workspace prepared"
+        store.close()
+
+
+class TestBug11WindowsEncoding:
+    """Windows subprocess output should survive cp949 and utf-8 emitters."""
+
+    def test_decode_subprocess_output_prefers_utf8(self, monkeypatch):
+        monkeypatch.setattr("pascal.sandbox.locale.getpreferredencoding", lambda _=False: "cp949")
+        assert decode_subprocess_output("안녕".encode("utf-8")) == "안녕"
+
+    def test_decode_subprocess_output_falls_back_to_cp949(self, monkeypatch):
+        monkeypatch.setattr("pascal.sandbox.locale.getpreferredencoding", lambda _=False: "cp949")
+        assert decode_subprocess_output("안녕".encode("cp949")) == "안녕"
+
+
+class TestBug12TextRepliesVisible:
+    """Casual chat replies must be surfaced to the CLI/user."""
+
+    async def test_text_only_llm_reply_emits_text_response_action_once(self, tmp_path):
+        store = PascalStore(str(tmp_path / "t.db"))
+        seen: list[dict] = []
+
+        class TextOnlyLLM:
+            def __init__(self):
+                self.calls = 0
+
+            async def chat(self, messages, tools=None):
+                self.calls += 1
+                from pascal.types import LLMResponse
+                return LLMResponse(text="안녕")
+
+        llm = TextOnlyLLM()
+        actions = await run_loop(store, llm, max_iterations=5, on_action=seen.append)
+
+        assert llm.calls == 1
+        assert len(actions) == 1
+        assert actions[0]["action"] == "text_response"
+        assert actions[0]["result"]["text"] == "안녕"
+        assert seen[-1]["action"] == "text_response"
+        assert seen[-1]["result"]["text"] == "안녕"
+        store.close()
+
+    async def test_handle_notification_result_keeps_reply_text(self, tmp_path):
+        store = PascalStore(str(tmp_path / "t.db"))
+        notif_id = store.push_notification(source="cli", message="안녕")
+
+        result = await execute_action(
+            store,
+            {
+                "action": "handle_notification",
+                "notification_id": notif_id,
+                "reply_text": "안녕하세요",
+                "response": "casual hello",
+            },
+            "handle_notification",
+        )
+
+        assert result["reply_text"] == "안녕하세요"
+        store.close()
+
+    def test_cli_prints_text_response(self, monkeypatch, capsys):
+        import pascal.__main__ as cli
+
+        monkeypatch.setattr(cli, "_stop_spinner", lambda clear=True: None)
+        cli._print_action({"action": "text_response", "result": {"text": "안녕하세요"}})
+
+        assert "안녕하세요" in capsys.readouterr().out

{pascal_agent-0.3.4 → pascal_agent-0.3.6}/tests/test_tools.py

@@ -63,26 +63,63 @@ class TestFileTools:
         assert "Unknown tool" in result["error"]
 
 
-class TestToolRegistry:
-    def test_all_tools_registered(self):
-        expected = {"read_file", "write_file", "list_dir", "screenshot", "click",
-                    "type_text", "hotkey", "scroll", "skill", "channel_reply",
-                    "uia_snapshot", "uia_click", "uia_type", "uia_get_text",
+class TestToolRegistry:
+    def test_all_tools_registered(self):
+        expected = {"read_file", "write_file", "list_dir", "screenshot", "click",
+                    "type_text", "hotkey", "scroll", "skill", "channel_reply",
+                    "uia_snapshot", "uia_click", "uia_type", "uia_get_text",
                     "uia_find", "uia_wait", "window_focus",
                     "clipboard_get", "clipboard_set",
                     "app_launch", "app_list", "app_close"}
         assert expected == set(TOOL_REGISTRY.keys())
 
-    def test_all_tools_have_effect_levels(self):
-        for name in TOOL_REGISTRY:
-            assert name in TOOL_EFFECTS, f"Tool '{name}' missing from TOOL_EFFECTS"
-
-
-class TestToolSafetyGate:
-    async def test_write_file_allowed_at_e2(self, tmp_path):
-        set_workspace(str(tmp_path))
-        store = PascalStore(str(tmp_path / "t.db"))
-        target = tmp_path / "safe.txt"
+    def test_all_tools_have_effect_levels(self):
+        for name in TOOL_REGISTRY:
+            assert name in TOOL_EFFECTS, f"Tool '{name}' missing from TOOL_EFFECTS"
+
+
+class TestAppLaunch:
+    def test_resolve_app_checks_common_windows_paths(self, tmp_path, monkeypatch):
+        from pascal import tools
+
+        chrome = tmp_path / "Google" / "Chrome" / "Application" / "chrome.exe"
+        chrome.parent.mkdir(parents=True)
+        chrome.write_text("")
+
+        monkeypatch.setattr(tools.shutil, "which", lambda name: None)
+        monkeypatch.setenv("ProgramFiles", str(tmp_path))
+        monkeypatch.setenv("ProgramFiles(x86)", "")
+        monkeypatch.setenv("LOCALAPPDATA", "")
+        monkeypatch.setenv("SystemRoot", "")
+
+        assert tools._resolve_app("chrome") == str(chrome)
+
+    async def test_app_launch_uses_resolved_target(self, monkeypatch):
+        import subprocess
+        from pascal import tools
+
+        seen = {}
+
+        def fake_popen(cmd, shell=False):
+            seen["cmd"] = cmd
+            seen["shell"] = shell
+            return object()
+
+        monkeypatch.setattr(tools, "_resolve_app", lambda name: r"C:\Apps\chrome.exe")
+        monkeypatch.setattr(subprocess, "Popen", fake_popen)
+
+        result = await tools.app_launch({"name": "chrome", "args": ["--incognito"]})
+
+        assert result["ok"] is True
+        assert seen["cmd"] == [r"C:\Apps\chrome.exe", "--incognito"]
+        assert seen["shell"] is False
+
+
+class TestToolSafetyGate:
+    async def test_write_file_allowed_at_e2(self, tmp_path):
+        set_workspace(str(tmp_path))
+        store = PascalStore(str(tmp_path / "t.db"))
+        target = tmp_path / "safe.txt"
         tid = store.add_task("Write file")
         llm = MockLLM([
             j(action="pick_task", task_id=tid, reason="start"),