utim-cli 1.44.0__tar.gz → 1.44.1__tar.gz

utim_cli-1.44.1/CHANGELOG.md

@@ -0,0 +1,29 @@
+# Changelog
+
+All notable changes to the UTIM CLI Agent will be documented in this file.
+
+## [1.43.20] - 2026-07-01
+
+### Added
+- **Local-Global Experience Vector DB Sync**: UTIM now carries the ChromaDB experience database across project folders automatically. On startup, the previous project's `experiences.json`, `vector_db`, and vector metadata files are copied to the current folder — deleted from the old folder only after a successful paste. Last active folder is persisted server-side so the sync survives PC restarts.
+- **BYOK Provider Disconnection (key `x`)**: Press `x` in the model selector to view a list of connected custom providers and disconnect them. All associated models are removed from the model list instantly.
+- **Bring Your Own Key (BYOK) for Free Users**: Free-tier users can now connect any OpenAI-compatible provider using their own API key. BYOK models bypass UTIM quota limits and plan gating entirely.
+- **Dynamic Changelog & Version API**: `/api/changelog` parses `CHANGELOG.md` at request time and returns structured JSON. `/health` version field is also derived from `CHANGELOG.md` dynamically — deploying a new changelog auto-updates both the website changelog page and version badge.
+- **Changelog Tab on Website**: The terminal website now includes a `↻ Changelog` tab that fetches live release notes from the Railway server on load.
+- **Features Page Redesign**: The Features tab now displays a 9-card animated grid with per-feature glow icons, numbered labels, colored tags, and spring entrance animations — matching the full terminal aesthetic of the site.
+- **Last Project Folder Persistence**: Server stores each user's last active project directory in the database. Survives PC restarts and is used to drive the cross-folder experience DB sync.
+- **`GET /api/auth/last-folder` and `POST /api/auth/last-folder` Endpoints**: New authenticated REST endpoints to read/write a user's last active project folder path.
+
+### Changed
+- **Plan Upgrade Credit Transition**: Free plan credit allowance ($1.00) is zeroed out instead of rolling over to the new paid plan's quota bank on upgrade.
+- **Hobby Plan Model Access**: Hobby plan `allowed_models` corrected to `"all"` so users can access the full model registry (not just free-tier models).
+- **BYOK Model Gating Bypass**: Orchestrator pre-flight checks now skip plan gating and UTIM credit checks for custom BYOK models since they use user-owned keys.
+- **Pricing Page Claims Cleaned**: Removed unsubstantiated marketing claims (`Dedicated elite endpoints`, `Autonomous team agents access`, `High-speed dedicated endpoints`, `All premium models (GPT-4o, Claude)`, `Synthetic Eye & VSIX tools`, `Claude Sonnet 4.6 (1 RPM)`, `10-session history storage`) from all pricing tier feature lists.
+
+### Fixed
+- **BYOK Flow Display Bug**: Rewrote Add/Delete/BYOK-import dialogs to run on `sys.__stdout__` with `prompt_toolkit.prompt()` so they are never swallowed by the alt-screen buffer.
+- **Double-Exit Crash (TUI)**: Wrapped all keyboard exit callbacks (`ENTER`/`ESC`/`q`/`CTRL+C`) in `try...except` blocks to prevent double-fire tracebacks.
+- **`/changelog` Route No Longer Shows Legacy Page**: All website routes (including `/changelog`) now correctly map to the `<PowershellUI />` terminal component. Legacy standalone page removed.
+
+---
+

