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

utim_cli-1.44.0/CHANGELOG.md

@@ -0,0 +1,51 @@
+# Changelog
+
+All notable changes to the UTIM CLI Agent will be documented in this file.
+
+## [1.44.00] - 2026-07-01
+
+### Added
+- **New Frontier Model `anthropic/claude-sonnet-5`**: Registered the new flagship Claude 3.5 Sonnet next-gen model across the main agent and subagent registries. Priced at $2.00/1M input and $10.00/1M output base with a 2% UTIM markup, and whitelisted for Hobby/Pro/Team tiers.
+- **Full File Diff Preview in TUI**: Pressing `Space` inside the interactive Undo or Redo list dialog now loads a full-screen, syntax-colored (green/red/cyan) paginated unified diff preview panel displaying exactly what code changes will be reverted or restored.
+- **Local Project-Based Storage Architecture**: Separated local workspace folders into persistent `.utim/` (containing `utim_local.db`, local configurations, and learning experiences) and transient `.utim_tmp/` (containing plans, vector database, web searches, and generated images). Added auto-generation of a root `.gitignore` inside `.utim_tmp` to exclude it from version control.
+- **Workspace Startup UX Notices**: Friendly CLI notification banner at startup informing the user when a project workspace is initialized, detailing what the `.utim/` and `.utim_tmp/` directories store and confirming the exact path where they were created.
+
+### Changed
+- **Local SQLite Connection Path**: Configured the SQLite Database URL to dynamically point directly to the project-relative `.utim/utim_local.db` path (resolving lazy CWD relative paths on start) instead of a hardcoded path in the working directory.
+- **ORM JSON Column Serialization**: Swapped raw `Text` columns to native SQLAlchemy `JSON` types for conversation `messages`, `turn_history`, and `redo_history` columns, ensuring transparent SQLite/PostgreSQL serialization and eliminating raw JSON string/list parsing issues on resume.
+- **Divergent History Guard / Warn-on-Dirty-Redo**: Redoing an action after typing new prompts now prompts the user with a confirmation warning that their new post-undo trajectory will be discarded and rewritten, preventing accidental loss of the original redo stack.
+- **Scrollback Buffer Cleared on Undo/Redo**: Swapped `console.clear()` with ANSI escape sequences (`\033[3J\033[H\033[2J`) to completely wipe the scrollback history buffer so undone turns are permanently removed from terminal scrollback.
+- **Faithful Conversation Replay**: Replaced simplified text-only message printing after undo/redo with full `_print_session_history` rendering, faithfully replaying all tool calls and interactive agent actions in their original visual layout.
+- **Chronological Redo Ordering**: Fixed a list slicing bug where redoing multiple steps applied changes backward (newest first). Redoing now chronologically restores turns from the oldest undone prompt up to the selected target.
+
+### Fixed
+- **Resume Dialog Crash**: Fixed a crash in `/resume` dialog causing unhandled exceptions in the event loop by introducing the missing `FileChange` model and the `get_or_create_user` helper in `db.py`.
+- **Deserialization Failure on Session Resume**: Resolved a bug in `_dialog_resume` and `HistoryManager` where the conversation and turn/redo histories were read back as raw strings instead of deserialized JSON lists.
+- **Situational RAG Injection Noise**: Tightened semantic distance threshold (`1.2` to `0.7`) and introduced a `0.55` similarity floor in the Experience DB retrieval engine. Suppressed command-execution boosts on conversational prompts (like "hello"), keeping the context window clean.
+
+
+## [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.43.20/utim_cli.egg-info → utim_cli-1.44.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: utim-cli
-Version: 1.43.20
+Version: 1.44.0
 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.43.20 → utim_cli-1.44.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "utim-cli"
-version = "1.43.20"
+version = "1.44.00"
 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.43.20 → utim_cli-1.44.0}/utim_cli/backup.py

@@ -4,9 +4,27 @@ 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):
@@ -43,18 +61,20 @@ def is_file_valid(path: str) -> bool:
 def backup_state():
     """Backup active configuration and database files to .utim_backup/."""
     try:
-        if not os.path.exists(UTIM_DIR):
+        utim_dir = _utim_dir()
+        backup_dir = _backup_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):
@@ -67,13 +87,16 @@ 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:
-        if not os.path.exists(BACKUP_DIR):
+        utim_dir = _utim_dir()
+        backup_dir = _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 = [
@@ -81,8 +104,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)
@@ -99,3 +122,4 @@ def restore_state() -> bool:
         log_error("backup", f"State restoration failed: {e}", e)
         return False
 
