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

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

@@ -1,5 +1,25 @@
 # Changelog
 
+## [2.4.2] - 2026-10-13
+
+### 🤖 Sub-Agent Swarm Model Configuration & Hardcoded Lock
+- **Swarm Model Settings in `/model`**: Added a dedicated configuration section in the `/model` dialog allowing users to choose the model used across all swarm subagents.
+- **Strict User Lock**: When a specific model is selected, it is hardcoded—the main agent cannot override or change it, even if custom `model_id` parameters are passed to `invoke_subagents`.
+- **Dynamic Auto Mode**: Added a "Let the agent decide (Auto)" option allowing the main agent to dynamically assign models per task or fall back to its active model.
+
+### ⚡ Non-Interactive Command Execution (`--hard-skip-perms`)
+- **Hard Skip Permissions**: Added the `--hard-skip-perms` CLI flag, `UTIM_HARD_SKIP_PERMS=1` environment variable, and `/hard-skip-perms` slash command.
+- **Unrestricted Command Execution**: Automatically approves terminal commands without prompting for user confirmation, even for unsafe or destructive commands.
+
+### 🐛 Bug Fixes
+- **Premature Halting Fix**: Fixed an issue where the model abruptly stopped if it completed inspection tools and emitted an action promise without executing further mutation tools, now triggering an automatic continuation nudge.
+
+## [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.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: utim-cli
-Version: 2.4.0
+Version: 2.4.2
 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
@@ -22,6 +22,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests==2.31.0
 Requires-Dist: aiohttp>=3.9.5
+Requires-Dist: httpx>=0.25.0
 Requires-Dist: python-dotenv==1.0.1
 Requires-Dist: urllib3==1.26.18
 Requires-Dist: charset-normalizer==3.3.2

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "utim-cli"
-version = "2.4.0"
+version = "2.4.2"
 
 description = "UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal."
 readme = "README.md"
@@ -25,6 +25,7 @@ classifiers = [
 dependencies = [
     "requests==2.31.0",
     "aiohttp>=3.9.5",
+    "httpx>=0.25.0",
     "python-dotenv==1.0.1",
     "urllib3==1.26.18",
     "charset-normalizer==3.3.2",

{utim_cli-2.4.0 → utim_cli-2.4.2}/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.2"
 
 # 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.2}/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.2"
 
 
 import builtins, os, pathlib, urllib.parse, re

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

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

{utim_cli-2.4.0 → utim_cli-2.4.2}/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):
@@ -440,6 +454,15 @@ class ReActAgent:
                 "tool_calls": tool_calls,
             })
 
+            # Clear any stale vision images and videos from a previous iteration
+            try:
+                import utim_cli.tools as _tools_module
+                _tools_module._pending_vision_images.clear()
+                _tools_module._pending_vision_videos.clear()
+                _tools_module._active_model_id = self.model_id
+            except Exception:
+                pass
+
             # Execute each tool call
             for i, tc in enumerate(tool_calls):
                 result = self._execute_tool_call(tc)
@@ -451,6 +474,41 @@ class ReActAgent:
                     "tool_call_id": tc_id,
                     "content": result,
                 })
+
+            # Drain and inject vision images & native videos into conversation
+            try:
+                import utim_cli.tools as _tools_module
+                _vision_queue = getattr(_tools_module, "_pending_vision_images", [])
+                for _vimg in list(_vision_queue or []):
+                    self.messages.append({
+                        "role": "user",
+                        "content": [
+                            {"type": "text", "text": _vimg.get("group_header") or f"[{_vimg.get('meta', 'Image')}]"},
+                            {
+                                "type": "image_url",
+                                "image_url": {"url": f"data:{_vimg['mime']};base64,{_vimg['b64']}"},
+                            },
+                        ],
+                    })
+                if _vision_queue:
+                    _vision_queue.clear()
+
+                _video_queue = getattr(_tools_module, "_pending_vision_videos", [])
+                for _vent in list(_video_queue or []):
+                    self.messages.append({
+                        "role": "user",
+                        "content": [
+                            {"type": "text", "text": _vent.get("header") or f"[Video: {_vent.get('filepath', '')}]"},
+                            {
+                                "type": "video_url",
+                                "video_url": {"url": f"data:{_vent['mime']};base64,{_vent['b64']}"},
+                            },
+                        ],
+                    })
+                if _video_queue:
+                    _video_queue.clear()
+            except Exception:
+                pass
         else:
             self.console.print(f"\n[bold yellow]Agent paused after reaching maximum iterations ({max_iterations}).[/bold yellow]")
             self.console.print("[dim]You can type 'continue' to resume the task.[/dim]\n")