{utim_cli-1.44.0/utim_cli.egg-info → utim_cli-1.44.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: utim-cli
-Version: 1.44.0
+Version: 1.44.1
 Summary: UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal.
 License: MIT
 Project-URL: Homepage, https://utim.dev

{utim_cli-1.44.0 → utim_cli-1.44.1}/pyproject.toml

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

{utim_cli-1.44.0 → utim_cli-1.44.1}/utim_cli/backup.py

@@ -4,27 +4,9 @@ import json
 import sqlite3
 from utim_cli.logger import log_info, log_error, log_warning
 
-def _utim_dir() -> str:
-    """Return the absolute path to the project-local .utim directory."""
-    try:
-        from utim_cli.config import config
-        return str(config.local_dir)
-    except Exception:
-        return os.path.join(os.getcwd(), ".utim")
-
-def _backup_dir() -> str:
-    """Return the absolute path to the project-local .utim_backup directory."""
-    try:
-        from utim_cli.config import config
-        return str(config.local_dir.parent / ".utim_backup")
-    except Exception:
-        return os.path.join(os.getcwd(), ".utim_backup")
-
-# Legacy constants kept for any external code that might import them
 BACKUP_DIR = ".utim_backup"
 UTIM_DIR = ".utim"
 
-
 def is_json_valid(path: str) -> bool:
     """Check if JSON file exists and is parseable."""
     if not os.path.exists(path):
@@ -61,20 +43,18 @@ def is_file_valid(path: str) -> bool:
 def backup_state():
     """Backup active configuration and database files to .utim_backup/."""
     try:
-        utim_dir = _utim_dir()
-        backup_dir = _backup_dir()
-        if not os.path.exists(utim_dir):
+        if not os.path.exists(UTIM_DIR):
             return
             
-        os.makedirs(backup_dir, exist_ok=True)
+        os.makedirs(BACKUP_DIR, exist_ok=True)
         
         files_to_backup = [
             "config.json", "mcp.json", "utim_local.db", 
             "memory.json", "session_state.json"
         ]
         for f in files_to_backup:
-            src = os.path.join(utim_dir, f)
-            dst = os.path.join(backup_dir, f)
+            src = os.path.join(UTIM_DIR, f)
+            dst = os.path.join(BACKUP_DIR, f)
             if os.path.exists(src):
                 # Verify file is not corrupted before backing it up
                 if not is_file_valid(src):
@@ -87,16 +67,13 @@ def backup_state():
     except Exception as e:
         log_error("backup", f"State backup failed: {e}", e)
 
-
 def restore_state() -> bool:
     """Restore configuration and database files from backup if corrupt or missing."""
     try:
-        utim_dir = _utim_dir()
-        backup_dir = _backup_dir()
-        if not os.path.exists(backup_dir):
+        if not os.path.exists(BACKUP_DIR):
             return False
             
-        os.makedirs(utim_dir, exist_ok=True)
+        os.makedirs(UTIM_DIR, exist_ok=True)
         restored = False
         
         files_to_restore = [
@@ -104,8 +81,8 @@ def restore_state() -> bool:
             "memory.json", "session_state.json"
         ]
         for f in files_to_restore:
-            src = os.path.join(backup_dir, f)
-            dst = os.path.join(utim_dir, f)
+            src = os.path.join(BACKUP_DIR, f)
+            dst = os.path.join(UTIM_DIR, f)
             
             # Check if destination is missing or corrupted
             needs_restore = not os.path.exists(dst) or not is_file_valid(dst)
@@ -122,4 +99,3 @@ def restore_state() -> bool:
         log_error("backup", f"State restoration failed: {e}", e)
         return False
 
-

{utim_cli-1.44.0 → utim_cli-1.44.1}/utim_cli/bootstrap.py

@@ -114,22 +114,7 @@ description: Guidelines and patterns for asynchronous Python programming using a
 }
 
 def initialize_utim() -> str:
-    """Initialize .utim and .utim_tmp directory structure, local SQLite database,
-    and auto-create custom skills/rules if they don't exist.
-
-    Returns the path to the local DB file.
-    """
-    from utim_cli.config import config as _cfg
-
-    # Ensure BOTH project-local directories exist (and capture first-run state)
-    utim_first_run, utim_tmp_first_run = _cfg.ensure_project_dirs()
-    UTIM_DIR_resolved = _cfg.local_dir
-    UTIM_TMP_DIR_resolved = _cfg.local_tmp_dir
-
-    # Store first-run flag so utim.py can show a welcome hint
-    initialize_utim._utim_first_run = utim_first_run  # type: ignore[attr-defined]
-    initialize_utim._utim_tmp_first_run = utim_tmp_first_run  # type: ignore[attr-defined]
-
+    """Initialize .utim directory, local SQLite database, and auto-create custom skills/rules if they don't exist."""
     try:
         from utim_cli.backup import restore_state
         restore_state()
