utim-cli 2.4.0__tar.gz → 2.4.1__tar.gz

{utim_cli-2.4.0 → utim_cli-2.4.1}/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [2.4.1] - 2026-09-18
+
+###  Bug Fixes
+- Fixed the `UnboundLocalError: rotator` crash when resolving failover providers.
+- Fixed an Admin UI bug that zeroed out free model upstream prices in the Model Pricing & Provisioning interface.
+
 ## [2.4.0] - 2026-09-14
 
 ### ✨ New Features & Enhancements

{utim_cli-2.4.0/utim_cli.egg-info → utim_cli-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: utim-cli
-Version: 2.4.0
+Version: 2.4.1
 Summary: UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal.
 License: Emend AI Proprietary EULA
 Project-URL: Homepage, https://utim.dev

{utim_cli-2.4.0 → utim_cli-2.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "utim-cli"
-version = "2.4.0"
+version = "2.4.1"
 
 description = "UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal."
 readme = "README.md"

{utim_cli-2.4.0 → utim_cli-2.4.1}/utim/__init__.py

@@ -14,7 +14,7 @@ Quickstart:
 try:
     from utim_cli._version import VERSION as __version__
 except ImportError:
-    __version__ = "2.4.0"
+    __version__ = "2.4.1"
 
 # Developer-friendly core classes (similar to `import genai` / `import openai`)
 from utim_cli.sdk.session import UtimSession as Session

{utim_cli-2.4.0 → utim_cli-2.4.1}/utim_cli/__init__.py

@@ -5,7 +5,7 @@ try:
     from utim_cli._version import VERSION as __version__
 except ImportError:
     # Fallback during first-install / editable-install edge cases
-    __version__ = "2.4.0"
+    __version__ = "2.4.1"
 
 
 import builtins, os, pathlib, urllib.parse, re

{utim_cli-2.4.0 → utim_cli-2.4.1}/utim_cli/_version.py

@@ -11,6 +11,6 @@
 # from here so every surface stays in sync automatically.
 # ─────────────────────────────────────────────────────────────────────────────
 
-VERSION = "2.4.0"
+VERSION = "2.4.1"
 
 

{utim_cli-2.4.0 → utim_cli-2.4.1}/utim_cli/agent.py

@@ -3,6 +3,7 @@ import json
 import sys
 import time
 from .tools import get_tools
+from .syntax_fix import attempt_syntax_repair
 from rich.console import Console
 from rich.live import Live
 from rich.spinner import Spinner
@@ -293,7 +294,20 @@ class ReActAgent:
             num_lines = math.ceil(getattr(self, "_last_running_indicator_len", 40) / max(1, width))
             for _ in range(num_lines):
                 self.console.print("\033[F\033[K", end="")
-            return f"Error executing {tool_name}: {str(e)}"
+
+            # Auto-repair: if the tool failed due to a syntax error in the
+            # generated code, attempt an "on the go" syntax fix before
+            # reporting the error.
+            error_msg = str(e)
+            repaired = None
+            try:
+                repaired = attempt_syntax_repair(error_msg, self.console)
+            except Exception:
+                repaired = None
+            if repaired:
+                return repaired
+
+            return f"Error executing {tool_name}: {error_msg}"
 
 
     def run(self, max_iterations: int = 500, show_tools: bool = True):

utim_cli-2.4.1/utim_cli/architecture_indexer.py

@@ -0,0 +1,251 @@
+import os
+import re
+import json
+import hashlib
+from pathlib import Path
+import ast
+
+def get_project_hash(project_path: str) -> str:
+    return hashlib.sha256(os.path.abspath(project_path).encode('utf-8')).hexdigest()[:12]
+
+def _ignore_dir(dname: str) -> bool:
+    ignored = {'.git', 'node_modules', 'venv', '.venv', '__pycache__', 'dist', 'build', '.next', '.utim'}
+    return dname in ignored
+
+def index_python_file(filepath: Path) -> dict:
+    try:
+        content = filepath.read_text(encoding='utf-8', errors='ignore')
+        tree = ast.parse(content)
+        imports = []
+        symbols = []
+        lines = content.split('\n')
+        
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names: imports.append(alias.name)
+            elif isinstance(node, ast.ImportFrom):
+                if node.module: imports.append(node.module)
+            elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                docstring = ast.get_docstring(node)
+                args = [a.arg for a in node.args.args]
+                sig = f"({', '.join(args)})"
+                start = max(0, node.lineno - 1)
+                end = min(len(lines), start + 6)
+                snippet = "\n".join(lines[start:end])
+                if len(lines) > end: snippet += "\n    # ..."
+                symbols.append({"type": "function", "name": node.name, "line": node.lineno, "docstring": docstring, "signature": sig, "snippet": snippet})
+            elif isinstance(node, ast.ClassDef):
+                docstring = ast.get_docstring(node)
+                start = max(0, node.lineno - 1)
+                end = min(len(lines), start + 5)
+                snippet = "\n".join(lines[start:end])
+                if len(lines) > end: snippet += "\n    # ..."
+                symbols.append({"type": "class", "name": node.name, "line": node.lineno, "docstring": docstring, "snippet": snippet})
+        return {"imports": list(set(imports)), "symbols": symbols}
+    except Exception:
+        return {"imports": [], "symbols": []}
+
+def index_js_ts_file(filepath: Path) -> dict:
+    try:
+        content = filepath.read_text(encoding='utf-8', errors='ignore')
+        imports = re.findall(r'import\s+.*?from\s+[\'"](.*?)[\'"]', content)
+        symbols = []
+        lines = content.split('\n')
+        for i, line in enumerate(lines):
+            match = re.search(r'(?:export\s+)?(?:const|let|var|function|class)\s+([a-zA-Z0-9_]+)', line)
+            if match:
+                name = match.group(1)
+                snippet = "\n".join(lines[i:min(len(lines), i+6)])
+                if len(lines) > i+6: snippet += "\n    // ..."
+                symbols.append({"type": "export", "name": name, "line": i+1, "snippet": snippet, "signature": ""})
+        return {"imports": list(set(imports)), "symbols": symbols}
+    except Exception:
+        return {"imports": [], "symbols": []}
+
+def index_generic_file(filepath: Path) -> dict:
+    try:
+        content = filepath.read_text(encoding='utf-8', errors='ignore')
+        symbols = []
+        lines = content.split('\n')
+        for i, line in enumerate(lines):
+            s_line = line.strip()
+            name = None
+            
+            # 1. Standard OOP / Procedural / DevOps / Smart Contracts
+            m1 = re.search(r'^(?:public |private |protected |export |func |fn |class |struct |interface |def |sub |function |contract |resource |module )\s*([a-zA-Z0-9_]+)\s*(?:\{|\(|:|"|\')', s_line)
+            # 2. SQL Data Definition
+            m2 = re.search(r'^CREATE\s+(?:TABLE|PROCEDURE|VIEW|FUNCTION|TRIGGER)\s+([a-zA-Z0-9_]+)', s_line, re.IGNORECASE)
+            # 3. Bash / Shell scripts
+            m3 = re.search(r'^([a-zA-Z0-9_]+)\s*\(\)\s*\{', s_line)
+            # 4. Lisp / Clojure / Scheme
+            m4 = re.search(r'^\(\s*def[a-zA-Z0-9_]*\s+([a-zA-Z0-9_\-]+)', s_line)
+
+            if m1: name = m1.group(1)
+            elif m2: name = m2.group(1)
+            elif m3: name = m3.group(1)
+            elif m4: name = m4.group(1)
+
+            if name and len(name) > 2 and name not in ("if", "for", "while", "switch", "catch", "return", "else", "elif"):
+                snippet = "\n".join(lines[i:min(len(lines), i+6)])
+                if len(lines) > i+6: snippet += "\n    // ..."
+                symbols.append({"type": "symbol", "name": name, "line": i+1, "snippet": snippet, "signature": ""})
+        return {"imports": [], "symbols": symbols}
+    except Exception:
+        return {"imports": [], "symbols": []}
+
+def architecture_lock(project_path: str = ".") -> str:
+    import uuid
+    from utim_cli.brain import get_current_resolved_project
+    abs_path = os.path.abspath(project_path)
+    if not os.path.isdir(abs_path):
+        return f"Error: Project path '{abs_path}' does not exist or is not a directory."
+
+    proj_id, proj_dir = get_current_resolved_project()
+    arch_hash = uuid.uuid4().hex[:8]
+    arch_dir = proj_dir / f"arch_{arch_hash}"
+    arch_dir.mkdir(parents=True, exist_ok=True)
+    brain_file = arch_dir / "00_architecture_map.json"
+
+    inventory = []
+    project_type = []
+    
+    # Generic stack identification heuristics
+    if (Path(abs_path) / "package.json").exists(): project_type.append("Node.js")
+    if (Path(abs_path) / "requirements.txt").exists() or (Path(abs_path) / "pyproject.toml").exists(): project_type.append("Python")
+    if (Path(abs_path) / "go.mod").exists(): project_type.append("Go")
+    if (Path(abs_path) / "Cargo.toml").exists(): project_type.append("Rust")
+    if (Path(abs_path) / "composer.json").exists(): project_type.append("PHP")
+    if (Path(abs_path) / "Gemfile").exists(): project_type.append("Ruby")
+    
+    # Known binaries to skip indexing completely
+    BINARY_EXTS = {
+        ".png", ".jpg", ".jpeg", ".gif", ".ico", ".svg", ".mp4", ".mp3", ".wav",
+        ".zip", ".tar", ".gz", ".rar", ".7z", ".exe", ".dll", ".so", ".dylib",
+        ".bin", ".dat", ".db", ".sqlite", ".pyc", ".class", ".o", ".a", ".lib",
+        ".pdf", ".doc", ".docx", ".xls", ".xlsx"
+    }
+
+    for root, dirs, files in os.walk(abs_path):
+        dirs[:] = [d for d in dirs if not _ignore_dir(d)]
+        for f in files:
+            if f.startswith('.'): continue
+            fpath = Path(root) / f
+            rel_path = str(fpath.relative_to(abs_path)).replace('\\', '/')
+            
+            file_data = {
+                "file": rel_path,
+                "size": fpath.stat().st_size if fpath.exists() else 0,
+                "extension": fpath.suffix,
+                "relationships": []
+            }
+            
+            # Universal Language Routing
+            if fpath.suffix == ".py":
+                data = index_python_file(fpath)
+            elif fpath.suffix in (".js", ".ts", ".jsx", ".tsx", ".mjs", ".cjs"):
+                data = index_js_ts_file(fpath)
+            elif fpath.suffix.lower() not in BINARY_EXTS:
+                data = index_generic_file(fpath)
+            else:
+                data = {"imports": [], "symbols": []}
+                
+            file_data["imports"] = data["imports"]
+            file_data["symbols"] = data["symbols"]
+            inventory.append(file_data)
+
+    nodes = []
+    edges = []
+    nodes.append({"id": "PROJECT_ROOT", "type": "project", "path": abs_path})
+
+    def get_cluster_name(file_path: str) -> str:
+        parts = file_path.replace('\\', '/').split('/')
+        ignore_dirs = {'src', 'lib', 'app', 'main', 'bin', 'scripts', 'tests', 'test', 'public', 'assets', 'static', 'dist', 'build'}
+        
+        # 1. Find the most meaningful parent directory
+        for part in reversed(parts[:-1]):
+            clean_part = part.lower().strip()
+            if clean_part and clean_part not in ignore_dirs:
+                return clean_part
+        
+        # 2. Fallback to filename if it's unique
+        filename = parts[-1].split('.')[0].lower()
+        if filename not in {'index', 'main', 'app', 'core'}:
+            return filename
+            
+        return "core"
+
+    clusters = {}
+
+    for item in inventory:
+        file_id = item["file"]
+        nodes.append({"id": file_id, "type": "file", "extension": item.get("extension"), "size": item.get("size")})
+        edges.append({"source": "PROJECT_ROOT", "target": file_id, "relation": "contains"})
+        
+        for imp in item.get("imports", []):
+            nodes.append({"id": imp, "type": "module"})
+            edges.append({"source": file_id, "target": imp, "relation": "imports"})
+            
+        cluster_name = get_cluster_name(file_id)
+        if cluster_name not in clusters:
+            clusters[cluster_name] = []
+            
+        try:
+            content = (Path(abs_path) / file_id).read_text(encoding='utf-8', errors='ignore')
+            content_lower = content.lower()
+            file_lower = file_id.lower()
+            if "if __name__ ==" in content or "int main(" in content or "func main(" in content or "app.listen" in content_lower:
+                clusters[cluster_name].append(f"### File: `{file_id}` (Entrypoint/Server)\n*This file contains application startup or core routing.*\n")
+        except:
+            pass
+
+        for sym in item.get("symbols", []):
+            sym_id = f"{file_id}::{sym['name']}"
+            nodes.append({"id": sym_id, "type": sym["type"], "name": sym["name"], "line": sym.get("line")})
+            edges.append({"source": file_id, "target": sym_id, "relation": "defines"})
+
+            name = sym.get("name", "")
+            doc = sym.get("docstring") or ""
+            snippet = sym.get("snippet") or ""
+            sig = sym.get("signature", "")
+            
+            md_block = f"### `{name}{sig}` in `{file_id}`\n"
+            if doc: md_block += f"**Docstring:** {doc}\n"
+            md_block += f"```text\n{snippet}\n```\n"
+            clusters[cluster_name].append(md_block)
+
+    # Dynamically generate markdown files based on organic clusters
+    generated_mds = []
+    for cname, blocks in clusters.items():
+        if not blocks: continue
+        safe_cname = re.sub(r'[^a-z0-9_]', '_', cname)
+        md_content = f"# 🧩 Architecture Component: {cname.title()}\n\n" + "\n".join(blocks)
+        md_filename = f"component_{safe_cname}.md"
+        (arch_dir / md_filename).write_text(md_content, encoding="utf-8")
+        generated_mds.append(md_filename)
+
+    conventions = [
+        "## Innate Project Architecture Rules",
+        "- **Organic Component Isolation**: The project is structured organically. Do not bloat central routers or core files.",
+        "- **Multifile Designs**: When adding large new features, ALWAYS create new standalone component files based on the existing directory structure.",
+        "- **MANDATORY ARCHITECTURE REVIEW**: You MUST use `read_file` on the relevant domain files below BEFORE exploring the source code manually. They contain the exact structural blueprints you need.",
+        f"- **Available Domain Files**: {', '.join([f'[file:///{str(arch_dir.absolute() / m).replace(chr(92), "/")}]' for m in generated_mds])}"
+    ]
+    (arch_dir / "conventions_summary.txt").write_text("\n".join(conventions), encoding="utf-8")
+
+    unique_nodes = {n["id"]: n for n in nodes}.values()
+
+    graph_data = {
+        "project_path": abs_path,
+        "project_type": project_type,
+        "total_files": len(inventory),
+        "nodes": list(unique_nodes),
+        "edges": edges,
+        "capabilities": ["Project orientation", "Graph traversal", "Symbol resolution"]
+    }
+    
+    with open(brain_file, 'w', encoding='utf-8') as bf:
+        json.dump(graph_data, bf, indent=2)
+
+    return (f"Architecture lock successfully generated at: {arch_dir}\n"
+            f"Generated 00_architecture_map.json and detailed Markdown component files.\n"
+            f"Indexed {len(inventory)} files. Identified stack: {', '.join(project_type) or 'Unknown'}.")

{utim_cli-2.4.0 → utim_cli-2.4.1}/utim_cli/bootstrap.py

@@ -37,6 +37,7 @@ def initialize_utim() -> str:
     
     # 4. Auto-create skills directory and default skills/rules
     _write_skills_and_agents()
+    _scaffold_local_ui_skill()
     
     # 5. Sync global/local experience database across project folders
     try:
@@ -51,6 +52,71 @@ def initialize_utim() -> str:
     return str(db_path)
 
 
+def _scaffold_local_ui_skill():
+    """Auto-generate UI design guide in the local workspace if .agents exists or it looks like a project."""
+    import os
+    from pathlib import Path
+    
+    # Only scaffold if we are in a project directory or .agents already exists
+    if not (Path('.git').exists() or Path('.agents').exists() or Path('package.json').exists() or Path('requirements.txt').exists()):
+        return
+        
+    try:
+        skill_dir = Path('.agents/skills/Ui design Guide')
+        skill_dir.mkdir(parents=True, exist_ok=True)
+        skill_md = skill_dir / 'SKILL.md'
+        
+        if not skill_md.exists():
+            skill_content = """---
+name: Ui design Guide
+description: Directives and best practices for creating beautiful, modern, and highly polished web interfaces.
+---
+
+# UI Design Guide
+
+When the user asks you to generate something related to design, build a website, or perform a UI overhaul, you MUST apply these modern UI/UX principles to ensure the result is professional, beautiful, and highly polished. Do not settle for default browser styles.
+
+## 1. Typography
+- **Fonts**: Use modern, clean sans-serif fonts (e.g., Inter, Roboto, San Francisco, or system-ui).
+- **Hierarchy**: Clearly distinguish between headings (H1, H2) and body text using font weights (e.g., bold headers, regular body) and sizes.
+- **Readability**: Keep body text line-height around `1.5` to `1.6`. Use slightly muted colors for body text (e.g., `#4b5563` on light themes or `#a1a1aa` on dark themes) rather than stark black or pure white.
+
+## 2. Layout & Whitespace (Negative Space)
+- **Breathing Room**: Be generous with padding and margins. Do not cram elements together.
+- **Alignment**: Use CSS Flexbox or Grid for perfect alignment. Center things deliberately.
+- **Constraints**: Limit the maximum width of text containers (e.g., `max-w-3xl`) so lines don't stretch too far across wide screens.
+
+## 3. Colors & Theme
+- **Backgrounds**: Use soft, off-white (e.g., `#f9fafb`) or rich dark (e.g., `#0f172a`) background colors instead of pure `#ffffff` or `#000000`.
+- **Accents**: Pick a primary brand color (e.g., a vibrant blue or purple) and use it sparingly for primary buttons, active states, and important links.
+- **Gradients & Glassmorphism**: Where appropriate, use subtle background gradients or translucent frosted-glass effects (e.g., `backdrop-filter: blur(10px); background: rgba(255, 255, 255, 0.1);`).
+
+## 4. Components & Shapes
+- **Corners**: Use consistent `border-radius` (e.g., `8px` or `12px` for cards/buttons, full pill-shapes for badges).
+- **Shadows**: Add soft, diffuse box-shadows to cards and dropdowns to create depth and elevation. Avoid harsh, dark shadows (e.g., use `box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1)`).
+- **Borders**: If using borders, make them very subtle (e.g., `1px solid rgba(255,255,255,0.1)` or `#e5e7eb`).
+
+## 5. Micro-Interactions & States
+- **Transitions**: Apply `transition: all 0.2s ease;` to buttons, links, and interactive elements.
+- **Hover/Active**: Always provide visual feedback when an element is hovered (e.g., slightly lighten/darken the background, or lift the element up by 2px) or clicked.
+- **Focus**: Remove default browser outlines and replace them with custom, aesthetic focus rings.
+
+## 6. Responsiveness
+- Ensure all designs are mobile-friendly first.
+- Use responsive units or media queries to collapse grids into single columns on smaller screens.
+- Ensure tap targets (buttons, links) are at least `44px` tall on mobile devices.
+
+## Directives
+- **Never use raw unstyled HTML** for a final output unless explicitly requested.
+- **Use modern CSS frameworks** (like Tailwind CSS) if permitted by the project, or write clean, well-structured vanilla CSS using CSS Variables for theming.
+- **Review your design**: Before finalizing the code, ask yourself: "Does this look like a premium modern SaaS product or a 1990s web page?" Adjust accordingly.
+"""
+            skill_md.write_text(skill_content, encoding='utf-8')
+                
+    except Exception:
+        pass
+
+
 def _sync_global_experience(api_key: str, current_folder: str):
     """
     Track which project folder the user is currently in (server-side record only).

{utim_cli-2.4.0 → utim_cli-2.4.1}/utim_cli/brain.py

@@ -104,7 +104,9 @@ def _brain_db_path() -> str:
 def _project_id(workspace_path: Optional[str] = None) -> str:
     """Stable short hex ID for the current workspace directory."""
     cwd = workspace_path or os.getcwd()
-    return "proj_" + hashlib.sha1(cwd.encode()).hexdigest()[:10]
+    # Normalize path to ensure the same directory always yields the same hash
+    normalized = os.path.normcase(os.path.normpath(os.path.abspath(cwd)))
+    return "proj_" + hashlib.sha1(normalized.encode('utf-8')).hexdigest()[:10]
 
 def _project_dir(project_id: str) -> Path:
     d = _brain_root() / "projects" / project_id
@@ -904,6 +906,16 @@ def reason_over_memories(user_prompt: str, memories: List[Dict]) -> str:
 
 # ── Context Injection Helper (called by orchestrator) ─────────────────────────
 
+_CURRENT_RESOLVED_PROJ_ID = None
+
+def get_current_resolved_project() -> Tuple[str, Path]:
+    """Return the globally resolved project id and path from the last system prompt injection, or fallback to current workspace."""
+    global _CURRENT_RESOLVED_PROJ_ID
+    if _CURRENT_RESOLVED_PROJ_ID:
+        return _CURRENT_RESOLVED_PROJ_ID, _project_dir(_CURRENT_RESOLVED_PROJ_ID)
+    pid = _project_id()
+    return pid, _project_dir(pid)
+
 def find_most_relevant_brain_project(query: str = "") -> Tuple[str, Path]:
     """
     Find the most relevant brain project folder using local MiniLM vector search.
@@ -911,16 +923,19 @@ def find_most_relevant_brain_project(query: str = "") -> Tuple[str, Path]:
     embeddings table for the project with the highest similarity score.
     Falls back to the current workspace project directory.
     """
+    global _CURRENT_RESOLVED_PROJ_ID
     current_pid = _project_id()
     current_dir = _project_dir(current_pid)
 
     if not query or not query.strip():
+        _CURRENT_RESOLVED_PROJ_ID = current_pid
         return current_pid, current_dir
 
     try:
         brain_root = _brain_root()
         projects_dir = brain_root / "projects"
         if not projects_dir.exists():
+            _CURRENT_RESOLVED_PROJ_ID = current_pid
             return current_pid, current_dir
 
         # Run MiniLM embedding search against brain_embeddings to score projects
@@ -931,10 +946,12 @@ def find_most_relevant_brain_project(query: str = "") -> Tuple[str, Path]:
         conn.close()
 
         if not rows:
+            _CURRENT_RESOLVED_PROJ_ID = current_pid
             return current_pid, current_dir
 
         q_vecs = _embed([query.strip()])
         if not q_vecs:
+            _CURRENT_RESOLVED_PROJ_ID = current_pid
             return current_pid, current_dir
 
         q_vec = q_vecs[0]
@@ -958,11 +975,13 @@ def find_most_relevant_brain_project(query: str = "") -> Tuple[str, Path]:
             best_pid = max(project_scores.items(), key=lambda x: x[1])[0]
             best_dir = _project_dir(best_pid)
             if best_dir.exists():
+                _CURRENT_RESOLVED_PROJ_ID = best_pid
                 return best_pid, best_dir
 
     except Exception:
         pass
 
+    _CURRENT_RESOLVED_PROJ_ID = current_pid
     return current_pid, current_dir
 
 
@@ -986,11 +1005,23 @@ def get_brain_context_prompt(user_prompt: str = "") -> str:
         proj_url = str(proj_dir.absolute()).replace("\\", "/")
         root_url = str(brain_root.absolute()).replace("\\", "/")
 
+        conventions = ""
+        # Find the most recent architecture snapshot and inject conventions
+        try:
+            arch_dirs = sorted(proj_dir.glob("arch_*"), key=os.path.getmtime, reverse=True)
+            if arch_dirs:
+                conv_file = arch_dirs[0] / "conventions_summary.txt"
+                if conv_file.exists():
+                    conventions = f"\n\n### PROJECT CONVENTIONS ###\n{conv_file.read_text(encoding='utf-8')}\n"
+        except Exception:
+            pass
+
         return (
             f"\n\n### BRAIN MEMORY DIRECTORY ###\n"
             f"Project brain directory: [brain](file:///{proj_url})\n"
             f"Global brain directory: [global_brain](file:///{root_url})\n"
-            f"Note: The paths above are directories. To explore historical project memories, architecture snapshots, or conventions, call `list_directory('{proj_url}')` and `read_file` on the memory files inside it.\n"
+            f"Note: If you need to know about the project, check the brain files in the directory above - you will get exactly what you need. If something is missing, you can freely check the actual source code files.\n"
+            f"{conventions}"
         )
     except Exception:
         return ""