micro-cc 0.2.78__tar.gz → 0.2.81__tar.gz

micro_cc-0.2.81/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 George Salapa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

micro_cc-0.2.81/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: micro-cc
+Version: 0.2.81
+Summary: Harness that gives frontier models full system access — shell, filesystem, browser, MCP — running directly on the metal.
+Author: George Salapa
+License: MIT License
+        
+        Copyright (c) 2026 George Salapa
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: anthropic>=0.76.0
+Requires-Dist: anyio>=4.0
+Requires-Dist: beautifulsoup4>=4.14
+Requires-Dist: fastapi>=0.135
+Requires-Dist: google-search-results>=2.4
+Requires-Dist: httpx>=0.28
+Requires-Dist: httpx-sse>=0.4
+Requires-Dist: lxml>=6.0
+Requires-Dist: mammoth>=1.11
+Requires-Dist: markdown-it-py>=4.0
+Requires-Dist: markdownify>=1.2
+Requires-Dist: mcp>=1.26
+Requires-Dist: numpy>=2.4
+Requires-Dist: openai>=2.16
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: pathvalidate>=3.3
+Requires-Dist: pdfminer.six>=20260107
+Requires-Dist: pillow>=12.0
+Requires-Dist: playwright>=1.58
+Requires-Dist: prompt_toolkit>=3.0
+Requires-Dist: puremagic>=1.30
+Requires-Dist: PyAutoGUI>=0.9
+Requires-Dist: pydantic>=2.12
+Requires-Dist: pydantic-settings>=2.13
+Requires-Dist: pyperclip>=1.9
+Requires-Dist: python-dotenv>=1.2
+Requires-Dist: python-pptx>=1.0
+Requires-Dist: requests>=2.32
+Requires-Dist: rich>=14.0
+Requires-Dist: uvicorn>=0.42
+Requires-Dist: xlsxwriter>=3.2
+Requires-Dist: youtube-transcript-api>=1.2
+Provides-Extra: postgres
+Requires-Dist: psycopg[binary]>=3.2; extra == "postgres"
+Dynamic: license-file
+
+# micro · cc — cognitive compute
+
+```
+                   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. 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
+
+```bash
+pip install micro-cc
+```
+
+macOS and WSL only — both are real POSIX/bash environments, which the `bash_` tool requires. On Windows, install WSL first, then run `pip install micro-cc` *inside* the WSL shell.
+
+## Usage
+
+```bash
+microcc /path/to/your/project
+```
+
+First run, type `/login` to configure your model endpoint. Type `/` inside the app for the full command list — it's always current with what's actually built.
+
+Non-interactive entry point: `microcc-headless` (single prompt, cron-friendly). Run with `--help` for usage.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

micro_cc-0.2.81/README.md

@@ -0,0 +1,38 @@
+# micro · cc — cognitive compute
+
+```
+                   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. 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
+
+```bash
+pip install micro-cc
+```
+
+macOS and WSL only — both are real POSIX/bash environments, which the `bash_` tool requires. On Windows, install WSL first, then run `pip install micro-cc` *inside* the WSL shell.
+
+## Usage
+
+```bash
+microcc /path/to/your/project
+```
+
+First run, type `/login` to configure your model endpoint. Type `/` inside the app for the full command list — it's always current with what's actually built.
+
+Non-interactive entry point: `microcc-headless` (single prompt, cron-friendly). Run with `--help` for usage.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

{micro_cc-0.2.78 → micro_cc-0.2.81}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "micro-cc"
-version = "0.2.78"
+version = "0.2.81"
 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"
 license = {file = "LICENSE"}
 authors = [{name = "George Salapa"}]
-classifiers = ["License :: Other/Proprietary License"]
+classifiers = ["License :: OSI Approved :: MIT License"]
 
 dependencies = [
     "anthropic>=0.76.0",
@@ -53,7 +53,6 @@ postgres = ["psycopg[binary]>=3.2"]
 [project.scripts]
 microcc = "micro_cc.start_live_tui_:start_"
 microcc-headless = "micro_cc.start_headless_:start_headless_"
-microcc-batch = "micro_cc.start_batch_:start_batch_"
 
 [tool.setuptools.packages.find]
 where = ["src"]

{micro_cc-0.2.78 → micro_cc-0.2.81}/src/micro_cc/browser/_md_convert.py

@@ -24,7 +24,8 @@ import os
 import re
 
 
-from micro_cc.utils.helpers import get_endpoint
+from micro_cc.models import model_call
+from micro_cc.utils import settings_store_
 
 
 class _CustomMarkdownify(markdownify.MarkdownConverter):
@@ -639,26 +640,18 @@ class ImageConverter(MediaConverter):
     def _get_image_description(self, local_path, extension):
         prompt = "Write a detailed caption for this image."
 
-        data_uri = ""
         with open(local_path, "rb") as image_file:
-            content_type, encoding = mimetypes.guess_type("_dummy" + extension)
-            if content_type is None:
-                content_type = "image/jpeg"
             image_base64 = base64.b64encode(image_file.read()).decode("utf-8")
-            data_uri = f"data:{content_type};base64,{image_base64}"
-
-        endpoint = get_endpoint()
-        # Lazy-imported per-branch — see claude_loop_.py's dispatch for why.
-        if endpoint == "LiteLLM":
-            from micro_cc.models.litellm import l_model_call
-            response = asyncio.run(l_model_call(input=prompt, encoded_image=data_uri))
-        elif endpoint == "Foundry":
-            from micro_cc.models.foundry import f_model_call
-            response = asyncio.run(f_model_call(input=prompt, encoded_image=data_uri))
-        else:
-            from micro_cc.models.anthropic import a_model_call
-            response = asyncio.run(a_model_call(input=prompt, encoded_image=data_uri))
-        return response.content[0].text
+
+        # Providers add their own image envelope; encoded_image is bare base64.
+        # Use the selected model rather than a Claude default on OpenAI/Ollama.
+        response = asyncio.run(model_call(
+            input=prompt, encoded_image=image_base64,
+            model=settings_store_.get_setting("model"),
+        ))
+        if response is None:
+            return ""
+        return "\n".join(block.text for block in response.content if block.type == "text")
 
 
 class FileConversionException(BaseException):

micro_cc-0.2.81/src/micro_cc/cache/state_store.py

@@ -0,0 +1,197 @@
+import logging
+import time
+import threading
+from typing import Dict, Optional, Any
+
+logger = logging.getLogger(__name__)
+
+# In-memory, single-process state store for the running project's loop state
+# (todos, discovered tools/MCPs, streaming flag). microcc is always one user
+# in one process, so a namespaced module-level dict with per-entry TTLs is
+# all this needs — no separate process, no connection, no serialization
+# boundary to manage.
+
+_NAMESPACE = "micro_cc"
+
+_store: Dict[str, Dict[str, Any]] = {}
+_lock = threading.RLock()  # reentrant, since some ops call other ops while holding it
+_cleanup_running = False
+
+
+def _make_key(key_type: str, *parts: str) -> str:
+    """Generate namespaced key"""
+    return f"{_NAMESPACE}:{key_type}:" + ":".join(parts)
+
+
+def _set_with_ttl(key: str, value: Any, ttl: int) -> None:
+    """Set value with expiration timestamp"""
+    expiry = time.time() + ttl
+    with _lock:
+        _store[key] = {"value": value, "expiry": expiry}
+
+
+def _get(key: str) -> Optional[Any]:
+    """Get value if not expired, cleanup if expired"""
+    with _lock:
+        if key not in _store:
+            return None
+        entry = _store[key]
+        if time.time() > entry["expiry"]:
+            del _store[key]
+            return None
+        return entry["value"]
+
+
+def _delete(key: str) -> None:
+    """Delete key"""
+    with _lock:
+        _store.pop(key, None)
+
+
+def _cleanup_expired() -> None:
+    """Background task to clean up expired entries"""
+    while _cleanup_running:
+        time.sleep(60)  # Run every minute
+        current_time = time.time()
+        with _lock:
+            expired_keys = [
+                k for k, v in _store.items() if current_time > v["expiry"]
+            ]
+            for key in expired_keys:
+                del _store[key]
+            if expired_keys:
+                logger.debug("Cleaned up %d expired state entries", len(expired_keys))
+
+
+def start_cleanup_task() -> None:
+    """Start background cleanup thread"""
+    global _cleanup_running
+    if not _cleanup_running:
+        _cleanup_running = True
+        cleanup_thread = threading.Thread(
+            target=_cleanup_expired, daemon=True, name="StateCleanup"
+        )
+        cleanup_thread.start()
+        logger.debug("State cleanup task started")
+
+
+def stop_cleanup_task() -> None:
+    """Stop background cleanup thread"""
+    global _cleanup_running
+    _cleanup_running = False
+
+
+# ========================= Todos =========================
+# Stored as the raw dict (in-memory store, no serialization needed).
+# Keyed by project_dir, same TTL as plan.
+
+def set_todos(project_dir: str, todos: dict) -> None:
+    """Persist the todo store (id -> {content, status, notes, ...})."""
+    try:
+        key = _make_key("todos", project_dir)
+        _set_with_ttl(key, todos, 3600)
+    except Exception as e:
+        logger.warning("State error in set_todos: %s", e)
+
+
+def get_todos(project_dir: str) -> Optional[dict]:
+    """Return the todo store dict, or None if unset/expired."""
+    try:
+        key = _make_key("todos", project_dir)
+        return _get(key)
+    except Exception as e:
+        logger.warning("State error in get_todos: %s", e)
+        return None
+
+
+def clear_todos(project_dir: str) -> None:
+    """Wipe the todo store for this project."""
+    try:
+        key = _make_key("todos", project_dir)
+        _delete(key)
+    except Exception as e:
+        logger.warning("State error in clear_todos: %s", e)
+
+
+##########################tool discovery
+
+DISCOVERED_TOOLS_TTL = 180  # seconds of inactivity before re-discovery is required
+
+
+def get_discovered_tools(project_dir: str) -> set:
+    try:
+        key = _make_key("discovered_tools", project_dir)
+        data = _get(key)
+        if not data:
+            return set()
+        return set(data.get("discovered_tools", []))
+    except Exception as e:
+        logger.warning("State error in get_discovered_tools: %s", e)
+        return set()
+
+
+def add_discovered_tools(project_dir: str, tools: list) -> None:
+    try:
+        existing = get_discovered_tools(project_dir)
+        existing.update(tools)
+        data = {"discovered_tools": list(existing)}
+        key = _make_key("discovered_tools", project_dir)
+        _set_with_ttl(key, data, DISCOVERED_TOOLS_TTL)
+    except Exception as e:
+        logger.warning("State error in add_discovered_tools: %s", e)
+
+
+def clear_discovered_tools(project_dir: str) -> None:
+    try:
+        key = _make_key("discovered_tools", project_dir)
+        _delete(key)
+    except Exception as e:
+        logger.warning("State error in clear_discovered_tools: %s", e)
+
+
+########################## mcp discovery
+
+def get_discovered_mcps(project_dir: str) -> set:
+    try:
+        key = _make_key("discovered_mcps", project_dir)
+        data = _get(key)
+        if not data:
+            return set()
+        return set(data.get("discovered_mcps", []))
+    except Exception as e:
+        logger.warning("State error in get_discovered_mcps: %s", e)
+        return set()
+
+
+def add_discovered_mcps(project_dir: str, mcps: list) -> None:
+    try:
+        existing = get_discovered_mcps(project_dir)
+        existing.update(mcps)
+        data = {"discovered_mcps": list(existing)}
+        key = _make_key("discovered_mcps", project_dir)
+        _set_with_ttl(key, data, DISCOVERED_TOOLS_TTL)
+    except Exception as e:
+        logger.warning("State error in add_discovered_mcps: %s", e)
+
+
+def clear_discovered_mcps(project_dir: str) -> None:
+    try:
+        key = _make_key("discovered_mcps", project_dir)
+        _delete(key)
+    except Exception as e:
+        logger.warning("State error in clear_discovered_mcps: %s", e)
+
+
+########################## streaming state
+
+def set_streaming_state(project_dir: str, active: bool) -> None:
+    key = _make_key("streaming", project_dir)
+    if active:
+        _set_with_ttl(key, True, 600)
+    else:
+        _delete(key)
+
+
+def get_streaming_state(project_dir: str) -> bool:
+    key = _make_key("streaming", project_dir)
+    return bool(_get(key))

{micro_cc-0.2.78 → micro_cc-0.2.81}/src/micro_cc/claude_loop_.py

@@ -1,13 +1,13 @@
 import asyncio
 import datetime
-import json
 import os
 from functools import partial
 
 from dotenv import load_dotenv
 
-from micro_cc.cache.redis_cache import RedisStateManager
+from micro_cc.cache import state_store
 from micro_cc.execute_tool import execute_tool_call
+from micro_cc.models import model_call
 from micro_cc.models.registry import DEFAULT_MODEL, DEFAULT_TRIM_BUDGET
 from micro_cc.utils.tool_limits import cap_for, MAX_TOOL_RESULTS_PER_MESSAGE
 from micro_cc.utils.tool_result_storage import persist_and_preview
@@ -33,7 +33,7 @@ from micro_cc.tools.search_tool_ import (
 )
 from micro_cc.tools.mcp_client_ import resolve_mcp_tools, call_mcp_tool
 from micro_cc.utils.msg_store_ import load_summary, load_checkpoint, compact_checkpoint
-from micro_cc.utils.tokenization_simple import token_cutter, token_stats, save_token_stats
+from micro_cc.utils.tokenization_simple import token_cutter, token_stats, save_token_stats, detect_cache_miss
 from micro_cc.utils.claude_md_loader import load_claude_md_file
 from micro_cc.utils.helpers import get_endpoint
 
@@ -98,7 +98,7 @@ async def claude_loop(
 
     surface identifies which caller is driving this turn — "tui" (the live
     boss, start_live_.py's do_query), "gui" (webui/server.py's browser
-    handoff), or the default "headless" (start_headless_.py/start_batch_.py,
+    handoff), or the default "headless" (start_headless_.py,
     including a subagent spawned by /graph itself). Defaults to the most
     restrictive value on purpose: only "tui" gets the self-invocation
     invitation to start a /graph-style orchestration (see below) — the
@@ -123,7 +123,6 @@ async def claude_loop(
     dangerous = DEFAULT_DANGEROUS if dangerous_tools is None else set(dangerous_tools)
     ask_user = ASK_USER_QUESTION_TOOL
     end_resp = get_endpoint()
-    redis_state = RedisStateManager()
 
     skills_summary = get_skill_summary(project_dir)
     claude_md_content = load_claude_md_file(project_dir)
@@ -178,7 +177,7 @@ async def claude_loop(
             tools[tool.__name__] = tool
 
     #########discovered tools
-    discovered_tools = redis_state.get_discovered_tools(project_dir)
+    discovered_tools = state_store.get_discovered_tools(project_dir)
     for tool_name in discovered_tools:
         if tool_name not in tools:
             tool_schemas.append(get_tool_schema(tool_name))
@@ -189,7 +188,7 @@ async def claude_loop(
     # the MCP client (fetch tools, dispatch calls). Their auth stays local
     # (mcp_client_.resolve_mcp_tools reads auth_env), never sent to a model
     # provider. mcp_routing: {tool_name: {"url": server_url, "headers": dict}}
-    discovered_mcp = redis_state.get_discovered_mcps(project_dir)
+    discovered_mcp = state_store.get_discovered_mcps(project_dir)
     mcp_routing = {}
     resolved_mcp_names = set()  # catalog/server names already fetched — avoids re-resolving
 
@@ -490,49 +489,14 @@ whole conversation history, including compacted turns.
         )
 
         try:
-            # Imported lazily, per-branch: anthropic/openai are the two
-            # heaviest imports in the whole app (pydantic building hundreds
-            # of response-type models — see search_tool_.py's own lazy
-            # AsyncOpenAI import for the same reason). Only one backend is
-            # ever active per session, so eagerly importing all four at
-            # module load (as this used to) paid for both SDKs on every
-            # startup no matter which endpoint was actually configured.
-            if end_resp == "Ollama":
-                from micro_cc.models.ollama import o_model_call
-                stream = await o_model_call(
-                    input=trimmed_loop_msgs,
-                    model=model,
-                    tools=tool_schemas,
-                    thinking=True,
-                    stream=True,
-                )
-            elif end_resp == "LiteLLM":
-                from micro_cc.models.litellm import l_model_call
-                stream = await l_model_call(
-                    input=trimmed_loop_msgs,
-                    model=model,
-                    tools=tool_schemas,
-                    thinking=True,
-                    stream=True,
-                )
-            elif end_resp == "Foundry":
-                from micro_cc.models.foundry import f_model_call
-                stream = await f_model_call(
-                    input=trimmed_loop_msgs,
-                    model=model,
-                    tools=tool_schemas,
-                    thinking=True,
-                    stream=True,
-                )
-            else:
-                from micro_cc.models.anthropic import a_model_call
-                stream = await a_model_call(
-                    input=trimmed_loop_msgs,
-                    model=model,
-                    tools=tool_schemas,
-                    thinking=True,
-                    stream=True,
-                )
+            stream = await model_call(
+                input=trimmed_loop_msgs,
+                model=model,
+                endpoint=end_resp,
+                tools=tool_schemas,
+                thinking=True,
+                stream=True,
+            )
 
             if stream is None:
                 yield {"type": "error", "message": "model call failed after retries"}
@@ -549,12 +513,27 @@ whole conversation history, including compacted turns.
                     response = event["response"]
                     api_usage = event.get("usage", {})
 
+            cache_miss = None
             if api_usage.get("input"):
+                # detect_cache_miss BEFORE token_stats["input"] is overwritten
+                # below — it needs the PREVIOUS turn's snapshot to compare
+                # against this turn's.
+                cache_miss = detect_cache_miss(api_usage, model)
+                # "input": last call's context size (live ctx% readout —
+                # same snapshot semantics as real Claude Code's
+                # calculateContextPercentages). "total_input": running sum
+                # across every call this session (same as real Claude
+                # Code's cost-tracker.ts addToTotalModelUsage) — each turn
+                # is its own billed API request, so real spend is this
+                # sum, not the size of the most recent one alone.
                 token_stats["input"] = api_usage["input"]
+                token_stats["total_input"] += api_usage["input"]
             if api_usage.get("output"):
                 token_stats["output"] += api_usage["output"]
             if api_usage:
                 save_token_stats(project_dir)
+            if cache_miss:
+                yield {"type": "cache_invalidate", **cache_miss}
 
             if response is None:
                 yield {"type": "error", "message": "model call failed after retries"}
@@ -573,17 +552,17 @@ whole conversation history, including compacted turns.
             # thinking + text already streamed as deltas above
 
             if tool_use_blocks:
-                # Auto-re-resolve tools that expired from Redis but exist in catalogs
+                # Auto-re-resolve tools that expired from state_store but exist in catalogs
                 for tb in tool_use_blocks:
                     if tb.name not in tools and tb.name not in mcp_routing:
                         if tb.name in TOOL_CATALOG:
-                            # Re-inject from catalog + refresh Redis
+                            # Re-inject from catalog + refresh state_store
                             tool_schemas.append(get_tool_schema(tb.name))
                             tools[tb.name] = get_tool_func(tb.name)
-                            redis_state.add_discovered_tools(project_dir, [tb.name])
+                            state_store.add_discovered_tools(project_dir, [tb.name])
                         elif tb.name in mcp_catalog:
-                            # Re-inject MCP + refresh Redis
-                            redis_state.add_discovered_mcps(project_dir, [tb.name])
+                            # Re-inject MCP + refresh state_store
+                            state_store.add_discovered_mcps(project_dir, [tb.name])
                             new_mcp_tools, new_mcp_routing, new_mcp_failures = await resolve_mcp_tools([mcp_catalog[tb.name]])
                             tool_schemas.extend(new_mcp_tools)
                             mcp_routing.update(new_mcp_routing)
@@ -739,8 +718,8 @@ whole conversation history, including compacted turns.
                     if tool_block.name == "search_tools" and isinstance(result, dict):
                         new_tools = result.get("discovered_tools", [])
                         new_mcps = result.get("discovered_mcps", [])
-                        redis_state.add_discovered_tools(project_dir, new_tools)
-                        redis_state.add_discovered_mcps(project_dir, new_mcps)
+                        state_store.add_discovered_tools(project_dir, new_tools)
+                        state_store.add_discovered_mcps(project_dir, new_mcps)
                         # Inject into current loop so next API call has them
                         for t_name in new_tools:
                             if t_name not in tools:
@@ -870,14 +849,6 @@ whole conversation history, including compacted turns.
                 # for this whole turn (final_text/done) to finish.
                 yield {"type": "turn_boundary"}
 
-                # # Post-tool nudge (lightweight user reminder, not full context)
-                # plan_data_post = redis_state.get_plan(project_dir)
-                # if plan_data_post:
-                #     post_reminder = get_post_tool_plan_reminder(plan_data_post, all_blocks[0].name)
-                #     msgs.append({"role": "user", "content": f"<system-reminder>{post_reminder}</system-reminder>"})
-                # else:
-                #     msgs.append({"role": "user", "content": "<system-reminder>You just used a tool. Note what you found, then continue working silently — no narration needed.</system-reminder>"})
-
             # No tool use = final response (text already streamed as deltas)
             if not tool_use_blocks and text_block:
                 msgs.append({"role": "assistant", "content": text_block.text})

{micro_cc-0.2.78 → micro_cc-0.2.81}/src/micro_cc/execute_tool.py

@@ -23,7 +23,11 @@ async def execute_tool_call(
     args = tool_call.input  # Already a dict from SDK
 
     if name not in tools:
-        return f"Unknown tool: {name}"
+        return (
+            f"Tool '{name}' is not loaded — discovered tools expire after "
+            f"180s of inactivity. Call search_tools again to rediscover it, "
+            f"then retry."
+        )
 
     tool = tools[name]
 

micro_cc-0.2.81/src/micro_cc/models/__init__.py

@@ -0,0 +1,6 @@
+"""Application model API. Provider SDKs are loaded only when called."""
+
+from micro_cc.models.client import model_call
+from micro_cc.models.types import ContentBlock, Response, ResponseStream, StreamEvent, Usage
+
+__all__ = ["model_call", "ContentBlock", "Response", "ResponseStream", "StreamEvent", "Usage"]

micro_cc-0.2.81/src/micro_cc/models/adapters/__init__.py

@@ -0,0 +1 @@
+"""SDK-output adapters. No credentials, requests, retries, or SDK imports here."""