@@ -137,6 +122,8 @@ def initialize_utim() -> str:
         from utim_cli.logger import log_error
         log_error("bootstrap", "Failed to restore state during initialization", e)
         
+    UTIM_DIR.mkdir(exist_ok=True)
+    
     # 1. Initialize local_utim database using SQLAlchemy init_db
     try:
         from utim_cli.server.db import init_db
@@ -156,13 +143,14 @@ def initialize_utim() -> str:
     
     # 5. Sync global/local experience database across project folders
     try:
-        api_key = _cfg.get("api_key")
+        from utim_cli.config import config
+        api_key = config.get("api_key")
         if api_key:
             _sync_global_experience(api_key, os.getcwd())
     except Exception:
         pass
     
-    db_path = UTIM_DIR_resolved / "utim_local.db"
+    db_path = UTIM_DIR / 'utim_local.db'
     return str(db_path)
 
 
@@ -286,16 +274,14 @@ def _sync_global_experience(api_key: str, current_folder: str):
 def _write_skills_and_agents():
     """Auto-create skills/ directory, AGENTS.md, and all default SKILL.md files inside .utim/."""
     try:
-        from utim_cli.config import config
-        utim_dir = config.local_dir
         # Write AGENTS.md
-        agents_path = utim_dir / 'AGENTS.md'
+        agents_path = UTIM_DIR / 'AGENTS.md'
         if not agents_path.exists():
             with open(agents_path, 'w', encoding='utf-8') as f:
                 f.write(DEFAULT_AGENTS_MD)
                 
         # Write skills
-        skills_dir = utim_dir / 'skills'
+        skills_dir = UTIM_DIR / 'skills'
         for skill_name, content in DEFAULT_SKILLS.items():
             skill_dir = skills_dir / skill_name
             skill_dir.mkdir(parents=True, exist_ok=True)
@@ -305,14 +291,13 @@ def _write_skills_and_agents():
                     f.write(content)
                     
         # Write DESIGN.md
-        design_path = utim_dir / 'DESIGN.md'
+        design_path = UTIM_DIR / 'DESIGN.md'
         if not design_path.exists():
             _write_default_design_md(design_path)
     except Exception as e:
         from utim_cli.logger import log_error
         log_error("bootstrap", "Failed to write skills and agents configuration to .utim/", e)
 
-
 def _write_default_design_md(md_path: Path):
     content = """# Premium Web Design System (Aesthetics Cheat-Sheet)
 Use this guide to build modern, beautiful, and "award-winning" web interfaces. Apply these principles, variables, and recipes to wow the user.
@@ -334,8 +319,7 @@ Use this guide to build modern, beautiful, and "award-winning" web interfaces. A
 
 def _write_analytical_rules_md():
     """Write the analytical_rules.md file to .utim folder if not exists."""
-    from utim_cli.config import config
-    md_path = config.local_dir / 'analytical_rules.md'
+    md_path = UTIM_DIR / 'analytical_rules.md'
     if md_path.exists():
         return
         
@@ -351,11 +335,9 @@ Always start by identifying the TRUE objective, then work backwards to feasible
         from utim_cli.logger import log_error
         log_error("bootstrap", f"Failed to write analytical rules markdown to {md_path}", e)
 
-
 def _write_utim_md():
     """Write the UTIM.md file to .utim folder if not exists."""
-    from utim_cli.config import config
-    md_path = config.local_dir / 'UTIM.md'
+    md_path = UTIM_DIR / 'UTIM.md'
     if md_path.exists():
         return
         
@@ -369,13 +351,10 @@ def _write_utim_md():
         from utim_cli.logger import log_error
         log_error("bootstrap", f"Failed to write UTIM.md markdown to {md_path}", e)
 
-
 def get_rag_context(user_prompt: str = "") -> str:
     """Get RAG context string for system prompt injection by matching user_prompt keywords to skills."""
     try:
-        from utim_cli.config import config
         from utim_cli.state import STATE
-        utim_dir = config.local_dir
         STATE["injected_contexts"] = []
         
         # Simple keyword matching to select relevant skills
@@ -398,7 +377,7 @@ def get_rag_context(user_prompt: str = "") -> str:
                 
         # If no keywords matched, default to AGENTS.md
         if not matched_skills:
-            agents_path = utim_dir / 'AGENTS.md'
+            agents_path = UTIM_DIR / 'AGENTS.md'
             if agents_path.exists():
                 with open(agents_path, 'r', encoding='utf-8') as f:
                     content = f.read()
@@ -408,7 +387,7 @@ def get_rag_context(user_prompt: str = "") -> str:
             
         context = ""
         for skill_name in matched_skills[:2]: # Load top 2 matched skills
-            skill_path = utim_dir / 'skills' / skill_name / 'SKILL.md'
+            skill_path = UTIM_DIR / 'skills' / skill_name / 'SKILL.md'
             if skill_path.exists():
                 with open(skill_path, 'r', encoding='utf-8') as f:
                     content = f.read()
@@ -425,12 +404,9 @@ def get_rag_context(user_prompt: str = "") -> str:
         log_error("bootstrap", "Failed to get RAG context from skills", e)
         return ""
 
-
 def get_subagent_rag_context(subagent_name: str, query: str = "") -> str:
     """Get RAG context string for the specified sub-agent prompt injection by reading from markdown skill files directly."""
     try:
-        from utim_cli.config import config
-        utim_dir = config.local_dir
         # Map subagent name to the most relevant skill file
         mapping = {
             "project_res": "software-architecture",
@@ -442,7 +418,7 @@ def get_subagent_rag_context(subagent_name: str, query: str = "") -> str:
         if not skill_name:
             return ""
         
-        skill_path = utim_dir / 'skills' / skill_name / 'SKILL.md'
+        skill_path = UTIM_DIR / 'skills' / skill_name / 'SKILL.md'
         if not skill_path.exists():
             return ""
             

{utim_cli-1.44.0 → utim_cli-1.44.1}/utim_cli/config.py

@@ -2,55 +2,14 @@ import json
 import shutil
 import os
 import pathlib
-from typing import Any, Dict, Optional, Tuple
+from typing import Any, Dict, Optional
 
 class Config:
     def __init__(self):
         self.global_dir = pathlib.Path.home() / ".utim"
-        # local_dir and local_tmp_dir are always relative to the current working
-        # directory (the user's project root).  They are resolved lazily via
-        # properties so that tests that change os.getcwd() see the correct path.
+        self.local_dir = pathlib.Path(".utim").resolve()
         self._data: Dict[str, Any] = self._load()
 
-    # ── Project-local storage paths ──────────────────────────────────────────
-
-    @property
-    def local_dir(self) -> pathlib.Path:
-        """Path to the project-local .utim directory (persistent data)."""
-        return pathlib.Path(os.getcwd()) / ".utim"
-
-    @property
-    def local_tmp_dir(self) -> pathlib.Path:
-        """Path to the project-local .utim_tmp directory (transient data)."""
-        return pathlib.Path(os.getcwd()) / ".utim_tmp"
-
-    def ensure_project_dirs(self) -> Tuple[bool, bool]:
-        """Create .utim and .utim_tmp if they do not yet exist.
-
-        Returns (utim_created, utim_tmp_created) — True if the directory was
-        just created for the first time (useful for showing first-run messages).
-        """
-        utim_created = not self.local_dir.exists()
-        utim_tmp_created = not self.local_tmp_dir.exists()
-
-        self.local_dir.mkdir(parents=True, exist_ok=True)
-        self.local_tmp_dir.mkdir(parents=True, exist_ok=True)
-
-        # Write a .gitignore inside .utim_tmp so transient files are never
-        # accidentally committed to version control.
-        gitignore = self.local_tmp_dir / ".gitignore"
-        if not gitignore.exists():
-            try:
-                gitignore.write_text(
-                    "# Auto-generated by UTIM.  These files are transient and safe to delete.\n"
-                    "*\n",
-                    encoding="utf-8",
-                )
-            except Exception:
-                pass
-
-        return utim_created, utim_tmp_created
-
     def _load(self) -> Dict[str, Any]:
         data = {}
         # Load global config

{utim_cli-1.44.0 → utim_cli-1.44.1}/utim_cli/orchestrator.py

@@ -361,7 +361,6 @@ class Orchestrator:
         # Turn-level file-change tracking
         self.turn_history: List[Dict[str, Any]] = []
         self.redo_history: List[Dict[str, Any]] = []
-        self._post_undo_dirty: bool = False  # True if user typed a new prompt while redo_history was non-empty
         self._turn_changes: List[Dict[str, Any]] = []
         self._current_turn_start: int = 1  
 
@@ -1683,6 +1682,7 @@ class Orchestrator:
             after  = ch.get("after")  or ""
             b_lines = before.splitlines()
             a_lines = after.splitlines()
+            # Simple heuristic: added = lines only in after, removed = lines only in before
             b_set = set(b_lines); a_set = set(a_lines)
             add_total += len(a_lines) - len([l for l in a_lines if l in b_set])
             del_total += len(b_lines) - len([l for l in b_lines if l in a_set])
@@ -1696,69 +1696,6 @@ class Orchestrator:
             parts.append(f"[bold red]-{del_total}[/bold red]")
         return "  ".join(parts) if parts else "No files changed"
 
-    def get_undo_file_diff(self, from_turn_idx: int, mode: str = "undo") -> List[Dict]:
-        """Build a per-file diff preview for all turns from from_turn_idx onward (undo)
-        or for all redo_history turns (redo).
-        Returns a list of dicts: {path, action, before_lines, after_lines, added, removed}
-        """
-        import difflib
-        source_turns: List[Dict] = []
-        if mode == "undo":
-            source_turns = self.turn_history[from_turn_idx:]
-        else:  # redo
-            source_turns = list(reversed(self.redo_history))
-
-        # Collapse per-file: keep the first before and last after across all turns
-        file_first_before: Dict[str, Any] = {}
-        file_last_after: Dict[str, Any] = {}
-        file_action: Dict[str, str] = {}
-        for turn in source_turns:
-            for ch in turn.get("changes", []):
-                path = ch["path"]
-                act = ch.get("action", "write")
-                if path not in file_first_before:
-                    file_first_before[path] = ch.get("before")
-                    file_action[path] = act
-                file_last_after[path] = ch.get("after")
-
-        results: List[Dict] = []
-        for path in file_first_before:
-            before_str = file_first_before[path] or ""
-            after_str  = file_last_after.get(path) or ""
-            b_lines = before_str.splitlines(keepends=True)
-            a_lines = after_str.splitlines(keepends=True)
-
-            if mode == "undo":
-                # Undo: show revert direction (after→before)
-                diff_lines = list(difflib.unified_diff(
-                    a_lines, b_lines,
-                    fromfile=f"{path}  (current)",
-                    tofile=f"{path}  (after undo)",
-                    n=3
-                ))
-                added   = sum(1 for l in diff_lines if l.startswith("+") and not l.startswith("+++"))
-                removed = sum(1 for l in diff_lines if l.startswith("-") and not l.startswith("---"))
-            else:
-                # Redo: show forward direction (before→after)
-                diff_lines = list(difflib.unified_diff(
-                    b_lines, a_lines,
-                    fromfile=f"{path}  (current)",
-                    tofile=f"{path}  (after redo)",
-                    n=3
-                ))
-                added   = sum(1 for l in diff_lines if l.startswith("+") and not l.startswith("+++"))
-                removed = sum(1 for l in diff_lines if l.startswith("-") and not l.startswith("---"))
-
-            results.append({
-                "path": path,
-                "action": file_action[path],
-                "diff_lines": diff_lines,
-                "added": added,
-                "removed": removed,
-            })
-        return results
-
-
     def rewind_single_turn(self, turn_idx: int, revert_code: bool = True,
                            revert_msgs: bool = True) -> Dict[str, Any]:
         """Rewind only a single turn (not all subsequent turns)."""
@@ -1923,37 +1860,24 @@ class Orchestrator:
         turn["msg_start"] = msg_start
         turn["msg_end"] = msg_end
         self.turn_history.append(turn)
-        self._post_undo_dirty = False  # Redo completed — dirty flag cleared
         
         # Persist messages and redo history to DB
         self._persist_messages()
         return res
 
     def redo_up_to_turn(self, redo_idx: int) -> Dict[str, Any]:
-        """Redo undone turns chronologically up to redo_idx turns from the oldest undone.
-        
-        redo_history stores turns in reverse-chronological order: [C, B, A] where A
-        is at the end (most recently undone = earliest chronologically = first to redo).
-        
-        The dialog shows them in chronological order [A, B, C] so:
-          redo_idx=0 → redo just A  (the last item in redo_history)
-          redo_idx=1 → redo A + B  (the last 2 items, applied A first)
-          redo_idx=2 → redo A+B+C  (all, applied A→B→C)
-        """
+        """Redo all undone turns from index 0 up to redo_idx (inclusive)."""
         if not hasattr(self, "redo_history") or not self.redo_history or redo_idx >= len(self.redo_history):
             return {"reverted": [], "errors": ["No undone turns to redo."]}
-
-        n = redo_idx + 1  # number of turns to redo
-
-        # Take the n chronologically-oldest turns from the END of redo_history
-        # redo_history = [C, B, A]  →  last n=2 = [B, A]  →  reversed = [A, B] ✓
-        turns_to_redo = list(reversed(self.redo_history[-n:]))
-        # Remove those n items from the end
-        self.redo_history = self.redo_history[:-n] if n < len(self.redo_history) else []
-
+            
+        # Get the slice of turns to redo
+        turns_to_redo = self.redo_history[:redo_idx + 1]
+        # Keep the remaining undone turns
+        self.redo_history = self.redo_history[redo_idx + 1:]
+        
         res: Dict[str, Any] = {"redone_code": [], "errors": []}
-
-        # Apply in chronological order (A → B → C)
+        
+        # Redo them in order
         for turn in turns_to_redo:
             # Redo code changes
             for ch in turn.get("changes", []):
@@ -1977,19 +1901,18 @@ class Orchestrator:
                         res["redone_code"].append(path)
                 except Exception as e:
                     res["errors"].append(f"{path}: {e}")
-
-            # Redo messages: append them back in order
+                    
+            # Redo messages: append them back
             msg_start = len(self.messages)
             messages_to_add = turn.get("messages", [])
             self.messages.extend(messages_to_add)
             msg_end = len(self.messages)
-
+            
             # Reconstruct the turn entry and append back to turn_history
             turn["msg_start"] = msg_start
             turn["msg_end"] = msg_end
             self.turn_history.append(turn)
-
-        self._post_undo_dirty = False  # Redo completed — dirty flag cleared
+            
         self._persist_messages()
         return res
 
@@ -2697,10 +2620,6 @@ class Orchestrator:
             pass
 
         self.messages.append({"role": "user", "content": user_message})
-        # Track dirty redo: if there was redo history when the user typed this new prompt,
-        # flag it so /redo can warn them instead of silently losing the redo stack
-        if self.redo_history:
-            self._post_undo_dirty = True
         self.redo_history = []  # Clear redo history on new user action
         self._persist_messages(in_progress_turn={
             "user_msg": user_message,

{utim_cli-1.44.0 → utim_cli-1.44.1}/utim_cli/situational_scoring.py

@@ -157,17 +157,11 @@ def get_situational_multiplier(content: str, task_type: str, user_prompt: str =
         except Exception:
             pass
 
-    # 2. Command Chaining & Operator Pattern Boosting — ONLY for explicit command-execution tasks
-    # Must match BOTH the task type AND have specific command-execution words (not just "run")
-    COMMAND_EXECUTION_WORDS = ["exec", "execute", "command", "shell", "powershell", "cmd", "terminal", "install", "npm run", "pip install", "run tests", "run script"]
-    is_command_prompt = any(w in user_prompt.lower() for w in COMMAND_EXECUTION_WORDS)
+    # 2. Command Chaining & Operator Pattern Boosting (e.g., && vs ; separation)
+    is_command_prompt = any(w in user_prompt.lower() for w in ["run", "exec", "command", "shell", "powershell", "cmd", "terminal", "install", "test"])
     if any(k in c_lower for k in ["&&", "command", "shell", "powershell", "cmd", "operator", "separate"]):
-        # Only boost if the task is explicitly about running commands AND the prompt is command-related
-        if task_type in ["setup", "testing"] and is_command_prompt:
+        if task_type in ["setup", "testing"] or is_command_prompt:
             multiplier *= 2.2
-        elif task_type == "general" or not is_command_prompt:
-            # Suppress command-operator hints completely for general/conversational prompts
-            multiplier *= 0.1
 
     # 3. Operating System and Platform Pattern Boosting
     if os.name == "nt":  # Windows
@@ -211,19 +205,9 @@ def get_situational_multiplier(content: str, task_type: str, user_prompt: str =
 
 
 def score_and_filter_context(items: List[Dict], user_prompt: str, limit: int = 5) -> List[Dict]:
-    """Scores a list of retrieved context items and drops any below a minimum relevance threshold.
-    
-    Items with a base_score below MIN_BASE_SCORE are discarded before situational scoring,
-    preventing irrelevant experiences (e.g. PowerShell tips) from being injected on
-    unrelated conversational prompts like 'hello'.
-    """
+    """Scores a list of retrieved context items based on neural conceptual pattern matching."""
     if not items:
         return []
-
-    # Minimum cosine-similarity-derived base score to be eligible for injection.
-    # base_score = 1/(1+distance), so distance=0.7 → base_score≈0.59.
-    # Items with lower scores are semantically too far from the query.
-    MIN_BASE_SCORE = 0.55
         
     task_type = classify_task_type(user_prompt)
     scored_items = []
@@ -232,10 +216,6 @@ def score_and_filter_context(items: List[Dict], user_prompt: str, limit: int = 5
         content = item.get("content", "")
         base_score = item.get("base_score", 1.0)
         
-        # Hard gate: drop items that are too semantically distant regardless of boosts
-        if base_score < MIN_BASE_SCORE:
-            continue
-        
         # Calculate neural pattern multiplier
         multiplier = get_situational_multiplier(content, task_type, user_prompt=user_prompt)
         situational_score = base_score * multiplier

{utim_cli-1.44.0 → utim_cli-1.44.1}/utim_cli/tools.py

@@ -3130,10 +3130,9 @@ def store_experience(category: str, content: str, priority: int = None, subagent
     from pathlib import Path
     
     try:
-        # Use config.local_dir for project-local path resolution
-        from utim_cli.config import config as _cfg
-        utim_dir = _cfg.local_dir
-        utim_dir.mkdir(parents=True, exist_ok=True)
+        # Ensure .utim directory exists
+        utim_dir = Path('.utim')
+        utim_dir.mkdir(exist_ok=True)
         exp_file = utim_dir / 'experiences.json'
         
         # Load existing experiences
@@ -3198,10 +3197,9 @@ def recall_experience(query: str, limit: int = 5, subagent: str = None) -> str:
         from pathlib import Path
         import json
         from utim_cli.state import STATE
-        from utim_cli.config import config as _cfg
         
         results_str = []
-        utim_dir = _cfg.local_dir
+        utim_dir = Path('.utim')
         exp_file = utim_dir / 'experiences.json'
         
         # Search experiences from experiences.json