+

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

@@ -114,7 +114,22 @@ description: Guidelines and patterns for asynchronous Python programming using a
 }
 
 def initialize_utim() -> str:
-    """Initialize .utim directory, local SQLite database, and auto-create custom skills/rules if they don't exist."""
+    """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]
+
     try:
         from utim_cli.backup import restore_state
         restore_state()
@@ -122,8 +137,6 @@ 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
@@ -143,14 +156,13 @@ def initialize_utim() -> str:
     
     # 5. Sync global/local experience database across project folders
     try:
-        from utim_cli.config import config
-        api_key = config.get("api_key")
+        api_key = _cfg.get("api_key")
         if api_key:
             _sync_global_experience(api_key, os.getcwd())
     except Exception:
         pass
     
-    db_path = UTIM_DIR / 'utim_local.db'
+    db_path = UTIM_DIR_resolved / "utim_local.db"
     return str(db_path)
 
 
@@ -274,14 +286,16 @@ 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)
@@ -291,13 +305,14 @@ 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.
@@ -319,7 +334,8 @@ 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."""
-    md_path = UTIM_DIR / 'analytical_rules.md'
+    from utim_cli.config import config
+    md_path = config.local_dir / 'analytical_rules.md'
     if md_path.exists():
         return
         
@@ -335,9 +351,11 @@ 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."""
-    md_path = UTIM_DIR / 'UTIM.md'
+    from utim_cli.config import config
+    md_path = config.local_dir / 'UTIM.md'
     if md_path.exists():
         return
         
@@ -351,10 +369,13 @@ 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
@@ -377,7 +398,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()
@@ -387,7 +408,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()
@@ -404,9 +425,12 @@ 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",
@@ -418,7 +442,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.43.20 → utim_cli-1.44.0}/utim_cli/config.py

@@ -2,14 +2,55 @@ import json
 import shutil
 import os
 import pathlib
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Tuple
 
 class Config:
     def __init__(self):
         self.global_dir = pathlib.Path.home() / ".utim"
-        self.local_dir = pathlib.Path(".utim").resolve()
+        # 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._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.43.20 → utim_cli-1.44.0}/utim_cli/orchestrator.py

@@ -361,6 +361,7 @@ 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  
 
@@ -1682,7 +1683,6 @@ 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,6 +1696,69 @@ 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)."""
@@ -1860,24 +1923,37 @@ 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 all undone turns from index 0 up to redo_idx (inclusive)."""
+        """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)
+        """
         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."]}
-            
-        # 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:]
-        
+
+        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 []
+
         res: Dict[str, Any] = {"redone_code": [], "errors": []}
-        
-        # Redo them in order
+
+        # Apply in chronological order (A → B → C)
         for turn in turns_to_redo:
             # Redo code changes
             for ch in turn.get("changes", []):
@@ -1901,18 +1977,19 @@ class Orchestrator:
                         res["redone_code"].append(path)
                 except Exception as e:
                     res["errors"].append(f"{path}: {e}")
-                    
-            # Redo messages: append them back
+
+            # Redo messages: append them back in order
             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
 
@@ -2620,6 +2697,10 @@ 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.43.20 → utim_cli-1.44.0}/utim_cli/situational_scoring.py

@@ -157,11 +157,17 @@ def get_situational_multiplier(content: str, task_type: str, user_prompt: str =
         except Exception:
             pass
 
-    # 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"])
+    # 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)
     if any(k in c_lower for k in ["&&", "command", "shell", "powershell", "cmd", "operator", "separate"]):
-        if task_type in ["setup", "testing"] or is_command_prompt:
+        # 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:
             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
@@ -205,9 +211,19 @@ 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 based on neural conceptual pattern matching."""
+    """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'.
+    """
     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 = []
@@ -216,6 +232,10 @@ 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.43.20 → utim_cli-1.44.0}/utim_cli/tools.py

@@ -3130,9 +3130,10 @@ def store_experience(category: str, content: str, priority: int = None, subagent
     from pathlib import Path
     
     try:
-        # Ensure .utim directory exists
-        utim_dir = Path('.utim')
-        utim_dir.mkdir(exist_ok=True)
+        # 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)
         exp_file = utim_dir / 'experiences.json'
         
         # Load existing experiences
@@ -3197,9 +3198,10 @@ 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 = Path('.utim')
+        utim_dir = _cfg.local_dir
         exp_file = utim_dir / 'experiences.json'
         
         # Search experiences from experiences.json