pascal-agent 1.1.0__tar.gz → 1.3.0__tar.gz

{pascal_agent-1.1.0 → pascal_agent-1.3.0}/.gitignore

@@ -37,3 +37,10 @@ artifacts/
 scratch/
 .gstack/
 .pascal_tmp/
+.omc/
+
+# Virtual environments
+venv/
+.venv/
+.audit-venv*/
+env/

{pascal_agent-1.1.0 → pascal_agent-1.3.0}/.gitlab-ci.yml

@@ -7,7 +7,7 @@ stages:
 
 before_script:
   - python -m pip install --upgrade pip
-  - python -m pip install -e ".[dev]" ruff mypy pytest-cov
+  - python -m pip install -e ".[all]" ruff mypy pytest-cov
 
 lint:
   stage: lint

pascal_agent-1.3.0/.omx/metrics.json

@@ -0,0 +1,8 @@
+{
+  "total_turns": 1,
+  "session_turns": 1,
+  "last_activity": "2026-04-03T16:03:15.353Z",
+  "session_input_tokens": 0,
+  "session_output_tokens": 0,
+  "session_total_tokens": 0
+}

pascal_agent-1.3.0/.omx/state/hud-state.json

@@ -0,0 +1,5 @@
+{
+  "last_turn_at": "2026-04-03T16:03:15.477Z",
+  "turn_count": 1,
+  "last_agent_output": "Pascal’s core is coherent: the desk-as-prompt loop, declarative plan tree, and 4-layer safety stack "
+}

pascal_agent-1.3.0/.omx/state/notify-hook-state.json

@@ -0,0 +1,6 @@
+{
+  "recent_turns": {
+    "019d540f-8f29-7512-84d9-9a6854d4e6b2|019d540f-8fa1-76d1-a361-46dec69d12fe|agent-turn-complete": 1775232195341
+  },
+  "last_event_at": "2026-04-03T16:03:15.341Z"
+}

pascal_agent-1.3.0/.omx/state/skill-active-state.json

@@ -0,0 +1,11 @@
+{
+  "version": 1,
+  "active": false,
+  "skill": "ultrawork",
+  "keyword": "PARALLEL",
+  "phase": "completing",
+  "activated_at": "2026-04-03T16:03:15.614Z",
+  "updated_at": "2026-04-03T16:03:16.077Z",
+  "source": "keyword-detector",
+  "input_lock": null
+}

pascal_agent-1.3.0/.omx/state/team-leader-nudge.json

@@ -0,0 +1,5 @@
+{
+  "last_nudged_by_team": {},
+  "last_idle_nudged_by_team": {},
+  "progress_by_team": {}
+}

pascal_agent-1.3.0/.omx/state/tmux-hook-state.json

@@ -0,0 +1,9 @@
+{
+  "total_injections": 0,
+  "pane_counts": {},
+  "session_counts": {},
+  "recent_keys": {},
+  "last_injection_ts": 0,
+  "last_reason": "disabled",
+  "last_event_at": "2026-04-03T16:03:15.617Z"
+}

{pascal_agent-1.1.0 → pascal_agent-1.3.0}/ARCHITECTURE.md

@@ -26,11 +26,14 @@ CLI / REPL / daemon / scheduler
         /         |          \
        v          v           v
    tools.py    mcp.py     sandbox.py
