micro-cc 0.2.32__tar.gz → 0.2.35__tar.gz

{micro_cc-0.2.32 → micro_cc-0.2.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: micro-cc
-Version: 0.2.32
+Version: 0.2.35
 Summary: Harness that gives frontier models full system access — shell, filesystem, browser, MCP — running directly on the metal.
 Author: George Salapa
 License-Expression: MIT
@@ -44,18 +44,19 @@ Requires-Dist: youtube-transcript-api>=1.2
 # micro · cc — cognitive compute
 
 ```
-  ███╗   ███╗██╗ ██████╗██████╗  ██████╗
-  ████╗ ████║██║██╔════╝██╔══██╗██╔═══██╗
-  ██╔████╔██║██║██║     ██████╔╝██║   ██║
-  ██║╚██╔╝██║██║██║     ██╔══██╗██║   ██║
-  ██║ ╚═╝ ██║██║╚██████╗██║  ██║╚██████╔╝
-  ╚═╝     ╚═╝╚═╝ ╚═════╝╚═╝  ╚═╝ ╚═════╝
-       c o g n i t i v e  c o m p u t e
+                   88
+                   ""
+
+88,dPYba,,adPYba,  88  ,adPPYba, 8b,dPPYba,  ,adPPYba,     ,adPPYba,  ,adPPYba,
+88P'   "88"    "8a 88 a8"     "" 88P'   "Y8 a8"     "8a   a8"     "" a8"     ""
+88      88      88 88 8b         88         8b       d8 · 8b         8b
+88      88      88 88 "8a,   ,aa 88         "8a,   ,a8"   "8a,   ,aa "8a,   ,aa
+88      88      88 88  `"Ybbd8"' 88          `"YbbdP"'     `"Ybbd8"'  `"Ybbd8"'
 ```
 
 > Knowledge work is, by extension, a coding problem.
 
-Frontier models with full system access — shell, filesystem, browser, MCP — running directly on the metal. Verbose, thorough planning paired with unrestricted file operations means micro·cc can take on complex multi-step work autonomously. Point it at any project directory and go.
+Frontier models with full system access — shell, filesystem, browser, MCP. Verbose, thorough planning paired with unrestricted file operations lets micro·cc take on complex multi-step work autonomously. Point it at any project directory and go.
 
 ## Install
 
@@ -65,8 +66,6 @@ pip install micro-cc
 
 On first launch, micro·cc creates `~/.micro-cc/` with an example `.env` — add your API keys there and restart. That directory is also where conversation history and project state live.
 
-Recommended terminal: **iTerm2** (macOS).
-
 ## Platform
 
 Built and tested on macOS. Works on Linux. Windows should work via `pip install` + any modern terminal — iTerm2 is macOS-only but micro·cc doesn't depend on it, it just looks best there.

{micro_cc-0.2.32 → micro_cc-0.2.35}/README.md

@@ -1,18 +1,19 @@
 # micro · cc — cognitive compute
 
 ```
-  ███╗   ███╗██╗ ██████╗██████╗  ██████╗
-  ████╗ ████║██║██╔════╝██╔══██╗██╔═══██╗
-  ██╔████╔██║██║██║     ██████╔╝██║   ██║
-  ██║╚██╔╝██║██║██║     ██╔══██╗██║   ██║
-  ██║ ╚═╝ ██║██║╚██████╗██║  ██║╚██████╔╝
-  ╚═╝     ╚═╝╚═╝ ╚═════╝╚═╝  ╚═╝ ╚═════╝
-       c o g n i t i v e  c o m p u t e
+                   88
+                   ""
+
+88,dPYba,,adPYba,  88  ,adPPYba, 8b,dPPYba,  ,adPPYba,     ,adPPYba,  ,adPPYba,
+88P'   "88"    "8a 88 a8"     "" 88P'   "Y8 a8"     "8a   a8"     "" a8"     ""
+88      88      88 88 8b         88         8b       d8 · 8b         8b
+88      88      88 88 "8a,   ,aa 88         "8a,   ,a8"   "8a,   ,aa "8a,   ,aa
+88      88      88 88  `"Ybbd8"' 88          `"YbbdP"'     `"Ybbd8"'  `"Ybbd8"'
 ```
 
 > Knowledge work is, by extension, a coding problem.
 
-Frontier models with full system access — shell, filesystem, browser, MCP — running directly on the metal. Verbose, thorough planning paired with unrestricted file operations means micro·cc can take on complex multi-step work autonomously. Point it at any project directory and go.
+Frontier models with full system access — shell, filesystem, browser, MCP. Verbose, thorough planning paired with unrestricted file operations lets micro·cc take on complex multi-step work autonomously. Point it at any project directory and go.
 
 ## Install
 
@@ -22,8 +23,6 @@ pip install micro-cc
 
 On first launch, micro·cc creates `~/.micro-cc/` with an example `.env` — add your API keys there and restart. That directory is also where conversation history and project state live.
 
-Recommended terminal: **iTerm2** (macOS).
-
 ## Platform
 
 Built and tested on macOS. Works on Linux. Windows should work via `pip install` + any modern terminal — iTerm2 is macOS-only but micro·cc doesn't depend on it, it just looks best there.

{micro_cc-0.2.32 → micro_cc-0.2.35}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "micro-cc"
-version = "0.2.32"
+version = "0.2.35"
 description = "Harness that gives frontier models full system access — shell, filesystem, browser, MCP — running directly on the metal."
 readme = "README.md"
 requires-python = ">=3.12"

{micro_cc-0.2.32 → micro_cc-0.2.35}/src/micro_cc/models/anthropic.py

@@ -7,6 +7,9 @@ import json
 
 
 import os
+
+from micro_cc.models.registry import resolve, supports_thinking, wants_summarized_display
+
 load_dotenv(os.path.expanduser("~/.micro-cc/.env"))
 load_dotenv()
 
@@ -82,7 +85,7 @@ async def _wrap_stream(raw_stream):
 
 async def a_model_call(
     input: Union[List[Dict[str, Any]], str],
-    model="claude-4.6",
+    model="sonnet-4.6",
     encoded_image: Optional[Union[str, List[str]]] = None,
     tools: Optional[List[Dict[str, Any]]] = None,
     mcp_servers: list = None,
@@ -96,18 +99,8 @@ async def a_model_call(
     client = AsyncAnthropic(timeout=client_timeout)
     base_sleep = 2
 
-    MODEL_MAP = {
-        "sonnet-5": "claude-sonnet-5",
-        "opus-4.8": "claude-opus-4-8",
-        "opus-4.7": "claude-opus-4-7",
-        "opus-4.6": "claude-opus-4-6",
-        "sonnet-4.6": "claude-sonnet-4-6",
-        "haiku-4.5": "claude-haiku-4-5-20251001",
-        # legacy aliases
-        "claude-4.6": "claude-sonnet-4-6",
-        "claude-4.5-haiku": "claude-haiku-4-5-20251001",
-    }
-    model = MODEL_MAP.get(model, "claude-sonnet-4-6")
+    alias = model
+    model = resolve(alias, "anthropic")
 
     system_prompts = []
     messages = []
@@ -231,9 +224,9 @@ async def a_model_call(
 
     api_parameters["max_tokens"] = max_tokens
 
-    if thinking and model != "claude-haiku-4-5-20251001":
+    if thinking and supports_thinking(alias):
         api_parameters["thinking"] = {"type": "adaptive"}
-        if model == "claude-opus-4-7" or model == "claude-opus-4-8" or model == "claude-sonnet-5":
+        if wants_summarized_display(alias):
             api_parameters["thinking"]["display"] = "summarized"
         api_parameters["output_config"] = {"effort": "high"}
 

{micro_cc-0.2.32 → micro_cc-0.2.35}/src/micro_cc/models/litellm.py

@@ -17,6 +17,8 @@ import asyncio
 import json
 import os
 
+from micro_cc.models.registry import resolve, supports_thinking, wants_summarized_display
+
 load_dotenv(os.path.expanduser("~/.micro-cc/.env"))
 load_dotenv()
 
@@ -295,7 +297,7 @@ async def _wrap_stream(openai_stream):
 
 async def l_model_call(
     input: Union[List[Dict[str, Any]], str],
-    model="bedrock.anthropic.claude-sonnet-4-6",
+    model="sonnet-4.6",
     encoded_image: Optional[Union[str, List[str]]] = None,
     tools: Optional[List[Dict[str, Any]]] = None,
     mcp_openai_tools: list = None,
@@ -315,18 +317,8 @@ async def l_model_call(
     )
     base_sleep = 2
 
-    MODEL_MAP = {
-        "sonnet-5": "bedrock.anthropic.claude-sonnet-5",
-        "opus-4.8": "bedrock.anthropic.claude-opus-4-8",
-        "opus-4.7": "bedrock.anthropic.claude-opus-4-7",
-        "opus-4.6": "bedrock.anthropic.claude-opus-4-6",
-        "sonnet-4.6": "bedrock.anthropic.claude-sonnet-4-6",
-        "haiku-4.5": "bedrock.anthropic.claude-haiku-4-5",
-        # legacy aliases
-        "claude-4.6": "bedrock.anthropic.claude-sonnet-4-6",
-        "claude-4.5-haiku": "bedrock.anthropic.claude-haiku-4-5",
-    }
-    model = MODEL_MAP.get(model, "bedrock.anthropic.claude-sonnet-4-6")
+    alias = model
+    model = resolve(alias, "litellm")
 
     # ---- Build messages ----
     messages = []
@@ -398,16 +390,12 @@ async def l_model_call(
     if stream:
         api_params["stream_options"] = {"include_usage": True}
 
-    if thinking and model != "bedrock.anthropic.claude-haiku-4-5":
+    if thinking and supports_thinking(alias):
         api_params["extra_body"] = {
             "thinking": {"type": "adaptive"},
             "output_config": {"effort": "high"},
         }
-        if (
-            model == "bedrock.anthropic.claude-opus-4-7"
-            or model == "bedrock.anthropic.claude-opus-4-8"
-            or model == "bedrock.anthropic.claude-sonnet-5"
-        ):
+        if wants_summarized_display(alias):
             api_params["extra_body"]["thinking"]["display"] = "summarized"
 
     if tools:

micro_cc-0.2.35/src/micro_cc/models/registry.py

@@ -0,0 +1,67 @@
+"""Single source of truth for model aliases.
+
+Every backend (anthropic.py = direct API, litellm.py = proxy) used to keep
+its own MODEL_MAP: alias -> backend-specific id, plus its own copy of the
+"does this model support thinking / summarized display" conditionals. The
+two drifted — e.g. msg_store_.py called litellm.py with a raw bedrock id
+that wasn't a key in its MODEL_MAP, so it silently fell back to Sonnet
+instead of Haiku. Add a model here once and every caller picks it up.
+
+GPT-5.6 entries have no "anthropic" key — they only exist on the LiteLLM
+proxy (Azure/OpenAI backend), there's no direct-Anthropic-API equivalent.
+"""
+
+MODELS = {
+    "sonnet-5":   {"anthropic": "claude-sonnet-5",           "litellm": "bedrock.anthropic.claude-sonnet-5",  "thinking": True,  "summarized_display": True},
+    "opus-4.8":   {"anthropic": "claude-opus-4-8",           "litellm": "bedrock.anthropic.claude-opus-4-8",  "thinking": True,  "summarized_display": True},
+    "opus-4.7":   {"anthropic": "claude-opus-4-7",           "litellm": "bedrock.anthropic.claude-opus-4-7",  "thinking": True,  "summarized_display": True},
+    "opus-4.6":   {"anthropic": "claude-opus-4-6",           "litellm": "bedrock.anthropic.claude-opus-4-6",  "thinking": True,  "summarized_display": False},
+    "sonnet-4.6": {"anthropic": "claude-sonnet-4-6",         "litellm": "bedrock.anthropic.claude-sonnet-4-6", "thinking": True,  "summarized_display": False},
+    "haiku-4.5":  {"anthropic": "claude-haiku-4-5-20251001", "litellm": "bedrock.anthropic.claude-haiku-4-5", "thinking": False, "summarized_display": False},
+    "gpt-5.6-terra": {"litellm": "openai.gpt-5.6-terra", "thinking": False, "summarized_display": False},
+    "gpt-5.6-luna":  {"litellm": "openai.gpt-5.6-luna",  "thinking": False, "summarized_display": False},
+    "gpt-5.6-sol":   {"litellm": "openai.gpt-5.6-sol",   "thinking": False, "summarized_display": False},
+}
+
+# Old alias spellings some call sites still use — resolve to a MODELS key.
+LEGACY_ALIASES = {
+    "claude-4.6": "sonnet-4.6",
+    "claude-4.5-haiku": "haiku-4.5",
+}
+
+DEFAULT_MODEL = "sonnet-4.6"
+
+# Aliases shown in the /model picker UI, in display order.
+MODEL_OPTIONS = [
+    "sonnet-5", "opus-4.8", "opus-4.7", "opus-4.6", "sonnet-4.6", "haiku-4.5",
+    "gpt-5.6-terra", "gpt-5.6-luna", "gpt-5.6-sol",
+]
+
+
+def resolve(alias: str, backend: str) -> str:
+    """Alias -> backend-specific model id ('anthropic' or 'litellm').
+
+    Unknown aliases pass through unchanged rather than silently substituting
+    the default model — a typo'd or not-yet-registered name should surface
+    as an API error, not silently run (and bill) a different model. Aliases
+    with no entry for the requested backend (e.g. a gpt-5.6-* model asked
+    for on 'anthropic') also pass through unchanged, so the direct Anthropic
+    API call fails loudly instead of silently downgrading to Sonnet.
+    """
+    canonical = LEGACY_ALIASES.get(alias, alias)
+    entry = MODELS.get(canonical)
+    if entry is None:
+        return alias
+    return entry.get(backend, alias)
+
+
+def supports_thinking(alias: str) -> bool:
+    canonical = LEGACY_ALIASES.get(alias, alias)
+    entry = MODELS.get(canonical)
+    return entry["thinking"] if entry else True
+
+
+def wants_summarized_display(alias: str) -> bool:
+    canonical = LEGACY_ALIASES.get(alias, alias)
+    entry = MODELS.get(canonical)
+    return entry["summarized_display"] if entry else False

{micro_cc-0.2.32 → micro_cc-0.2.35}/src/micro_cc/screens/window_overlay_.py

@@ -5,16 +5,17 @@ from rich.console import Group
 from micro_cc.screens.md_render_ import render_md
 
 BANNER = """\
-[bold white]███╗   ███╗ ██████╗ ██████╗ ███████╗██╗[/]
-[bold white]████╗ ████║██╔═══██╗██╔══██╗██╔════╝██║[/]
-[bold white]██╔████╔██║██║   ██║██║  ██║█████╗  ██║[/]
-[dim]██║╚██╔╝██║██║   ██║██║  ██║██╔══╝  ██║[/]
-[dim]██║ ╚═╝ ██║╚██████╔╝██████╔╝███████╗███████╗[/]
-[dim]╚═╝     ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝╚══════╝[/]
-[dim]───────[/] [bold]on the metal[/] [dim]─────────────────────[/]
-[dim italic]Knowledge work is by extension a coding problem.[/]
-
-[white]enter[/] [dim]submit[/] [dim]·[/] [white]esc[/] [dim]interrupt[/] [dim]·[/] [white]/[/] [dim]commands[/]
+                   [#4a8a68]88[/]
+                   [grey42]""[/]
+
+[#4a8a68]88[/][grey42],[/][#4a8a68]dPYba[/][grey42],,[/][#4a8a68]adPYba[/][grey42],[/]  [#4a8a68]88[/]  [grey42],[/][#4a8a68]adPPYba[/][grey42],[/] [#4a8a68]8b[/][grey42],[/][#4a8a68]dPPYba[/][grey42],[/]  [grey42],[/][#4a8a68]adPPYba[/][grey42],[/]     [grey42],[/][#4a8a68]adPPYba[/][grey42],[/]  [grey42],[/][#4a8a68]adPPYba[/][grey42],[/]
+[#4a8a68]88P[/][grey42]'[/]   [grey42]"[/][#4a8a68]88[/][grey42]"[/]    [grey42]"[/][#4a8a68]8a[/] [#4a8a68]88[/] [#4a8a68]a8[/][grey42]"[/]     [grey42]""[/] [#4a8a68]88P[/][grey42]'[/]   [grey42]"[/][#4a8a68]Y8[/] [#4a8a68]a8[/][grey42]"[/]     [grey42]"[/][#4a8a68]8a[/]   [#4a8a68]a8[/][grey42]"[/]     [grey42]""[/] [#4a8a68]a8[/][grey42]"[/]     [grey42]""[/]
+[#4a8a68]88[/]      [#4a8a68]88[/]      [#4a8a68]88[/] [#4a8a68]88[/] [#4a8a68]8b[/]         [#4a8a68]88[/]         [#4a8a68]8b[/]       [#4a8a68]d8[/] [bold #8fd9b6]·[/] [#4a8a68]8b[/]         [#4a8a68]8b[/]
+[#4a8a68]88[/]      [#4a8a68]88[/]      [#4a8a68]88[/] [#4a8a68]88[/] [grey42]"[/][#4a8a68]8a[/][grey42],[/]   [grey42],[/][#4a8a68]aa[/] [#4a8a68]88[/]         [grey42]"[/][#4a8a68]8a[/][grey42],[/]   [grey42],[/][#4a8a68]a8[/][grey42]"[/]   [grey42]"[/][#4a8a68]8a[/][grey42],[/]   [grey42],[/][#4a8a68]aa[/] [grey42]"[/][#4a8a68]8a[/][grey42],[/]   [grey42],[/][#4a8a68]aa[/]
+[#4a8a68]88[/]      [#4a8a68]88[/]      [#4a8a68]88[/] [#4a8a68]88[/]  [grey42]`"[/][#4a8a68]Ybbd8[/][grey42]"'[/] [#4a8a68]88[/]          [grey42]`"[/][#4a8a68]YbbdP[/][grey42]"'[/]     [grey42]`"[/][#4a8a68]Ybbd8[/][grey42]"'[/]  [grey42]`"[/][#4a8a68]Ybbd8[/][grey42]"'[/]
+[grey42 italic]Knowledge work is, by extension, a coding problem.[/]
+
+[#4a8a68]enter[/] [grey42]submit[/] [grey42]·[/] [#4a8a68]esc[/] [grey42]interrupt[/] [grey42]·[/] [#4a8a68]/[/] [grey42]commands[/]
 """
 
 

{micro_cc-0.2.32 → micro_cc-0.2.35}/src/micro_cc/start_live_.py

@@ -15,6 +15,7 @@ from micro_cc.utils.process_tracker import init as init_process_tracker
 from micro_cc.cache.redis_cache import RedisStateManager
 from micro_cc.screens.window_overlay_ import MessageList, MessageRow, StreamingRow, BANNER
 from micro_cc.utils.file_watcher_ import FileWatcher
+from micro_cc.models import registry as model_registry
 from textual.app import App, ComposeResult
 from textual.containers import Vertical, VerticalScroll
 from textual.widgets import Static
@@ -131,7 +132,7 @@ class PromptInput(TextArea):
 
 class MicroApp(App):
 
-    MODEL_OPTIONS = ["sonnet-5", "opus-4.8", "opus-4.7", "opus-4.6", "sonnet-4.6", "haiku-4.5"]
+    MODEL_OPTIONS = model_registry.MODEL_OPTIONS
 
     LOGIN_SEQUENCE = {
         "Anthropic": ["ANTHROPIC_API_KEY", "OPENAI_API_KEY", "SERPAPI_KEY"],
@@ -147,7 +148,7 @@ class MicroApp(App):
         "SERPAPI_KEY":       "SERPAPI_KEY — optional, Enter to skip",
     }
 
-    _current_model = "sonnet-4.6"
+    _current_model = model_registry.DEFAULT_MODEL
     _trim_budget = 80000
 
     ALLOW_SELECT = True
@@ -603,7 +604,17 @@ class MicroApp(App):
         except Exception:
             return  # offline or PyPI unreachable — silently retry next start
 
-        if not latest or latest == __version__:
+        def _version_tuple(v):
+            parts = []
+            for p in v.split("."):
+                digits = "".join(ch for ch in p if ch.isdigit())
+                parts.append(int(digits) if digits else 0)
+            return tuple(parts)
+
+        # Strict > only — PyPI's JSON endpoint can lag behind a just-published
+        # version for a few minutes, and a stale read here must never look
+        # like a downgrade target.
+        if not latest or _version_tuple(latest) <= _version_tuple(__version__):
             return
 
         statusbar = self.query_one("#statusbar", Static)
@@ -614,14 +625,21 @@ class MicroApp(App):
         prompt.disabled = True
         prompt.placeholder = f"Updating micro-cc {__version__} → {latest}…"
 
-        # --quiet/--disable-pip-version-check trim chatter, --no-input stops
-        # any prompt from hanging a headless run. Piped (not inherited) so
-        # pip can never write straight to the tty mid-render and corrupt the
-        # Textual alt-screen — a background task drains the pipe as it fills
-        # so a chatty pip can't deadlock the subprocess either.
+        # --force-reinstall guarantees the package (and its deps) actually
+        # get overwritten rather than skipped as "already satisfied" — that's
+        # what makes this the real update mechanism on other machines, so it
+        # stays. No --no-cache-dir though: pip's wheel cache is keyed by
+        # exact version+hash, so reusing it is still a full, correct
+        # reinstall — it just skips redundant network fetches for deps whose
+        # version didn't change. --quiet/--disable-pip-version-check trim
+        # chatter, --no-input stops any prompt from hanging a headless run.
+        # Piped (not inherited) so pip can never write straight to the tty
+        # mid-render and corrupt the Textual alt-screen — a background task
+        # drains the pipe as it fills so a chatty pip can't deadlock the
+        # subprocess either.
         proc = await asyncio.create_subprocess_exec(
             sys.executable, "-m", "pip", "install",
-            "--upgrade", "--force-reinstall", "--no-cache-dir",
+            "--upgrade", "--force-reinstall",
             "--quiet", "--no-input", "--disable-pip-version-check",
             "micro-cc",
             stdout=asyncio.subprocess.PIPE,
@@ -1152,7 +1170,14 @@ class MicroApp(App):
                 self.run_worker(self.do_query(next_q), exclusive=True)
 
     def on_unmount(self):
-        self._term_busy(False)  # clear the terminal progress indicator on exit
+        # No raw /dev/tty write here — on_unmount fires before Textual's own
+        # driver restores the terminal (exits alt-screen, pops the keyboard
+        # enhancement mode, disables mouse tracking), so a write racing that
+        # teardown risks corrupting it. _set_busy(False) already clears the
+        # OSC 9;4 progress indicator at the end of every turn; exiting while
+        # idle needs no extra write, and exiting mid-turn relies on the
+        # terminal clearing per-tab state on process exit, same as every
+        # other OSC 9;4-aware terminal already does.
         self._watcher.stop()
         self._state_mgr.stop_cleanup_task()
 

micro_cc-0.2.35/src/micro_cc/tools/bash_tool.py

@@ -0,0 +1,255 @@
+import asyncio
+import os
+import shlex
+import shutil
+import signal
+import subprocess
+import tempfile
+
+
+_SHELL = shutil.which("bash") or "/bin/bash"
+
+# Sticky cwd per project_dir: lets `cd` inside one bash_ call carry over to
+# the next, like a real shell session, instead of resetting to project_dir
+# on every call.
+_cwd_state: dict[str, str] = {}
+
+# One-time snapshot of the user's interactive aliases/functions, so bash_
+# commands behave like a real terminal instead of a bare, alias-less `bash -c`.
+_snapshot_path: str | None = None
+_snapshot_attempted = False
+_snapshot_lock = asyncio.Lock()
+
+# No command-level restrictions here by design: this tool has no visibility
+# into whether it's gated (TUI's dangerous_tools/approval_request already
+# covers bash_ end-to-end at the tool-call level -- see claude_loop_.py).
+# Baking a second, command-level check in here would either duplicate that
+# gate or silently override it, so it doesn't live here.
+
+
+async def _ensure_shell_snapshot() -> str | None:
+    """Capture aliases/functions from an interactive shell once per process
+    and reuse them on every bash_ call. Cached including failures, so a
+    broken snapshot attempt isn't retried on every single call."""
+    global _snapshot_path, _snapshot_attempted
+    async with _snapshot_lock:
+        if _snapshot_attempted:
+            return _snapshot_path
+        _snapshot_attempted = True
+        fd, path = tempfile.mkstemp(prefix="micro_cc_shell_snapshot_")
+        os.close(fd)
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                _SHELL, "-i", "-c",
+                f"{{ alias -p; declare -f; }} > {shlex.quote(path)} 2>/dev/null",
+                stdin=subprocess.DEVNULL,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+            await asyncio.wait_for(proc.wait(), timeout=5)
+            if os.path.getsize(path) > 0:
+                _snapshot_path = path
+            else:
+                os.unlink(path)
+        except Exception:
+            try:
+                os.unlink(path)
+            except OSError:
+                pass
+        return _snapshot_path
+
+
+def _kill_tree(proc):
+    """SIGKILL the whole process group, not just the direct bash process.
+
+    start_new_session=True makes proc.pid its own process-group id, so this
+    also reaps anything the command piped into or backgrounded — a plain
+    proc.kill() only hits bash itself and orphans the rest.
+    """
+    try:
+        os.killpg(proc.pid, signal.SIGKILL)
+    except ProcessLookupError:
+        pass
+
+
+async def _drain_loop(pipe, chunks: list):
+    """Continuously copy whatever's available on `pipe` into `chunks`.
+
+    Runs concurrently with the process, not after it — without this, a
+    command producing more than the OS pipe buffer (~64KB) blocks on
+    write() forever since nothing reads until wait() returns. Left running
+    until cancelled; a backgrounded `cmd &` child inheriting this pipe
+    would otherwise keep it open past bash's own exit, so we never wait for
+    EOF here — the caller cancels once bash itself has exited.
+    """
+    fd = pipe.fileno()
+    os.set_blocking(fd, False)
+    while True:
+        try:
+            chunk = os.read(fd, 65536)
+        except BlockingIOError:
+            await asyncio.sleep(0.01)
+            continue
+        if not chunk:
+            return  # real EOF: every holder of the write end has closed it
+        chunks.append(chunk)
+
+
+async def _cancel(task):
+    task.cancel()
+    try:
+        await task
+    except asyncio.CancelledError:
+        pass
+
+
+async def bash_(
+    command: str,
+    *,
+    project_dir: str,
+    path: str = None,
+    timeout: int = 120
+) -> str:
+    """Execute bash command.
+
+    Args:
+        command: The bash command to execute
+        path: Working directory (default: last known cwd for this project, initially project_dir). Relative paths resolve to project_dir.
+        timeout: Max seconds before killing process (default 120)
+    """
+    max_output_chars = 60000
+
+    # Determine cwd. `cd` inside a previous command call carries over via
+    # _cwd_state, so this behaves like one continuous shell session rather
+    # than resetting to project_dir on every call.
+    if path:
+        if os.path.isabs(path):
+            cwd = path
+        else:
+            cwd = os.path.normpath(os.path.join(project_dir, path))
+    else:
+        cwd = _cwd_state.get(project_dir, project_dir)
+
+    if not os.path.isdir(cwd):
+        return f"[Directory not found: {cwd}]"
+
+    if _SHELL is None:
+        return "[No bash found on this machine]"
+
+    snapshot_path = await _ensure_shell_snapshot()
+
+    cwd_fd, cwd_file = tempfile.mkstemp(prefix="micro_cc_cwd_")
+    os.close(cwd_fd)
+
+    # Wrap the command so we can (a) source captured aliases/functions and
+    # (b) capture the resulting cwd for the next call, regardless of the
+    # command's own exit code. Newline-separated (not &&) so `pwd -P` still
+    # runs even if `command` exits non-zero.
+    script_lines = []
+    if snapshot_path:
+        script_lines.append(f"source {shlex.quote(snapshot_path)} 2>/dev/null || true")
+        script_lines.append("shopt -s expand_aliases 2>/dev/null || true")
+    script_lines.append(command)
+    script_lines.append("__mcc_ec=$?")
+    script_lines.append(f"pwd -P > {shlex.quote(cwd_file)}")
+    script_lines.append("exit $__mcc_ec")
+    full_command = "\n".join(script_lines)
+
+    try:
+        # Plain subprocess.Popen, not asyncio.create_subprocess_exec: asyncio's
+        # subprocess transport ties proc.wait()/returncode to ALL stdio pipes
+        # reaching EOF, not just the process exiting. A backgrounded `cmd &`
+        # child inherits those same pipes and can hold them open indefinitely,
+        # which made the asyncio version hang for the full timeout on every
+        # backgrounded launch. Popen.wait() (run in an executor thread below)
+        # reflects the shell's own exit immediately, independent of who still
+        # holds the pipes.
+        proc = subprocess.Popen(
+            [_SHELL, "-c", full_command],
+            cwd=cwd,
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            env={**os.environ, "TERM": "dumb"},
+            # Detach into a new session: no controlling terminal, own
+            # process group. Without this, a child that opens /dev/tty
+            # directly (ssh -t, vim, another Textual app, ...) reaches the
+            # REAL terminal the host TUI owns — writes its own raw-mode/
+            # alt-screen escape codes onto it and steals keyboard input,
+            # which is exactly the "bleeds onto terminal and breaks the
+            # app" failure. New session also means proc.pid is a process
+            # group id, so a timeout can kill the whole tree, not just bash.
+            start_new_session=True,
+        )
+
+        stdout_chunks: list = []
+        stderr_chunks: list = []
+        stdout_task = asyncio.ensure_future(_drain_loop(proc.stdout, stdout_chunks))
+        stderr_task = asyncio.ensure_future(_drain_loop(proc.stderr, stderr_chunks))
+
+        loop = asyncio.get_running_loop()
+        try:
+            await asyncio.wait_for(loop.run_in_executor(None, proc.wait), timeout=timeout)
+        except asyncio.TimeoutError:
+            _kill_tree(proc)
+            await _cancel(stdout_task)
+            await _cancel(stderr_task)
+            return f"[Command timed out after {timeout}s]"
+        except asyncio.CancelledError:
+            _kill_tree(proc)
+            await _cancel(stdout_task)
+            await _cancel(stderr_task)
+            raise  # re-raise so gather/task cancellation propagates
+
+        # bash exited — one more beat for the drain loops to pick up
+        # anything already flushed to the pipe, then stop. Don't wait for
+        # true EOF: a backgrounded child may still hold a pipe open forever.
+        await asyncio.sleep(0.05)
+        await _cancel(stdout_task)
+        await _cancel(stderr_task)
+
+        stdout = b"".join(stdout_chunks).decode("utf-8", errors="replace")
+        stderr = b"".join(stderr_chunks).decode("utf-8", errors="replace")
+
+        # Build output
+        if proc.returncode != 0:
+            output = f"[Exit code: {proc.returncode}]\n"
+            if stderr:
+                output += f"STDERR:\n{stderr}\n"
+            if stdout:
+                output += f"STDOUT:\n{stdout}"
+        else:
+            output = stdout
+            if stderr:
+                output += f"\n[STDERR]: {stderr}"
+
+        # Truncate if too long (keep head + tail)
+        if len(output) > max_output_chars:
+            half = max_output_chars // 2
+            output = (
+                output[:half] +
+                f"\n\n... [TRUNCATED {len(output) - max_output_chars} chars] ...\n\n" +
+                output[-half:]
+            )
+
+        return output.strip() or "[No output]"
+
+    except asyncio.CancelledError:
+        raise  # always propagate
+    except Exception as e:
+        return f"[Bash error: {type(e).__name__}: {e}]"
+    finally:
+        # Pick up wherever `command` left the shell (via `cd`), so the next
+        # call starts there instead of resetting to project_dir. Empty/missing
+        # on timeout or a crash before `pwd -P` ran -- just skip the update.
+        try:
+            with open(cwd_file, "r") as f:
+                new_cwd = f.read().strip()
+            if new_cwd:
+                _cwd_state[project_dir] = new_cwd
+        except OSError:
+            pass
+        try:
+            os.unlink(cwd_file)
+        except OSError:
+            pass