utim_cli-2.4.2/utim_cli/architecture_indexer.py

@@ -0,0 +1,269 @@
+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(abs_path)
+    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)
+
+    domain_links = ", ".join([
+        "[file:///{}]".format(str(arch_dir.absolute() / m).replace(chr(92), "/"))
+        for m in generated_mds
+    ])
+    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.",
+        "- **Available Domain Files**: " + domain_links
+    ]
+    (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)
+
+    component_bullets = "\n".join([
+        f"- {m}: [file:///{str(arch_dir.absolute() / m).replace(chr(92), '/')}]"
+        for m in generated_mds
+    ]) if generated_mds else "- None"
+
+    return (
+        f"✓ Architecture lock successfully generated at: {arch_dir}\n"
+        f"Identified stack: {', '.join(project_type) or 'Unknown'} | Indexed files: {len(inventory)}\n\n"
+        f"WHAT WAS PROVIDED:\n"
+        f"1. Structural Dependency Graph: `00_architecture_map.json` (all file nodes, module imports, and symbol definitions)\n"
+        f"2. Architecture Conventions: `conventions_summary.txt`\n"
+        f"3. Modular Component Blueprints ({len(generated_mds)} domain modules):\n{component_bullets}\n\n"
+        f"WHY THIS IS NEEDED & NEXT ACTION:\n"
+        f"- Zero-token structural grounding eliminates hallucinations and token-wasting blind repo exploration.\n"
+        f"- NEXT STEP: Use `read_file` on the relevant `component_<domain>.md` blueprint above matching your task to inspect exact function/class signatures and dependencies before reading or editing source code."
+    )
+

{utim_cli-2.4.0 → utim_cli-2.4.2}/utim_cli/ask_helper.py

@@ -5,7 +5,8 @@ A dedicated, lightweight helper miniagent sharing the core UTIM LLM execution ar
 Provides real-time project insight, chat explanation, and conversational companionship
 without interrupting the main agent's active execution loop.
 
-Uses 'openrouter/free' as the primary model (first fallback), then falls back through all registered free models from the server model_registry.
+Uses 'nvidia/nemotron-3.5-lightning:free' as the primary model (first fallback), then falls
+back through all registered free models from the server model_registry.
 Has access to exactly one tool: 'read_chat'.
 """
 
@@ -27,16 +28,16 @@ from rich import box
 
 from utim_cli.client_utils import get_free_models_fallback_chain
 
-# Primary helper model = 'openrouter/free' (cheapest free router), then falls
+# Primary helper model = 'nvidia/nemotron-3.5-lightning:free' (verified free model), then falls
 # back through the verified free models from the server DB registry.
 _HELPER_FALLBACK_CHAIN = get_free_models_fallback_chain()
-PRIMARY_HELPER_MODEL = _HELPER_FALLBACK_CHAIN[0] if _HELPER_FALLBACK_CHAIN else "openrouter/free"
+PRIMARY_HELPER_MODEL = _HELPER_FALLBACK_CHAIN[0] if _HELPER_FALLBACK_CHAIN else "nvidia/nemotron-3.5-lightning:free"
 
 
 
 HELPER_SYSTEM_PROMPT = """<identity>
 You are the UTIM Sidecar Assistant, an embedded technical companion running alongside the active UTIM CLI session.
-- Your identity is strictly the UTIM Sidecar Assistant. Never identify as ox-alpha, ChatGPT, Claude, Qwen, DeepSeek, or other base models.
+- Your identity is strictly the UTIM Sidecar Assistant. If asked what model you are running on, state your active model name accurately.
 </identity>
 
 Your mission is to provide real-time architectural insights, explain active agent operations, assess codebase states, and answer developer questions clearly and factually.

{utim_cli-2.4.0 → utim_cli-2.4.2}/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:
@@ -46,11 +47,83 @@ def initialize_utim() -> str:
             _sync_global_experience(api_key, os.getcwd())
     except Exception:
         pass
+
+    # 6. Pre-warm instant phrase voices in background
+    try:
+        from utim_cli.voice_instant import warm_instant_phrases
+        warm_instant_phrases(background=True)
+    except Exception:
+        pass
     
     db_path = UTIM_DIR / 'utim_local.db'
     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).