+
+actions.py delegates plan logic to plan.py
+and delegate logic to delegate.py.
 ```
 
 Supporting modules:
 
-- `state.py` persists tasks, context, plans, checkpoints, memories, and history.
+- `state.py` persists 13 tables: tasks, notifications, rules, run_lock, history, context, todos, memories, conversations, checkpoints, node_executions, task_artifacts, stagnation_log.
 - `desk.py` compiles durable state into the model-facing working document.
 - `governance.py`, `effect.py`, and `trust.py` gate actions before side effects happen.
 - `compaction.py` manages prompt budget pressure and restart thresholds.
@@ -41,9 +44,11 @@ Supporting modules:
 | Module | Purpose |
 | --- | --- |
 | `src/pascal/__main__.py` | CLI entrypoints, setup/config commands, one-shot run, resume, and REPL wiring. |
-| `src/pascal/actions.py` | Action handlers, declarative plan advancement, delegate lifecycle, verification, and MCP fallback dispatch. |
+| `src/pascal/actions.py` | Action handlers, verification, and MCP fallback dispatch. Plan and delegate logic extracted into `plan.py` and `delegate.py`. |
+| `src/pascal/plan.py` | Plan parsing, validation, and single-leaf execution. Extracted from `actions.py`. |
+| `src/pascal/delegate.py` | Delegate handler — spawns Claude Code / Codex CLI subprocesses (sync and async). Extracted from `actions.py`. |
 | `src/pascal/loop.py` | Main orchestration loop and tool-call execution. |
-| `src/pascal/state.py` | SQLite persistence for tasks, plans, checkpoints, context, memories, rules, and history. |
+| `src/pascal/state.py` | SQLite persistence (13 tables). Includes node_executions (parallel plan execution state), task_artifacts (shift handoff/evidence), and stagnation_log. |
 | `src/pascal/desk.py` | State-to-prompt compiler. |
 | `src/pascal/schemas.py` | Function schemas for built-in actions and connected MCP tools. |
 | `src/pascal/mcp.py` | MCP connection manager, tool discovery, and tool calls. |

{pascal_agent-1.1.0 → pascal_agent-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pascal-agent
-Version: 1.1.0
+Version: 1.3.0
 Summary: Pascal — autonomous AI employee runtime
 Project-URL: Homepage, https://gitlab.com/laum0621/pascal
 Project-URL: Repository, https://gitlab.com/laum0621/pascal
@@ -18,17 +18,16 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.12
 Requires-Dist: httpx>=0.27
-Requires-Dist: mcp
 Requires-Dist: openai>=1.0
-Requires-Dist: pillow
-Requires-Dist: pyautogui
 Provides-Extra: all
 Requires-Dist: aiogram>=3.0; extra == 'all'
 Requires-Dist: anthropic>=0.30; extra == 'all'
 Requires-Dist: mcp; extra == 'all'
 Requires-Dist: pillow; extra == 'all'
+Requires-Dist: playwright; extra == 'all'
 Requires-Dist: pyautogui; extra == 'all'
 Requires-Dist: pyperclip; extra == 'all'
+Requires-Dist: pytesseract; extra == 'all'
 Requires-Dist: pytest; extra == 'all'
 Requires-Dist: pytest-asyncio; extra == 'all'
 Requires-Dist: pywinauto>=0.6.8; extra == 'all'

{pascal_agent-1.1.0 → pascal_agent-1.3.0}/pyproject.toml

@@ -5,9 +5,12 @@ build-backend = "hatchling.build"
 [tool.hatch.build.targets.wheel]
 packages = ["src/pascal"]
 
+[tool.hatch.build.targets.sdist]
+exclude = [".audit-venv*", "dist/", "*.db", "*.db-*", "*.log", "*.jsonl", ".omc/", ".pascal_tmp/"]
+
 [project]
 name = "pascal-agent"
-version = "1.1.0"
+version = "1.3.0"
 description = "Pascal — autonomous AI employee runtime"
 readme = "README.md"
 license = {text = "MIT"}
@@ -24,7 +27,7 @@ classifiers = [
     "Programming Language :: Python :: 3.14",
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
 ]
-dependencies = ["openai>=1.0", "httpx>=0.27", "mcp", "pyautogui", "pillow"]
+dependencies = ["openai>=1.0", "httpx>=0.27"]
 
 [project.urls]
 Homepage = "https://gitlab.com/laum0621/pascal"
@@ -44,7 +47,7 @@ clipboard = ["pyperclip"]
 browser = ["playwright"]
 telegram = ["aiogram>=3.0"]
 dev = ["pytest", "pytest-asyncio"]
-all = ["pascal-agent[anthropic,desktop,uia,mcp,clipboard,telegram,dev]"]
+all = ["pascal-agent[anthropic,desktop,uia,ocr,mcp,clipboard,browser,telegram,dev]"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

pascal_agent-1.3.0/src/pascal/__init__.py

@@ -0,0 +1,17 @@
+"""Pascal -- autonomous AI employee built on a working-document loop."""
+
+__version__ = "1.3.0"
+
+# Force UTF-8 stdout/stderr on Windows (cp949 cannot encode Unicode symbols)
+import sys as _sys
+if _sys.stdout and _sys.stdout.encoding and _sys.stdout.encoding.lower() not in ("utf-8", "utf8"):
+    import io as _io
+    try:
+        _sys.stdout = _io.TextIOWrapper(
+            _sys.stdout.buffer, encoding="utf-8", errors="replace", line_buffering=True,
+        )
+        _sys.stderr = _io.TextIOWrapper(
+            _sys.stderr.buffer, encoding="utf-8", errors="replace", line_buffering=True,
+        )
+    except Exception:
+        pass

{pascal_agent-1.1.0 → pascal_agent-1.3.0}/src/pascal/__main__.py

@@ -7,18 +7,12 @@ import asyncio
 import json
 import logging
 import os
+import re
 import sys
 from pathlib import Path
 from textwrap import dedent
 
-# Force UTF-8 on Windows (fixes Korean/CJK text garbling)
-if sys.platform == "win32":
-    for stream in (sys.stdout, sys.stderr, sys.stdin):
-        if hasattr(stream, "reconfigure"):
-            try:
-                stream.reconfigure(encoding="utf-8", errors="replace")
-            except Exception:
-                pass
+# UTF-8 forcing handled in pascal/__init__.py
 
 from pascal.config import load_config
 from pascal.receipts import Ledger
@@ -70,14 +64,55 @@ _PROVIDERS = ("openai", "anthropic", "codex")
 _EFFECTS = ("E0", "E1", "E2", "E3", "E4", "E5", "unlimited")
 
 
+
+# ── Terminal styling (ANSI, no dependencies) ────────────────────
+class _S:
+    """ANSI escape sequences for terminal styling."""
+    RESET = "\033[0m"
+    BOLD = "\033[1m"
+    DIM = "\033[2m"
+    ITALIC = "\033[3m"
+    # Colors (Claude-inspired palette)
+    ORANGE = "\033[38;2;215;119;87m"       # brand / spinner
+    GREEN = "\033[38;2;78;186;101m"        # success
+    RED = "\033[38;2;255;107;128m"         # error
+    YELLOW = "\033[38;2;255;193;7m"        # warning
+    BLUE = "\033[38;2;147;165;255m"        # info / delegate
+    GRAY = "\033[38;2;153;153;153m"        # dim / metadata
+    WHITE = "\033[38;2;255;255;255m"       # primary text
+    DGRAY = "\033[38;2;80;80;80m"          # very dim
+
+    @staticmethod
+    def _check():
+        """Disable colors if not a TTY or NO_COLOR is set."""
+        if not sys.stdout.isatty() or os.environ.get("NO_COLOR"):
+            for attr in dir(_S):
+                if attr.isupper() and not attr.startswith("_"):
+                    setattr(_S, attr, "")
+        # Enable VT processing on Windows
+        if os.name == "nt":
+            try:
+                import ctypes
+                kernel32 = ctypes.windll.kernel32
+                handle = kernel32.GetStdHandle(-11)
+                mode = ctypes.c_ulong()
+                kernel32.GetConsoleMode(handle, ctypes.byref(mode))
+                kernel32.SetConsoleMode(handle, mode.value | 0x0004)  # add VT processing
+            except Exception:
+                pass
+
+_S._check()
+
+
 _SPINNER_FRAMES = ["|", "/", "-", "\\"]
-_active_model = ""  # set before loop starts
+_active_model = ""  # set in _run/_persistent_repl before loop starts
 
 # Background spinner state
 _spinner_running = False
 _spinner_thread = None
 _spinner_msg = "thinking..."
 _spinner_start_time = 0.0
+_stdout_lock = __import__("threading").Lock()
 
 
 def _start_spinner(msg: str = "thinking...") -> None:
@@ -97,11 +132,13 @@ def _start_spinner(msg: str = "thinking...") -> None:
         while _spinner_running:
             frame = _SPINNER_FRAMES[idx % len(_SPINNER_FRAMES)]
             elapsed = int(time.monotonic() - _spinner_start_time)
-            model_tag = f" ({_active_model})" if _active_model else ""
-            timer = f" {elapsed}s" if elapsed >= 1 else ""
-            print(f"\r  {frame} {_spinner_msg}{model_tag}{timer}   ", end="", flush=True)
+            model_tag = f" {_S.GRAY}({_active_model}){_S.RESET}" if _active_model else ""
+            timer = f" {_S.DIM}{elapsed}s{_S.RESET}" if elapsed >= 1 else ""
+            with _stdout_lock:
+                sys.stdout.write(f"\r  {_S.ORANGE}{frame}{_S.RESET} {_S.DIM}{_spinner_msg}{_S.RESET}{model_tag}{timer}   ")
+                sys.stdout.flush()
             idx += 1
-            time.sleep(0.15)
+            time.sleep(0.1)
 
     _spinner_thread = threading.Thread(target=_spin_loop, daemon=True)
     _spinner_thread.start()
@@ -115,18 +152,27 @@ def _stop_spinner(clear: bool = True) -> None:
         _spinner_thread.join(timeout=1)
         _spinner_thread = None
     if clear:
-        print(f"\r{' ' * 80}\r", end="", flush=True)
+        with _stdout_lock:
+            sys.stdout.write("\r" + " " * 80 + "\r")
+            sys.stdout.flush()
 
 
 # Actions hidden from user (internal bookkeeping)
 _SILENT_ACTIONS = frozenset({
-    "think", "pick_task", "add_todo", "complete_todo", "memorize",
+    "think", "pick_task", "create_task", "add_todo", "complete_todo", "memorize",
     "add_rule", "remove_rule", "set_context", "dismiss_notification",
-    "pause_task", "block_task", "create_subtask",
+    "pause_task", "block_task", "create_subtask", "stream_delta",
 })
 
 
 def _print_action(action: dict) -> None:
+    try:
+        _print_action_inner(action)
+    except Exception:
+        pass  # Never crash the loop due to display errors
+
+
+def _print_action_inner(action: dict) -> None:
     a = action.get("action", "?")
     reason = action.get("reason", "")
     result = action.get("result", {})
@@ -145,90 +191,94 @@ def _print_action(action: dict) -> None:
         tool = result.get("tool", "") if isinstance(result, dict) else ""
         label = tool or reason[:60] or "running"
         if error:
-            print(f"  x {label} -- {error[:80]}")
+            print(f"  {_S.RED}x{_S.RESET} {label} {_S.RED}— {error[:80]}{_S.RESET}")
         elif output:
             preview = output.strip().split("\n")[0][:80]
-            print(f"  > {label} -> {preview}")
+            print(f"  {_S.GREEN}>{_S.RESET} {label} {_S.GRAY}→ {preview}{_S.RESET}")
         else:
-            print(f"  > {label}")
+            print(f"  {_S.GREEN}>{_S.RESET} {label}")
 
     elif a == "editor":
         ed_action = (result.get("action", "") if isinstance(result, dict) else "") or reason[:60]
         if error:
-            print(f"  x editor {ed_action} -- {error[:80]}")
+            print(f"  {_S.RED}x{_S.RESET} editor {ed_action} {_S.RED}— {error[:80]}{_S.RESET}")
         elif output:
             preview = output.strip().split("\n")[0][:80]
-            print(f"  > editor {ed_action} -> {preview}")
+            print(f"  {_S.GREEN}>{_S.RESET} editor {ed_action} {_S.GRAY}→ {preview}{_S.RESET}")
         else:
-            print(f"  > editor {ed_action}")
+            print(f"  {_S.GREEN}>{_S.RESET} editor {ed_action}")
 
     elif a in ("computer", "uia"):
         sub = reason[:60] or (result.get("action", "") if isinstance(result, dict) else "")
         if error:
-            print(f"  x {a} {sub} -- {error[:80]}")
+            print(f"  {_S.RED}x{_S.RESET} {a} {sub} {_S.RED}— {error[:80]}{_S.RESET}")
         elif output:
             preview = output.strip().split("\n")[0][:80]
-            print(f"  > {a} {sub} -> {preview}")
+            print(f"  {_S.YELLOW}>{_S.RESET} {a} {sub} {_S.GRAY}→ {preview}{_S.RESET}")
         else:
-            print(f"  > {a} {sub}")
+            print(f"  {_S.YELLOW}>{_S.RESET} {a} {sub}")
 
     elif a == "code":
         if error:
-            print(f"  x code -- {error[:80]}")
+            print(f"  {_S.RED}x{_S.RESET} code {_S.RED}— {error[:80]}{_S.RESET}")
         elif output:
             preview = output.strip().split("\n")[0][:80]
-            print(f"  > code -> {preview}")
+            print(f"  {_S.GREEN}>{_S.RESET} code {_S.GRAY}→ {preview}{_S.RESET}")
         else:
-            print("  > code")
+            print(f"  {_S.GREEN}>{_S.RESET} code")
+
+    elif a == "skill":
+        name = result.get("skill_name", reason[:40]) if isinstance(result, dict) else reason[:40]
+        if error:
+            print(f"  {_S.RED}x{_S.RESET} skill {_S.RED}— {error[:80]}{_S.RESET}")
+        else:
+            print(f"  {_S.BLUE}#{_S.RESET} skill {_S.BOLD}{name}{_S.RESET} activated")
 
     elif a == "channel_reply":
         if error:
-            print(f"  x channel_reply -- {error[:80]}")
+            print(f"  {_S.RED}x{_S.RESET} channel_reply {_S.RED}— {error[:80]}{_S.RESET}")
         else:
             text = result.get("reply_text", "") or result.get("text", "") if isinstance(result, dict) else ""
             if text:
                 prev = getattr(_print_action, "_dedup_text", "")
                 if text.strip() != prev:
                     _print_action._dedup_text = text.strip()  # type: ignore[attr-defined]
-                    print(f"\n  {text}")
+                    print(f"  {_S.WHITE}{text}{_S.RESET}")
 
     elif a == "delegate":
         tool = result.get("tool", "agent") if isinstance(result, dict) else "agent"
-        print(f"  -> delegating to {tool}...")
+        print(f"  {_S.BLUE}-->{_S.RESET} delegating to {_S.BOLD}{tool}{_S.RESET}...")
 
     elif a == "plan":
         count = result.get("executed", 0) if isinstance(result, dict) else 0
-        print(f"  > planning ({count} steps)")
+        print(f"  {_S.BLUE}>{_S.RESET} planning {_S.GRAY}({count} steps){_S.RESET}")
 
     elif a == "complete_task":
         summary = result.get("summary", reason) if isinstance(result, dict) else reason
-        print(f"\n  Done: {summary[:120]}")
+        print(f"  {_S.GREEN}*{_S.RESET} {_S.GREEN}{_S.BOLD}Done:{_S.RESET} {summary[:120]}")
 
     elif a == "fail_task":
-        print(f"\n  Failed: {reason[:120]}")
+        print(f"  {_S.RED}x{_S.RESET} {_S.RED}{_S.BOLD}Failed:{_S.RESET} {reason[:120]}")
 
     elif a == "escalate":
         question = action.get("question", reason) if isinstance(action, dict) else reason
-        print(f"\n  ? {question[:120]}")
+        print(f"  {_S.YELLOW}?{_S.RESET} {_S.YELLOW}{question[:120]}{_S.RESET}")
 
     elif a == "wait":
         pass  # silent
 
     elif a == "text_response":
-        # Legacy: LLM replied with plain text (no tool calls)
         text = result.get("text", reason) if isinstance(result, dict) else reason
         if text:
-            import re as _re
-            text = _re.sub(r'^\s*\{[^}]*"thought"\s*:[^}]*\}\s*', '', text).strip()
+            text = re.sub(r'^\s*\{[^}]*"thought"\s*:[^}]*\}\s*', '', text).strip()
             if text:
                 prev = getattr(_print_action, "_dedup_text", "")
                 if text.strip() != prev:
                     _print_action._dedup_text = text.strip()  # type: ignore[attr-defined]
-                    print(f"\n  {text}\n")
+                    print(f"  {_S.WHITE}{text}{_S.RESET}")
 
     else:
-        # Fallback for unknown actions
-        print(f"  {a}: {reason[:60]}")
+        print(f"  {_S.GRAY}{a}: {reason[:60]}{_S.RESET}")
 
 
 def _try_connect_embedding(store) -> None:
@@ -272,10 +322,12 @@ async def _run_loop_until_idle(store, llm, **kwargs) -> int:
     return total
 
 
-async def _run(args, config) -> None:
-    store = PascalStore(config.db_path)
-    store.release_lock(force=True)
-    _try_connect_embedding(store)
+async def _run(args, config) -> None:
+    global _active_model
+    _active_model = config.model
+    store = PascalStore(config.db_path)
+    store.release_lock(force=True)
+    _try_connect_embedding(store)
 
     # Seed initial task if provided
     if args.task:
@@ -332,10 +384,10 @@ async def _run(args, config) -> None:
     store.close()
 
 
-async def _resume_run(args, config) -> None:
-    store = PascalStore(config.db_path)
-    _try_connect_embedding(store)
-    task_id = args.resume
+async def _resume_run(args, config) -> None:
+    store = PascalStore(config.db_path)
+    _try_connect_embedding(store)
+    task_id = args.resume
     task = store.connection.execute("SELECT * FROM tasks WHERE id = ?", (task_id,)).fetchone()
     if task is None:
         print(f"Task {task_id} not found", file=sys.stderr)
@@ -389,10 +441,6 @@ def _notify(args, config) -> None:
 
 def _status(config) -> None:
     """Print Pascal's current desk state."""
-    import sys
-    if sys.stdout.encoding and sys.stdout.encoding.lower() not in ("utf-8", "utf8"):
-        if hasattr(sys.stdout, "reconfigure"):
-            sys.stdout.reconfigure(encoding="utf-8", errors="replace")
     from pascal.desk import Desk
     store = PascalStore(config.db_path)
     desk = Desk(store)
@@ -518,19 +566,25 @@ def _init_pascal_home() -> None:
         print(f"Pascal initialization failed: {exc}", file=sys.stderr)
         sys.exit(1)
 
-    print("Pascal initialization complete.")
+    # Logo on first init
+    for line in _LOGO.strip().splitlines():
+        print(f"  {_S.ORANGE}{line}{_S.RESET}")
+    print()
+    print(f"  {_S.GREEN}*{_S.RESET} {_S.BOLD}Initialization complete{_S.RESET}")
+    print()
     if created:
-        print("Created:")
+        print(f"  {_S.DIM}Created:{_S.RESET}")
         for path in created:
-            print(f"  - {path}")
+            print(f"    {_S.GREEN}+{_S.RESET} {path}")
     if existing:
-        print("Already existed:")
+        print(f"  {_S.DIM}Already existed:{_S.RESET}")
         for path in existing:
-            print(f"  - {path}")
+            print(f"    {_S.GRAY}·{_S.RESET} {_S.GRAY}{path}{_S.RESET}")
     print()
-    print("Next steps:")
-    print(f"  - Edit {config_path} to choose your model and provider.")
-    print(f"  - Add custom skills to {skills_dir}.")
+    print(f"  {_S.BOLD}Next steps:{_S.RESET}")
+    print(f"    {_S.BLUE}1.{_S.RESET} Edit {_S.DIM}{config_path}{_S.RESET} to choose your model and provider")
+    print(f"    {_S.BLUE}2.{_S.RESET} Set API key: {_S.DIM}OPENAI_API_KEY{_S.RESET} or {_S.DIM}ANTHROPIC_API_KEY{_S.RESET}")
+    print(f"    {_S.BLUE}3.{_S.RESET} Run {_S.ORANGE}pascal{_S.RESET} to start")
 
 
 def _read_toml_config() -> tuple[Path, dict]:
@@ -936,7 +990,7 @@ def _ensure_ready() -> bool:
 
     # First run: auto-init
     if not pascal_home.exists():
-        print("First run detected. Setting up Pascal...\n")
+        print(f"\n  {_S.ORANGE}{_S.BOLD}First run detected.{_S.RESET} Setting up Pascal...\n")
         _init_pascal_home()
         print()
 
@@ -948,7 +1002,7 @@ def _ensure_ready() -> bool:
             section["provider"] = provider
             section["model"] = model
             _write_toml_config(config_path, section)
-            print(f"Auto-detected: provider={provider}, model={model}\n")
+            print(f"  {_S.GREEN}*{_S.RESET} Auto-detected: {_S.BOLD}{provider}{_S.RESET} / {_S.DIM}{model}{_S.RESET}\n")
         else:
             # Interactive provider setup
             result = _quick_auth_setup()
@@ -957,15 +1011,28 @@ def _ensure_ready() -> bool:
     return True
 
 
+_LOGO = r"""
+ _____                    _
+|  __ \                  | |
+| |__) |_ _ ___  ___ __ _| |
+|  ___/ _` / __|/ __/ _` | |
+| |  | (_| \__ \ (_| (_| | |
+|_|   \__,_|___/\___\__,_|_|
+"""
+
+
 def _print_banner() -> None:
     """Print startup banner with current config."""
     from pascal import __version__
     config = load_config()
+    # Logo
+    for line in _LOGO.strip().splitlines():
+        print(f"  {_S.ORANGE}{line}{_S.RESET}")
     print()
-    print(f"  Pascal v{__version__}")
-    print(f"  {config.model} via {config.provider} | max effect: {config.max_effect}")
-    print()
-    print("  Type a task, 'help' for commands, Ctrl+C to exit.")
+    # Info bar
+    print(f"  {_S.BOLD}v{__version__}{_S.RESET}  {_S.GRAY}│{_S.RESET}  {_S.DIM}{config.model}{_S.RESET}  {_S.GRAY}│{_S.RESET}  {_S.DIM}{config.provider}{_S.RESET}  {_S.GRAY}│{_S.RESET}  {_S.DIM}effect: {config.max_effect}{_S.RESET}")
+    print(f"  {_S.DGRAY}{'─' * 50}{_S.RESET}")
+    print(f"  {_S.DIM}Type a task, 'help' for commands, Ctrl+C to exit.{_S.RESET}")
     print()
 
 
@@ -984,11 +1051,11 @@ def _interactive() -> None:
     pending = store.get_pending_tasks()
     notifs = store.get_pending_notifications()
     if active:
-        print(f"  Active: {active['goal'][:70]}")
+        print(f"  {_S.GREEN}>{_S.RESET} Active: {active['goal'][:70]}")
     if pending:
-        print(f"  Queued: {len(pending)} task(s)")
+        print(f"  {_S.BLUE}>{_S.RESET} Queued: {len(pending)} task(s)")
     if notifs:
-        print(f"  Notifications: {len(notifs)}")
+        print(f"  {_S.YELLOW}>{_S.RESET} Notifications: {len(notifs)}")
     if active or pending or notifs:
         print()
     store.close()
@@ -996,11 +1063,13 @@ def _interactive() -> None:
     try:
         asyncio.run(_persistent_repl(config))
     except KeyboardInterrupt:
-        print("\nBye.")
+        print(f"\n  {_S.DIM}Bye.{_S.RESET}")
 
 
 async def _persistent_repl(config) -> None:
     """Run a persistent-context REPL: one LoopRunner, user input as wake events."""
+    global _active_model
+    _active_model = config.model
     from pascal.config import create_llm
     from pascal.mcp import MCPManager
 
@@ -1028,16 +1097,16 @@ async def _persistent_repl(config) -> None:
         from pascal.loop import LoopRunner
         while True:
             try:
-                runner = LoopRunner(
-                    store, llm, verifier_llm=llm, ledger=ledger,
-                    mcp_manager=mcp_manager if mcp_manager.connected_servers else None,
-                    max_effect=config.max_effect,
-                    max_iterations=0,
-                    max_tool_rounds=_resolve_max_tool_rounds(config, None, daemon_mode=False),
-                    on_action=_print_action,
-                    wake_event=wake_event,
-                    mode="repl",
-                )
+                runner = LoopRunner(
+                    store, llm, verifier_llm=llm, ledger=ledger,
+                    mcp_manager=mcp_manager if mcp_manager.connected_servers else None,
+                    max_effect=config.max_effect,
+                    max_iterations=0,
+                    max_tool_rounds=_resolve_max_tool_rounds(config, None, daemon_mode=False),
+                    on_action=_print_action,
+                    wake_event=wake_event,
+                    mode="repl",
+                )
                 _runner_ref.clear()
                 _runner_ref.append(runner)
                 await runner.run()
@@ -1052,9 +1121,9 @@ async def _persistent_repl(config) -> None:
         loop = asyncio.get_event_loop()
         while True:
             try:
-                task = await loop.run_in_executor(None, lambda: input("> ").strip())
+                task = await loop.run_in_executor(None, lambda: input(f"\n{_S.ORANGE}>{_S.RESET} ").strip())
             except (KeyboardInterrupt, EOFError):
-                print("\nBye.")
+                print(f"\n  {_S.DIM}Bye.{_S.RESET}")
                 return
 
             if not task:
@@ -1079,7 +1148,6 @@ async def _persistent_repl(config) -> None:
                 print()
                 continue
 
-            print()
             _start_spinner("thinking...")
             # Inject user input directly as USER message (Claude Code pattern)
             if _runner_ref:
@@ -1096,6 +1164,7 @@ async def _persistent_repl(config) -> None:
         except asyncio.CancelledError:
             pass
         _stop_spinner()
+        store.release_lock(force=True)
         try:
             await mcp_manager.disconnect_all()
         except Exception: