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

{pascal_agent-1.2.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.2.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.2.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.2.0 → pascal_agent-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pascal-agent
-Version: 1.2.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.2.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.2.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.2.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,6 +64,7 @@ _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."""
@@ -90,23 +85,34 @@ class _S:
     @staticmethod
     def _check():
         """Disable colors if not a TTY or NO_COLOR is set."""
-        import sys, os
         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
+_SPINNER_FRAMES = ["|", "/", "-", "\\"]
+_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:
@@ -128,7 +134,9 @@ def _start_spinner(msg: str = "thinking...") -> None:
             elapsed = int(time.monotonic() - _spinner_start_time)
             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 ""
-            print(f"\r  {_S.ORANGE}{frame}{_S.RESET} {_S.DIM}{_spinner_msg}{_S.RESET}{model_tag}{timer}   ", end="", flush=True)
+            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.1)
 
@@ -144,18 +152,27 @@ def _stop_spinner(clear: bool = True) -> None:
         _spinner_thread.join(timeout=1)
         _spinner_thread = None
     if clear:
-        print(f"\r{' ' * 100}\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", {})
@@ -174,78 +191,78 @@ 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"  {_S.RED}✗{_S.RESET} {label} {_S.RED}— {error[:80]}{_S.RESET}")
+            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"  {_S.GREEN}▸{_S.RESET} {label} {_S.GRAY}→ {preview}{_S.RESET}")
+            print(f"  {_S.GREEN}>{_S.RESET} {label} {_S.GRAY}→ {preview}{_S.RESET}")
         else:
-            print(f"  {_S.GREEN}▸{_S.RESET} {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"  {_S.RED}✗{_S.RESET} editor {ed_action} {_S.RED}— {error[:80]}{_S.RESET}")
+            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"  {_S.GREEN}▸{_S.RESET} editor {ed_action} {_S.GRAY}→ {preview}{_S.RESET}")
+            print(f"  {_S.GREEN}>{_S.RESET} editor {ed_action} {_S.GRAY}→ {preview}{_S.RESET}")
         else:
-            print(f"  {_S.GREEN}▸{_S.RESET} 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"  {_S.RED}✗{_S.RESET} {a} {sub} {_S.RED}— {error[:80]}{_S.RESET}")
+            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"  {_S.YELLOW}▸{_S.RESET} {a} {sub} {_S.GRAY}→ {preview}{_S.RESET}")
+            print(f"  {_S.YELLOW}>{_S.RESET} {a} {sub} {_S.GRAY}→ {preview}{_S.RESET}")
         else:
-            print(f"  {_S.YELLOW}▸{_S.RESET} {a} {sub}")
+            print(f"  {_S.YELLOW}>{_S.RESET} {a} {sub}")
 
     elif a == "code":
         if error:
-            print(f"  {_S.RED}✗{_S.RESET} code {_S.RED}— {error[:80]}{_S.RESET}")
+            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"  {_S.GREEN}▸{_S.RESET} code {_S.GRAY}→ {preview}{_S.RESET}")
+            print(f"  {_S.GREEN}>{_S.RESET} code {_S.GRAY}→ {preview}{_S.RESET}")
         else:
-            print(f"  {_S.GREEN}▸{_S.RESET} 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}✗{_S.RESET} skill {_S.RED}— {error[:80]}{_S.RESET}")
+            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")
+            print(f"  {_S.BLUE}#{_S.RESET} skill {_S.BOLD}{name}{_S.RESET} activated")
 
     elif a == "channel_reply":
         if error:
-            print(f"  {_S.RED}✗{_S.RESET} channel_reply {_S.RED}— {error[:80]}{_S.RESET}")
+            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  {_S.WHITE}{text}{_S.RESET}")
+                    print(f"  {_S.WHITE}{text}{_S.RESET}")
 
     elif a == "delegate":
         tool = result.get("tool", "agent") if isinstance(result, dict) else "agent"
-        print(f"  {_S.BLUE}⟶{_S.RESET} delegating to {_S.BOLD}{tool}{_S.RESET}...")
+        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"  {_S.BLUE}▸{_S.RESET} planning {_S.GRAY}({count} steps){_S.RESET}")
+        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  {_S.GREEN}✓{_S.RESET} {_S.GREEN}{_S.BOLD}Done:{_S.RESET} {summary[:120]}")
+        print(f"  {_S.GREEN}*{_S.RESET} {_S.GREEN}{_S.BOLD}Done:{_S.RESET} {summary[:120]}")
 
     elif a == "fail_task":
-        print(f"\n  {_S.RED}✗{_S.RESET} {_S.RED}{_S.BOLD}Failed:{_S.RESET} {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  {_S.YELLOW}?{_S.RESET} {_S.YELLOW}{question[:120]}{_S.RESET}")
+        print(f"  {_S.YELLOW}?{_S.RESET} {_S.YELLOW}{question[:120]}{_S.RESET}")
 
     elif a == "wait":
         pass  # silent
@@ -253,13 +270,12 @@ def _print_action(action: dict) -> None:
     elif a == "text_response":
         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  {_S.WHITE}{text}{_S.RESET}\n")
+                    print(f"  {_S.WHITE}{text}{_S.RESET}")
 
     else:
         print(f"  {_S.GRAY}{a}: {reason[:60]}{_S.RESET}")
@@ -307,6 +323,8 @@ async def _run_loop_until_idle(store, llm, **kwargs) -> int:
 
 
 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)
@@ -423,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)
@@ -556,7 +570,7 @@ def _init_pascal_home() -> None:
     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(f"  {_S.GREEN}*{_S.RESET} {_S.BOLD}Initialization complete{_S.RESET}")
     print()
     if created:
         print(f"  {_S.DIM}Created:{_S.RESET}")
@@ -988,7 +1002,7 @@ def _ensure_ready() -> bool:
             section["provider"] = provider
             section["model"] = model
             _write_toml_config(config_path, section)
-            print(f"  {_S.GREEN}✓{_S.RESET} Auto-detected: {_S.BOLD}{provider}{_S.RESET} / {_S.DIM}{model}{_S.RESET}\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()
@@ -1037,11 +1051,11 @@ def _interactive() -> None:
     pending = store.get_pending_tasks()
     notifs = store.get_pending_notifications()
     if active:
-        print(f"  {_S.GREEN}▸{_S.RESET} Active: {active['goal'][:70]}")
+        print(f"  {_S.GREEN}>{_S.RESET} Active: {active['goal'][:70]}")
     if pending:
-        print(f"  {_S.BLUE}▸{_S.RESET} Queued: {len(pending)} task(s)")
+        print(f"  {_S.BLUE}>{_S.RESET} Queued: {len(pending)} task(s)")
     if notifs:
-        print(f"  {_S.YELLOW}▸{_S.RESET} Notifications: {len(notifs)}")
+        print(f"  {_S.YELLOW}>{_S.RESET} Notifications: {len(notifs)}")
     if active or pending or notifs:
         print()
     store.close()
@@ -1054,6 +1068,8 @@ def _interactive() -> None:
 
 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
 
@@ -1105,7 +1121,7 @@ async def _persistent_repl(config) -> None:
         loop = asyncio.get_event_loop()
         while True:
             try:
-                task = await loop.run_in_executor(None, lambda: input(f"{_S.ORANGE}❯{_S.RESET} ").strip())
+                task = await loop.run_in_executor(None, lambda: input(f"\n{_S.ORANGE}>{_S.RESET} ").strip())
             except (KeyboardInterrupt, EOFError):
                 print(f"\n  {_S.DIM}Bye.{_S.RESET}")
                 return
@@ -1132,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:
@@ -1149,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: