code-context-control 2.54.0__py3-none-any.whl → 2.55.0__py3-none-any.whl

cli/c3.py

@@ -92,7 +92,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.54.0"
+__version__ = "2.55.0"
 
 
 def _command_deps() -> CommandDeps:

{code_context_control-2.54.0.dist-info → code_context_control-2.55.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.54.0
+Version: 2.55.0
 Summary: Local code-intelligence layer for AI coding tools (Claude Code, Codex, Copilot, Cursor, Antigravity). Retrieve less, read less, edit safer — and version the configs that shape your agent (CLAUDE.md, skills, hooks, MCP).
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0

{code_context_control-2.54.0.dist-info → code_context_control-2.55.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 cli/__init__.py,sha256=ec66drCZGNMRU4V6ov0zVhYZph1us12Vn8OvG_LJyRY,22
 cli/_hook_utils.py,sha256=tJ4ZmXD5Y-JjFWb0uoR7ycYklYFUMnnjF2G7BO-wyBI,12600
-cli/c3.py,sha256=jTV4sTDaPkooaJtlwaQOAKYXY4Q6C5RfyioKX35vfTM,309220
+cli/c3.py,sha256=vH0SuIP9w6imPbFVi8y-veKrAKfNYrYC0KYiA8ydb54,309220
 cli/docs.html,sha256=bNymSz7LatnWHjxSXL92QSUtGvB3jBzNHbOV-bRpAOo,142507
 cli/edits.html,sha256=UjAhoCmBmQ89cklGvJqzC6eyNP2tc8H6T-e01DVkLvE,43418
 cli/hook_artifact.py,sha256=Se1CNBfoBFyvJQlRmYdNtdRXIkQp9zaF0O6ndRMo7ts,2198
@@ -95,7 +95,7 @@ cli/ui/components/sessions.js,sha256=FIKtil76B8tCkAmcFV7hlj6GQ_DCJK2jCzvEmdK7NBE
 cli/ui/components/settings.js,sha256=ATbAjBlVIwCNpxq7s191b49a_INQV38iwmySqtJLYwY,79066
 cli/ui/components/sidebar.js,sha256=cAY_jwYB-o1X_wWn__VXlG4IegVObuE3NmVsuFWqxtg,7417
 cli/ui/components/tasks.js,sha256=vyKQ3uwoppMwvdEaHlhWXW4oWcAisx4NveqzMhsYqHo,38438
-code_context_control-2.54.0.dist-info/licenses/LICENSE,sha256=l8Kh5QCNWNvR6kIt8L0BUZvc2LAFiHv2c-FnsGnUZf4,11301
+code_context_control-2.55.0.dist-info/licenses/LICENSE,sha256=l8Kh5QCNWNvR6kIt8L0BUZvc2LAFiHv2c-FnsGnUZf4,11301
 core/__init__.py,sha256=TSDCEcM4V7gcZVM3w2ykJaqEUch4Dkon-rivV17T73s,2501
 core/config.py,sha256=NUU1DuespWRotlJsv59CNnLiWTR4Bc7ysmD1UFA76RE,16429
 core/ide.py,sha256=V6VVMVsFdmmcsMyxikjQp7z9xa42CWiHKS-ya-MAcG4,6172
@@ -110,7 +110,7 @@ oracle/services/__init__.py,sha256=Nb4POd1_YIwLVYsGfr-DiK-iKTelkU0fh9m7wjeLQHA,2
 oracle/services/activity_reporter.py,sha256=ZAxNFyUy7QRP28anQLRbKEwm5SGG97KIQYFQDLjYqlM,11729
 oracle/services/api_auth.py,sha256=1PW3pG--1DJb_F6qMhP3gBTYHxxPE2bsHmVmIhC81Y8,3566
 oracle/services/c3_bridge.py,sha256=RqSw1tOoUDXA21fKDHmZ7s7qrIj3jiDYq8j8OvbxshA,17919
-oracle/services/chat_engine.py,sha256=y_1kQL4jvUw86R1lYWcvDGVyPk-YhG2Uj6Yj26bBrrM,66119
+oracle/services/chat_engine.py,sha256=zvjyFsXGwqRHsvggBwQ6L0hcOovQe0AKyOy2ZdOU0No,55974
 oracle/services/chat_store.py,sha256=mizKwDyFGESKh63V-XgyNd3jQVrN2JCQc-7u8z3_1F4,6252
 oracle/services/cross_memory.py,sha256=F8JeYkEFSwQL3iGS9KV1onaMSFj3opr6f3nCxwvznV0,5484
 oracle/services/federated_graph.py,sha256=I9FWedcht6-FU2hoIlMHlXyjpwrspKueIN-jEYek6vg,19947
@@ -152,7 +152,7 @@ services/benchmark_dashboard.py,sha256=iR-DnqnoKbqHMJ4d-ZkIvJBYfzwTa7r-jzO6j2BYD
 services/bitbucket_client.py,sha256=JByovvtVZ6F4NcU611KVuTgKlT1rIsX2A2VlBDfvRV8,17509
 services/bitbucket_credentials.py,sha256=2qLA9pQMol4y95y4DJMNBsBBPUsJQCKbLFo2iiCnfvI,7364
 services/circuit_breaker.py,sha256=ES6PpjL40gfDhtK88GeS6GFzsz5EOEEkZsB-DzX_tbw,3179
-services/claude_md.py,sha256=vI2at-7DEsnRXYcSaE88uNTxCSxzhy8M77AM20VlYRc,42643
+services/claude_md.py,sha256=-OwAv8cQRY8_i6tSsK5X-9rayZSJN_rrZMMjqJf3oEM,42728
 services/compressor.py,sha256=AK31TqHFpkOD_Lqbp9aEOkOx7zENUwpsQHQ9B2imEHo,33081
 services/context_snapshot.py,sha256=2f_bxY3xX4ZC653ncYno8YSeSTFSavwBjrorytHA0Ns,16879
 services/conversation_store.py,sha256=-E2H6f9pMSOHiBjsq7tFUjrFAwWYExf7LJkibi5MRMA,35650
@@ -189,9 +189,9 @@ services/retention.py,sha256=I2_RV233kWBBXox5rc_w-1h1aPua93o9huuPf-pJVuE,18629
 services/retrieval_broker.py,sha256=9X67VZ_6AkbAzopHuuMFKmP4CGZLnW576kjSKMenBnw,5261
 services/router.py,sha256=Cz10nx2fKTbaGn14mSBePWIDrw5rdcs_1JFYXeik084,15626
 services/runtime.py,sha256=b79gN0dFlzBO4rPaUMWier8FZFamMZlwIM3aywLmbB4,12840
-services/scanner.py,sha256=5rMwxAO8Qchz3-GtpZTNwCQDiJIyhAMSXdwNPmTaq-U,4701
+services/scanner.py,sha256=1wnsH6WAoarf4L0MskRb8CBfjaF0pPw6ZYDX_4y2q3A,5985
 services/session_benchmark.py,sha256=GX3H8OwKC0X9Kk5U-vfY6Y7qq9Qaz2HwadNA7mjO8RY,105047
-services/session_manager.py,sha256=qUo7ool6dDWXfVgFpokIRcWqkWh10OzMcp7aZTdmTHY,51632
+services/session_manager.py,sha256=cVsL45nfkAZ5P-elwLMBoesQ9QGwZsCl4ND3tQJXMMI,51838
 services/session_preloader.py,sha256=DsTAXMKVtrX9yu1sEFojYDi9-jkSAj1Ylt9JTy57Dow,9883
 services/subprojects.py,sha256=KNA-qGVPsd7Tg92Pt_kLWMLyER2YHmdQWO44sOelTIg,25123
 services/task_store.py,sha256=IHNeLipdyWtbWYu2-3ItIDeSDI9WoMKj6YwPPc1TgW0,46487
@@ -226,8 +226,8 @@ tui/screens/search_view.py,sha256=MMHjVdlk3HZSuDBSvq8IGrqv_Mh5Us6YqXQ80bcWSMk,19
 tui/screens/session_view.py,sha256=eZ1eDwHTvPOck1wCCviixtOaCxIkBT_95ytNNNriGNA,5991
 tui/screens/stats.py,sha256=p81PjzdaIv7hllb8f45-rlVe4lJZwSdIMqu7e86_u5s,6223
 tui/screens/ui_view.py,sha256=1QJCgLh2YfgWIpvzRG1KOGXYEaOYX6ojN61Azjf2oX0,2125
-code_context_control-2.54.0.dist-info/METADATA,sha256=jtQEMTmI5Z0UW8uxs6ImKZ8KKA9Fic3IrIgALMBz8zM,24759
-code_context_control-2.54.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-code_context_control-2.54.0.dist-info/entry_points.txt,sha256=7kX_WUsDCF2hbXzvbNyscyaBb9AeA-DJY5v_5hN0DlU,93
-code_context_control-2.54.0.dist-info/top_level.txt,sha256=wRt41zBybVF3qAiNXHz9BURbkKvUvfhmWWtKMhaw6eE,29
-code_context_control-2.54.0.dist-info/RECORD,,
+code_context_control-2.55.0.dist-info/METADATA,sha256=t426vjB6vV4mHLBpU55F_4GZtuKXvIRZ-yLYqTsVGc8,24759
+code_context_control-2.55.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+code_context_control-2.55.0.dist-info/entry_points.txt,sha256=7kX_WUsDCF2hbXzvbNyscyaBb9AeA-DJY5v_5hN0DlU,93
+code_context_control-2.55.0.dist-info/top_level.txt,sha256=wRt41zBybVF3qAiNXHz9BURbkKvUvfhmWWtKMhaw6eE,29
+code_context_control-2.55.0.dist-info/RECORD,,

oracle/services/chat_engine.py

@@ -3,7 +3,6 @@
 import concurrent.futures
 import json
 import queue
-import re
 import threading
 import time
 import urllib.error
@@ -31,102 +30,6 @@ from oracle.services.memory_writer import MemoryWriter
 from oracle.services.project_scanner import ProjectScanner
 from services.ollama_bridge import OllamaBridge
 
-# ── Tool definitions (embedded in system prompt) ──────────
-
-_TOOL_DEFS = """
-Available tools — call ONE at a time by outputting exactly:
-<tool_call>{"name": "tool_name", "args": {…}}</tool_call>
-
-After you see the result, continue your response using the data.
-Do NOT call a tool if you can answer from context or prior results.
-
-Tools:
-1. list_projects()
-   Returns all registered C3 projects with fact counts and paths.
-
-2. query_memory(project_path, query?, category?, limit=10)
-   Search or list memory facts from a specific project.
-   - project_path (required): full path to the project
-   - query (optional): keyword filter on fact text
-   - category (optional): filter by category
-   - limit: max results (default 10)
-
-3. search_facts(query, limit=20)
-   Search facts across ALL projects. Returns matches with project source.
-
-4. project_health(project_path)
-   Run a health check on a project's memory. Returns status, issues, stats.
-
-5. analyze_project(project_path)
-   Deep LLM-powered analysis of a project's memory patterns and themes.
-
-6. cross_insights(project_path?)
-   Get cross-project insights. If project_path given, filter to that project.
-
-7. suggest_action(project_path, action, fact_ids, reason)
-   Create a pending suggestion (merge_facts, archive_facts, or add_fact).
-   - action: "merge_facts" | "archive_facts" | "add_fact"
-   - fact_ids: list of fact IDs involved
-   - reason: explanation string
-
-8. read_graph(project_path)
-   Get memory graph statistics for a project (nodes, edges, types).
-
---- C3 Code Intelligence Tools (require project_path) ---
-
-9. c3_search(project_path, query, action="code", top_k=3, max_tokens=1200)
-   Code intelligence search within a project.
-   action: code|exact|files|semantic|transcript
-
-10. c3_read(project_path, file_path, symbols=null, lines=null)
-    Read file contents with optional symbol or line-range extraction.
-
-11. c3_edits(project_path, action="history", file="", limit=50, since="", tag="")
-    Query the edit ledger: history, versions, stats.
-
-12. c3_edits_cross(action="history", tag="", limit=20, scope="")
-    Query edit ledgers across ALL projects. No project_path needed.
-    scope: ""=all, "top"=top-level only, or a project name/path = it + its sub-projects.
-
-13. c3_memory_query(project_path, action="query", query="", category="", top_k=10)
-    Query project memory (read-only: recall, query, list, score, graph, trends).
-
-14. c3_compress(project_path, file_path, mode="map")
-    Token-efficient file summary. mode: map|dense_map|smart|diff|bug_scan
-
-15. c3_validate(project_path, file_path)
-    Syntax validation on a file.
-
-16. c3_status(project_path, view="health", detailed=false)
-    Project health/budget/sessions overview. view: budget|health|sessions
-
-17. c3_search_cross(query, action="code", top_k=3, scope="")
-    Search code across ALL projects. No project_path needed.
-    scope: ""=all, "top"=top-level only, or a project name/path = it + its sub-projects.
-
-18. delegate_task(agent_id, task, project_path="")
-    Delegate a specific sub-task to a specialized agent.
-    - agent_id: The ID of the active agent to use.
-    - task: A detailed prompt explaining what the agent needs to do.
-    - project_path: required when the agent's backend is codex/gemini/claude/auto
-      (CLI backends run inside a registered project's workspace, read-only).
-
-19. activity_report(date?, since?, until?, project_path?, narrate=false)
-    Cross-project daily activity digest: sessions, tool calls, edits, git
-    mutations, and token/cost across ALL projects (or one, via project_path).
-    Defaults to today (UTC). narrate=true adds a prose summary.
-
-20. c3_project(action="list", project="", ...)
-    Cross-project ops by registered project NAME or path. Read-only actions:
-    list|info|subprojects|search|read|compress|status|memory|impact|edits|validate.
-    Extra args mirror the underlying tool (query, file_path, mode, view,
-    mem_action, edits_action, top_k, limit, target).
-
-21. c3_artifacts(project_path, action="list", artifact="", version=0, against=0)
-    Agent-config artifact tracking (read-only): list|history|show|diff|status.
-    Version history for CLAUDE.md/settings/MCP configs/skills in a project.
-"""
-
 _SYSTEM_BASE = """You are Oracle, an AI assistant specializing in cross-project code intelligence and memory analysis.
 You have access to memory facts, project health data, cross-project insights,
 AND full C3 code intelligence (code search, file reading, edit history, validation)
@@ -148,23 +51,23 @@ _DEPTH_INSTRUCTIONS = {
     "deep": "\nProvide thorough, detailed analysis with examples, data, and recommendations. Use multiple tool calls to gather comprehensive data when needed.\n",
 }
 
+# Tools are declared via Ollama's tools= API, so the prompt carries only
+# behavioral guidance — no syntax, no catalog.
 _SYSTEM_RULES = """
 Important rules:
-- You can call multiple tools at once by outputting multiple `<tool_call>...</tool_call>` blocks.
-- Call tools in parallel when tasks are independent.
-- If the user's question can be answered from conversation context, do NOT call a tool.
+- Use the provided tools when the user asks about specific data you don't have in context; call independent tools in parallel in one turn.
+- Do NOT call a tool if the question can be answered from conversation context or prior results.
 - After receiving tool results, synthesize them into a clear, helpful answer.
+- Use list_projects first to discover project paths before calling project-specific tools.
 - Format your answers with markdown for readability.
 """
 
-# Native tool-calling mode: tools are declared via Ollama's tools= API, so the
-# prompt carries only behavioral guidance — no <tool_call> syntax, no catalog.
-_SYSTEM_RULES_NATIVE = """
+# Appended when the model rejected native tool calling: the round is rerun
+# without tools, and the prompt must not promise capabilities it lacks.
+_NO_TOOLS_RULES = """
 Important rules:
-- Use the provided tools when the user asks about specific data you don't have in context; call independent tools in parallel in one turn.
-- Do NOT call a tool if the question can be answered from conversation context or prior results.
-- After receiving tool results, synthesize them into a clear, helpful answer.
-- Use list_projects first to discover project paths before calling project-specific tools.
+- No tools are available in this session. Answer from conversation context only.
+- If the question requires live project data you do not have, say so plainly.
 - Format your answers with markdown for readability.
 """
 
@@ -181,31 +84,17 @@ COMMANDS = {
     "team":    {"args": "",                  "desc": "Show active agents and their specializations"},
 }
 
-_TOOL_CALL_RE = re.compile(r"<tool_call>\s*(\{.*?\})\s*</tool_call>", re.DOTALL)
 _MAX_TOOL_ROUNDS = 8
 # Rounds = LLM calls. One tool use needs 2 rounds (call + response synthesis).
 _DEPTH_MAX_ROUNDS = {"brief": 2, "normal": 4, "deep": 8}
 _MAX_HISTORY_MESSAGES = 40
 _MAX_TOOL_RESULT_CHARS = 3000
 _VISIBLE_RETRY_PROMPT = (
-    "Your previous response contained only hidden reasoning and no user-visible "
-    "assistant content. Now provide the visible response. If you need a tool, "
-    "output exactly one <tool_call>{...}</tool_call> block in assistant content; "
-    "otherwise answer the user directly."
-)
-_VISIBLE_RETRY_PROMPT_NATIVE = (
     "Your previous response contained only hidden reasoning and no user-visible "
     "assistant content. Now provide the visible response. If you need a tool, "
     "use a native tool call; otherwise answer the user directly."
 )
 
-_TC_OPEN = "<tool_call>"
-_TC_CLOSE = "</tool_call>"
-# If the pre-strip visible answer in round 0 is at least this many chars, we
-# treat any trailing <tool_call> as speculative and do NOT regenerate. Prevents
-# the "correct answer then wrong answer on next round" failure mode.
-_TRUST_ANSWER_MIN_CHARS = 120
-
 
 _NATIVE_TOOLS_CACHE: list[dict] | None = None
 
@@ -231,76 +120,36 @@ def _native_tool_defs() -> list[dict]:
     return _NATIVE_TOOLS_CACHE
 
 
-def _classify_no_tools(exc: Exception) -> tuple[bool, bool]:
-    """Classify a streaming error raised while native tools were attached.
+def _classify_stream_400(exc: Exception, tools_attached: bool,
+                         think_enabled: bool) -> tuple[bool, bool, bool]:
+    """Classify a streaming HTTP 400 into retriable capability downgrades.
 
-    Returns ``(fallback_to_legacy, negative_cache_model)``. Any HTTP 400
-    triggers fallback (retrying without tools is one cheap request); the
-    model's capability is negative-cached only when the server names tools as
-    the problem, so an unrelated 400 doesn't permanently demote the model.
+    Returns ``(drop_tools, drop_think, cache_no_tools)``. Ollama names the
+    offending capability in the error body ("does not support thinking" /
+    "... tools"). A 400 naming neither is still treated as a tools rejection
+    when tools were attached (retrying without them is one cheap request),
+    but is never negative-cached — so an unrelated 400 doesn't permanently
+    demote the model.
     """
     if not isinstance(exc, urllib.error.HTTPError) or exc.code != 400:
-        return False, False
+        return False, False, False
     try:
-        body = exc.read().decode("utf-8", "replace")
+        body = (exc.read().decode("utf-8", "replace") or "").lower()
     except Exception:
         body = ""
-    return True, "tool" in body.lower()
-
+    if think_enabled and "think" in body:
+        return False, True, False
+    if tools_attached:
+        return True, False, "tool" in body
+    return False, False, False
 
-class _ToolCallStripper:
-    """Streaming-friendly stripper for <tool_call>...</tool_call> blocks.
-
-    Buffers chunks so partial open/close tags that straddle chunk boundaries
-    are never leaked to the UI. feed() returns only visible (stripped) text;
-    flush() emits any trailing buffer that is not inside a tool_call.
-    """
 
-    def __init__(self) -> None:
-        self._buf = ""
-        self._in_call = False
-
-    def feed(self, chunk: str) -> str:
-        self._buf += chunk
-        out: list[str] = []
-        while True:
-            if self._in_call:
-                end = self._buf.find(_TC_CLOSE)
-                if end == -1:
-                    return "".join(out)
-                self._buf = self._buf[end + len(_TC_CLOSE):]
-                self._in_call = False
-                continue
-            start = self._buf.find(_TC_OPEN)
-            if start == -1:
-                hold = 0
-                for i in range(1, len(_TC_OPEN)):
-                    if self._buf.endswith(_TC_OPEN[:i]):
-                        hold = i
-                if hold:
-                    out.append(self._buf[:-hold])
-                    self._buf = self._buf[-hold:]
-                else:
-                    out.append(self._buf)
-                    self._buf = ""
-                return "".join(out)
-            out.append(self._buf[:start])
-            self._buf = self._buf[start + len(_TC_OPEN):]
-            self._in_call = True
-
-    def flush(self) -> str:
-        if self._in_call:
-            return ""
-        tail = self._buf
-        self._buf = ""
-        return tail
-
-
-def _build_system_prompt(state: dict, native: bool = False) -> str:
+def _build_system_prompt(state: dict, tools_enabled: bool = True) -> str:
     """Build system prompt dynamically based on conversation state.
 
-    ``native=True`` omits the <tool_call> catalog/syntax (tools are declared
-    via Ollama's native API instead), keeping only behavioral guidance.
+    Tools are declared via Ollama's native API; the prompt carries only
+    behavioral guidance. ``tools_enabled=False`` (model rejected native tool
+    calling) swaps in rules that promise no tool capabilities.
     """
     parts = [_SYSTEM_BASE]
 
@@ -326,11 +175,7 @@ def _build_system_prompt(state: dict, native: bool = False) -> str:
             "or 'my project', they mean one of the focused projects.\n"
         )
 
-    if native:
-        parts.append(_SYSTEM_RULES_NATIVE)
-    else:
-        parts.append(_TOOL_DEFS)
-        parts.append(_SYSTEM_RULES)
+    parts.append(_SYSTEM_RULES if tools_enabled else _NO_TOOLS_RULES)
     return "".join(parts)
 
 
@@ -364,21 +209,19 @@ class ChatEngine:
     # ── Shared streaming drain ────────────────────────────
 
     def _drain_stream(self, messages: list[dict], model: str,
-                      stripper: "_ToolCallStripper | None" = None,
                       tools: list[dict] | None = None, think: bool | None = True):
         """Stream one LLM round, yielding SSE event dicts as they arrive.
 
         The single streamer behind the main chat loop, the visible-response
         retry, and the delegate sub-agent loop. Returns (via StopIteration
-        value — use ``yield from``) a summary dict: ``text`` (raw, including
-        any <tool_call> markup in legacy mode), ``thinking``, ``tool_calls``
-        (native protocol), ``stats``, ``chunks``, ``visible_chars``.
-
-        In legacy mode pass a ``_ToolCallStripper`` so <tool_call> blocks are
-        withheld from the emitted text events; native mode emits text as-is
-        (the content channel is clean) and collects structured tool calls
-        without emitting SSE for them — the executor emits the canonical
-        ``tool_call`` event with its tool_id.
+        value — use ``yield from``) a summary dict: ``text``, ``thinking``,
+        ``tool_calls`` (native protocol), ``stats``, ``chunks``,
+        ``visible_chars``.
+
+        Text is emitted as-is (the content channel is clean under native
+        tool calling); structured tool calls are collected without emitting
+        SSE for them — the executor emits the canonical ``tool_call`` event
+        with its tool_id.
         """
         full_text = ""
         thinking_text = ""
@@ -402,15 +245,9 @@ class ChatEngine:
                 tool_calls.append(chunk)
             else:
                 full_text += chunk
-                visible = stripper.feed(chunk) if stripper is not None else chunk
-                if visible:
-                    visible_chars += len(visible)
-                    yield {"type": "text", "content": visible}
-        if stripper is not None:
-            tail = stripper.flush()
-            if tail:
-                visible_chars += len(tail)
-                yield {"type": "text", "content": tail}
+                if chunk:
+                    visible_chars += len(chunk)
+                    yield {"type": "text", "content": chunk}
         return {"text": full_text, "thinking": thinking_text,
                 "tool_calls": tool_calls, "stats": stats, "chunks": chunks,
                 "visible_chars": visible_chars}
@@ -454,15 +291,18 @@ class ChatEngine:
         # Save user message
         self.store.append_message(conv_id, {"role": "user", "content": user_message})
 
-        # Native tool-calling mode: capability probe returns True/False, or
-        # None (unknown) → attempt native and fall back on live rejection.
+        # Capability probe returns True/False, or None (unknown) → attempt
+        # native tools and rerun without them on live rejection. Thinking is
+        # likewise attempted and dropped on a live "does not support" 400.
         probe = self.bridge.supports_tools(use_model) if self.bridge else False
-        use_native = probe is not False
-        tools = _native_tool_defs() if use_native else None
+        tools_enabled = probe is not False
+        tools = _native_tool_defs() if tools_enabled else None
+        think_enabled = True
 
         # Build messages for LLM
         history = self.store.get_conversation(conv_id)
-        llm_messages = self._build_llm_messages(history, state, native=use_native)
+        llm_messages = self._build_llm_messages(history, state,
+                                                tools_enabled=tools_enabled)
         context_msgs = len(llm_messages) - 1  # exclude system prompt
         yield {"type": "status", "message": "Context ready", "detail": f"{context_msgs} messages in context"}
 
@@ -476,38 +316,43 @@ class ChatEngine:
                 yield {"type": "status", "message": f"Streaming from {use_model}", "detail": round_label or "Generating response"}
 
                 stream_start = time.time()
-                try:
-                    result = yield from self._drain_stream(
-                        llm_messages, use_model,
-                        stripper=None if use_native else _ToolCallStripper(),
-                        tools=tools,
-                    )
-                except Exception as e:
-                    fallback_ok, cache_neg = (
-                        _classify_no_tools(e) if (use_native and tools) else (False, False)
-                    )
-                    if not fallback_ok:
-                        yield {"type": "error", "message": f"LLM error: {e}"}
-                        break
-                    # Mid-turn fallback: the model rejected native tools —
-                    # demote to the legacy text protocol and rerun this round.
-                    if cache_neg and self.bridge:
-                        self.bridge.set_tools_support(use_model, False)
-                    use_native = False
-                    tools = None
-                    llm_messages[0] = {
-                        "role": "system",
-                        "content": _build_system_prompt(state, native=False),
-                    }
-                    yield {"type": "status", "message": "Falling back to text tool protocol",
-                           "detail": f"{use_model} rejected native tool calling"}
+                # Up to two capability downgrades (thinking, then tools) —
+                # each dropped at most once, so this cannot loop.
+                result = None
+                for _attempt in range(3):
                     try:
                         result = yield from self._drain_stream(
-                            llm_messages, use_model, stripper=_ToolCallStripper(),
+                            llm_messages, use_model, tools=tools,
+                            think=think_enabled,
                         )
-                    except Exception as e2:
-                        yield {"type": "error", "message": f"LLM error: {e2}"}
                         break
+                    except Exception as e:
+                        drop_tools, drop_think, cache_neg = _classify_stream_400(
+                            e, tools_attached=bool(tools),
+                            think_enabled=think_enabled)
+                        if drop_think:
+                            think_enabled = False
+                            yield {"type": "status",
+                                   "message": "Continuing without thinking",
+                                   "detail": f"{use_model} does not support thinking"}
+                            continue
+                        if drop_tools:
+                            if cache_neg and self.bridge:
+                                self.bridge.set_tools_support(use_model, False)
+                            tools_enabled = False
+                            tools = None
+                            llm_messages[0] = {
+                                "role": "system",
+                                "content": _build_system_prompt(state, tools_enabled=False),
+                            }
+                            yield {"type": "status",
+                                   "message": "Continuing without tools",
+                                   "detail": f"{use_model} rejected native tool calling"}
+                            continue
+                        yield {"type": "error", "message": f"LLM error: {e}"}
+                        break
+                if result is None:
+                    break
 
                 full_text = result["text"]
                 thinking_text = result["thinking"]
@@ -524,10 +369,8 @@ class ChatEngine:
                         "message": "Retrying visible response",
                         "detail": "Model returned thinking without assistant content",
                     }
-                    retry_prompt = (
-                        _VISIBLE_RETRY_PROMPT_NATIVE if use_native else _VISIBLE_RETRY_PROMPT
-                    )
-                    retry_messages = llm_messages + [{"role": "user", "content": retry_prompt}]
+                    retry_messages = llm_messages + [
+                        {"role": "user", "content": _VISIBLE_RETRY_PROMPT}]
                     try:
                         retry = yield from self._drain_stream(
                             retry_messages, use_model, tools=tools, think=False,
@@ -556,61 +399,30 @@ class ChatEngine:
                 total_tokens += chunk_count
                 yield {"type": "status", "message": "Response received", "detail": f"{chunk_count} chunks in {stream_ms}ms"}
 
-                # Determine tool calls for this round.
-                if use_native:
-                    # Structured calls from the native protocol; content is clean.
-                    valid_calls = [
-                        {"name": c.get("name", "unknown"), "args": c.get("arguments") or {}}
-                        for c in native_calls if c.get("name")
-                    ]
-                    visible_text = full_text.strip()
-                    final_text = visible_text
-                else:
-                    tool_matches = list(_TOOL_CALL_RE.finditer(full_text))
-                    visible_text = _TOOL_CALL_RE.sub("", full_text).strip()
-                    final_text = visible_text or full_text
-                    valid_calls = []
-                    for match in tool_matches:
-                        try:
-                            valid_calls.append(json.loads(match.group(1)))
-                        except json.JSONDecodeError:
-                            continue
+                # Structured calls from the native protocol; content is clean.
+                valid_calls = [
+                    {"name": c.get("name", "unknown"), "args": c.get("arguments") or {}}
+                    for c in native_calls if c.get("name")
+                ]
+                final_text = full_text.strip()
 
                 if not valid_calls:
                     # No tool call — final answer
                     round_messages.append({"role": "assistant", "content": final_text})
                     break
 
-                # Legacy-only heuristic: if the model already produced a
-                # substantive answer alongside speculative <tool_call> blocks,
-                # trust the answer and stop — regenerating with tool results
-                # usually corrupts it. Native mode needs no such guard: models
-                # emitting structured calls expect their results.
-                if not use_native and len(visible_text) >= _TRUST_ANSWER_MIN_CHARS:
-                    round_messages.append({"role": "assistant", "content": visible_text})
-                    yield {
-                        "type": "status",
-                        "message": "Answer finalized",
-                        "detail": "Speculative tool calls skipped — answer already provided",
-                    }
-                    break
-
-                # Record the assistant response before tool results (stripped so
-                # the next LLM round sees clean context without <tool_call> noise).
+                # Record the assistant response before tool results, and echo
+                # the structured calls back so the model can pair the
+                # role:tool results that follow.
                 round_messages.append({"role": "assistant", "content": final_text})
-                if use_native:
-                    # Echo the structured calls back so the model can pair the
-                    # role:tool results that follow.
-                    llm_messages.append({
-                        "role": "assistant",
-                        "content": full_text,
-                        "tool_calls": [
-                            {"function": {"name": c["name"], "arguments": c.get("args") or {}}}
-                            for c in valid_calls
-                        ],
-                    })
-                else:
-                    llm_messages.append({"role": "assistant", "content": final_text})
+                llm_messages.append({
+                    "role": "assistant",
+                    "content": full_text,
+                    "tool_calls": [
+                        {"function": {"name": c["name"], "arguments": c.get("args") or {}}}
+                        for c in valid_calls
+                    ],
+                })
 
                 # Execute all tools in parallel
                 tool_calls_count += len(valid_calls)
@@ -702,18 +514,11 @@ class ChatEngine:
                                 "tool_name": tool_name, "tool_id": tool_id,
                             })
 
-                            # Extend next LLM context: native protocol feeds a
-                            # role:tool message; legacy re-injects as user text.
-                            if use_native:
-                                llm_messages.append({
-                                    "role": "tool", "tool_name": tool_name,
-                                    "content": truncated,
-                                })
-                            else:
-                                llm_messages.append({
-                                    "role": "user",
-                                    "content": f"<tool_result name=\"{tool_name}\">\n{truncated}\n</tool_result>",
-                                })
+                            # Extend next LLM context with a role:tool message.
+                            llm_messages.append({
+                                "role": "tool", "tool_name": tool_name,
+                                "content": truncated,
+                            })
 
                     # Final drain after all tools complete
                     while True:
@@ -723,21 +528,6 @@ class ChatEngine:
                             break
                         yield ev
 
-                if not use_native:
-                    # Legacy models tend to restart their answer after inlined
-                    # tool results; the nudge counters that. Native mode must
-                    # NOT inject a user message between tool_calls and their
-                    # role:tool results — the protocol handles continuation.
-                    llm_messages.append({
-                        "role": "user",
-                        "content": (
-                            "The tool results above contain the data you requested. "
-                            "Now write your final answer to the user based on those results. "
-                            "Do NOT output any <tool_call> blocks. Do NOT restart or repeat "
-                            "your previous message — the user has already seen it. "
-                            "Write only the remaining, finalized answer."
-                        ),
-                    })
                 yield {"type": "status", "message": "Finalizing answer", "detail": f"After {len(valid_calls)} parallel results"}
             else:
                 # Exhausted rounds without a final answer — synthesize one
@@ -806,14 +596,16 @@ class ChatEngine:
     # ── LLM message building ─────────────────────────────
 
     def _build_llm_messages(self, history: list[dict], state: dict | None = None,
-                            native: bool = False) -> list[dict]:
+                            tools_enabled: bool = True) -> list[dict]:
         """Convert stored history to Ollama chat messages with sliding window.
 
         Historical tool results are re-injected as ``<tool_result>`` user
-        messages in BOTH modes: safe for all models, and avoids orphaned
-        ``role:tool`` messages (no paired tool_calls) on conversation reload.
+        messages — deliberately NOT ``role:tool``: on conversation reload
+        there is no paired ``tool_calls`` assistant message, and orphaned
+        role:tool entries confuse several models. This is history
+        serialization, not the retired legacy tool-call protocol.
         """
-        system_prompt = _build_system_prompt(state or {}, native=native)
+        system_prompt = _build_system_prompt(state or {}, tools_enabled=tools_enabled)
         messages = [{"role": "system", "content": system_prompt}]
 
         # Take last N messages, skip tool_call/tool_result (they were inlined)
@@ -1000,7 +792,15 @@ class ChatEngine:
         return {"ok": True, "command": "help", "message": "\n".join(lines)}
 
     def _cmd_tools(self) -> dict:
-        return {"ok": True, "command": "tools", "message": _TOOL_DEFS.strip()}
+        # Listed from TOOL_SPECS (single source of truth) — the legacy
+        # prompt catalog this used to echo was removed with the <tool_call>
+        # text protocol.
+        from oracle.services.tool_registry import TOOL_SPECS
+        lines = ["Available tools:"]
+        for spec in TOOL_SPECS:
+            desc = (spec.get("description") or "").strip().split("\n")[0]
+            lines.append(f"- **{spec['name']}** — {desc}")
+        return {"ok": True, "command": "tools", "message": "\n".join(lines)}
 
     def _cmd_team(self) -> dict:
         cfg = load_config()
@@ -1247,17 +1047,18 @@ class ChatEngine:
                                           project_path, _emit)
 
         model = agent.get("model") or self.bridge.model
-        # Sub-agents pick their tool protocol from their OWN model.
+        # Sub-agents probe their OWN model for native tool support.
         probe = self.bridge.supports_tools(model) if self.bridge else False
-        use_native = probe is not False
-        tools = _native_tool_defs() if use_native else None
+        tools_enabled = probe is not False
+        tools = _native_tool_defs() if tools_enabled else None
+        think_enabled = True
 
-        def _sys_prompt(native: bool) -> str:
-            rules = _SYSTEM_RULES_NATIVE if native else f"{_TOOL_DEFS}\n{_SYSTEM_RULES}"
+        def _sys_prompt(enabled: bool) -> str:
+            rules = _SYSTEM_RULES if enabled else _NO_TOOLS_RULES
             return f"{agent.get('system_prompt', '')}\n\n{rules}"
 
         llm_messages = [
-            {"role": "system", "content": _sys_prompt(use_native)},
+            {"role": "system", "content": _sys_prompt(tools_enabled)},
             {"role": "user", "content": task}
         ]
 
@@ -1272,7 +1073,8 @@ class ChatEngine:
         while rounds < max_rounds:
             rounds += 1
             _emit("agent_round", agent_id=agent_id, round=rounds)
-            gen = self._drain_stream(llm_messages, model, tools=tools)
+            gen = self._drain_stream(llm_messages, model, tools=tools,
+                                     think=think_enabled)
             result = None
             try:
                 while True:
@@ -1287,18 +1089,22 @@ class ChatEngine:
                         _emit("agent_thinking", content=ev["content"])
                     # stats chunks are ignored for sub-agents
             except Exception as e:
-                if use_native and tools:
-                    fallback_ok, cache_neg = _classify_no_tools(e)
-                    if fallback_ok:
-                        # Model rejected native tools — demote to the legacy
-                        # text protocol and rerun this round.
-                        if cache_neg and self.bridge:
-                            self.bridge.set_tools_support(model, False)
-                        use_native = False
-                        tools = None
-                        llm_messages[0] = {"role": "system", "content": _sys_prompt(False)}
-                        rounds -= 1
-                        continue
+                drop_tools, drop_think, cache_neg = _classify_stream_400(
+                    e, tools_attached=bool(tools), think_enabled=think_enabled)
+                if drop_think:
+                    think_enabled = False
+                    rounds -= 1
+                    continue
+                if drop_tools:
+                    # Model rejected native tools — rerun this round without
+                    # them (the agent answers from the prompt).
+                    if cache_neg and self.bridge:
+                        self.bridge.set_tools_support(model, False)
+                    tools_enabled = False
+                    tools = None
+                    llm_messages[0] = {"role": "system", "content": _sys_prompt(False)}
+                    rounds -= 1
+                    continue
                 _emit("agent_done", agent_id=agent_id, rounds=rounds, error=str(e))
                 return {"error": f"Agent '{agent_id}' encountered LLM error: {e}"}
 
@@ -1309,33 +1115,15 @@ class ChatEngine:
                 _emit("agent_done", agent_id=agent_id, rounds=rounds, error="empty_response")
                 return {"error": f"Agent '{agent_id}' returned empty response."}
 
-            if use_native:
-                if not native_calls:
-                    total_result_chars = len(full_text)
-                    dur_ms = (time.perf_counter_ns() - agent_start_ns) // 1_000_000
-                    _emit("agent_done", agent_id=agent_id, rounds=rounds,
-                          result_chars=total_result_chars, duration_ms=dur_ms)
-                    return {"agent": agent_id, "result": full_text}
-                # Sub-agents run one tool per round; take the first call.
-                first = native_calls[0]
-                call = {"name": first.get("name", "unknown"), "args": first.get("arguments") or {}}
-            else:
-                tool_match = _TOOL_CALL_RE.search(full_text)
-                if not tool_match:
-                    total_result_chars = len(full_text)
-                    dur_ms = (time.perf_counter_ns() - agent_start_ns) // 1_000_000
-                    _emit("agent_done", agent_id=agent_id, rounds=rounds,
-                          result_chars=total_result_chars, duration_ms=dur_ms)
-                    return {"agent": agent_id, "result": full_text}
-
-                try:
-                    call = json.loads(tool_match.group(1))
-                except json.JSONDecodeError:
-                    total_result_chars = len(full_text)
-                    dur_ms = (time.perf_counter_ns() - agent_start_ns) // 1_000_000
-                    _emit("agent_done", agent_id=agent_id, rounds=rounds,
-                          result_chars=total_result_chars, duration_ms=dur_ms)
-                    return {"agent": agent_id, "result": full_text}
+            if not native_calls:
+                total_result_chars = len(full_text)
+                dur_ms = (time.perf_counter_ns() - agent_start_ns) // 1_000_000
+                _emit("agent_done", agent_id=agent_id, rounds=rounds,
+                      result_chars=total_result_chars, duration_ms=dur_ms)
+                return {"agent": agent_id, "result": full_text}
+            # Sub-agents run one tool per round; take the first call.
+            first = native_calls[0]
+            call = {"name": first.get("name", "unknown"), "args": first.get("arguments") or {}}
 
             tool_name = call.get("name", "unknown")
             tool_args = call.get("args", {})
@@ -1358,18 +1146,11 @@ class ChatEngine:
             if len(result_str) > _MAX_TOOL_RESULT_CHARS:
                 truncated += "... (truncated)"
 
-            if use_native:
-                llm_messages.append({
-                    "role": "assistant", "content": full_text,
-                    "tool_calls": [{"function": {"name": tool_name, "arguments": tool_args}}],
-                })
-                llm_messages.append({"role": "tool", "tool_name": tool_name, "content": truncated})
-            else:
-                llm_messages.append({"role": "assistant", "content": full_text})
-                llm_messages.append({
-                    "role": "user",
-                    "content": f"<tool_result name=\"{tool_name}\">\n{truncated}\n</tool_result>\nContinue your response using this data."
-                })
+            llm_messages.append({
+                "role": "assistant", "content": full_text,
+                "tool_calls": [{"function": {"name": tool_name, "arguments": tool_args}}],
+            })
+            llm_messages.append({"role": "tool", "tool_name": tool_name, "content": truncated})
 
         dur_ms = (time.perf_counter_ns() - agent_start_ns) // 1_000_000
         _emit("agent_done", agent_id=agent_id, rounds=rounds,

services/claude_md.py

@@ -819,12 +819,13 @@ class ClaudeMdManager:
                 if dirname:
                     mentioned_dirs.add(dirname)
 
-        # Scan actual top-level dirs
-        skip = {'node_modules', '.git', '__pycache__', '.c3', 'venv',
-                'env', '.venv', 'dist', 'build', '.next', '.cache', '.claude'}
+        # Scan actual top-level dirs with the same pruning rules as the
+        # generator, so gitignored dirs are never reported as "new".
+        from services.scanner import make_dir_pruner
+        pruned = make_dir_pruner(self.project_path, extra_skip=('.claude',))
         actual_dirs = set()
         for item in self.project_path.iterdir():
-            if item.is_dir() and item.name not in skip and not item.name.startswith('.'):
+            if item.is_dir() and not pruned(item.name) and not item.name.startswith('.'):
                 actual_dirs.add(item.name)
 
         # Compare (use base names only)

services/scanner.py

@@ -11,6 +11,7 @@ os.walk with in-place dirnames pruning never descends into skipped
 directories, yields files in deterministic order, exits as soon as the
 caller stops consuming, and reports progress so long scans are visible.
 """
+import fnmatch
 import os
 from pathlib import Path
 from typing import Callable, Iterator, Optional, Set, Tuple
@@ -29,30 +30,60 @@ SKIP_DIRS = {
 }
 
 
-def gitignore_dir_names(root) -> set:
-    """Literal directory names from the root .gitignore (best-effort).
+def gitignore_dir_patterns(root) -> tuple:
+    """(literal_names, glob_patterns) for directory pruning from .gitignore.
 
-    Only unambiguous entries are used - a bare name or ``/name/`` with no
-    wildcard, negation, or nested separator - so pruning can never be
-    broader than the ignore file itself. Data/log directories are exactly
+    Single-segment entries only - a bare name, ``/name/``, or a simple glob
+    like ``*.egg-info/`` - never negations or nested paths, so pruning can
+    only be narrower than the ignore file itself. Both sets are matched
+    against directory basenames. Data/log/build directories are exactly
     what makes large-project scans hang, and they are almost always
-    plain-name entries.
+    single-segment entries.
     """
-    names = set()
+    names: set = set()
+    patterns: list = []
     try:
         text = (Path(root) / '.gitignore').read_text(errors='replace')
     except OSError:
-        return names
+        return names, patterns
     for line in text.splitlines():
         line = line.strip()
         if not line or line.startswith('#') or line.startswith('!'):
             continue
-        if any(ch in line for ch in '*?['):
-            continue
         cleaned = line.strip('/')
-        if cleaned and '/' not in cleaned and '\\' not in cleaned:
+        if not cleaned or '/' in cleaned or '\\' in cleaned:
+            continue
+        if any(ch in cleaned for ch in '*?['):
+            patterns.append(cleaned)
+        else:
             names.add(cleaned)
-    return names
+    return names, patterns
+
+
+def gitignore_dir_names(root) -> set:
+    """Literal directory names from the root .gitignore (best-effort)."""
+    return gitignore_dir_patterns(root)[0]
+
+
+def make_dir_pruner(root, extra_skip=(), respect_gitignore: bool = True):
+    """Predicate ``dirname -> bool`` (True = prune this directory).
+
+    Combines SKIP_DIRS, ``extra_skip``, and the root .gitignore (literal
+    names plus single-segment globs like ``*.egg-info/``). Shared by the
+    index scanners and the project-tree doc generator so every surface
+    agrees on what a distributable project looks like.
+    """
+    skip = set(SKIP_DIRS) | set(extra_skip)
+    patterns: list = []
+    if respect_gitignore:
+        names, patterns = gitignore_dir_patterns(root)
+        skip |= names
+
+    def pruned(dirname: str) -> bool:
+        return (dirname in skip
+                or any(fnmatch.fnmatch(dirname, p) for p in patterns))
+
+    return pruned
 
 
 def iter_files(
@@ -81,8 +112,10 @@ def iter_files(
     """
     root = Path(root)
     skip = set(SKIP_DIRS if skip_dirs is None else skip_dirs)
+    glob_skips: list = []
     if respect_gitignore:
-        skip |= gitignore_dir_names(root)
+        names, glob_skips = gitignore_dir_patterns(root)
+        skip |= names
 
     yielded = 0
     seen = 0
@@ -97,6 +130,8 @@ def iter_files(
         for d in sorted(dirnames):
             if d in skip:
                 continue
+            if glob_skips and any(fnmatch.fnmatch(d, p) for p in glob_skips):
+                continue
             if exclude_parts is not None and exclude_parts(rel_parts + (d,)):
                 continue
             kept.append(d)

services/session_manager.py

@@ -711,13 +711,18 @@ class SessionManager:
         return True
 
     def _scan_project_structure(self) -> str:
-        """Scan project and generate compressed structure."""
-        skip = {'node_modules', '.git', '__pycache__', '.c3', 'venv',
-                'env', '.venv', 'dist', 'build', '.next'}
+        """Scan project and generate compressed structure.
+
+        Prunes via the shared scanner rules (SKIP_DIRS + root .gitignore,
+        including simple globs like *.egg-info/), so the tree shipped in
+        instruction docs shows only what a clean distribution contains.
+        """
+        from services.scanner import make_dir_pruner
+        pruned = make_dir_pruner(self.project_path)
 
         structure = ["```"]
         for root, dirs, files in os.walk(self.project_path):
-            dirs[:] = sorted(d for d in dirs if d not in skip)
+            dirs[:] = sorted(d for d in dirs if not pruned(d))
             level = len(Path(root).relative_to(self.project_path).parts)
 
             indent = "  " * level