minovative-mind-cli 2.13.5 → 2.14.0

package/README.md

@@ -7,7 +7,7 @@ and hope for the best.
 
 This CLI does the opposite — it uses a custom built agentic system called,
 **Precision-Context Verification (PCV)** engine to feed lightweight Flash models
-exactly the right context, execute code, verify compilation, execute Property-Based Testing (PBT) suites and diff-scoped mutation audits, and self-correct (if it even needs to), until
+exactly the right context via **AST-level targeted reads** and **2-tier context compression**, execute code, verify compilation, execute Property-Based Testing (PBT) suites and diff-scoped mutation audits, and self-correct (if it even needs to), until
 the build/performance metrics are green.
 
 > The result: **Genuine Pro reasoning accuracy at Flash-level speed and efficiency.**
@@ -82,7 +82,7 @@ Works in any terminal — SSH, Docker, CI pipelines, Vim, Windows Command Prompt
 
 ### 🔬 Automated SWE-bench Evaluation Runner
 
-Evaluate the agent on SWE-bench Lite datasets with automated repo isolation, patch extraction, and public-ready telemetry reporting:
+Evaluate the agent on SWE-bench Lite datasets with automated repo isolation, patch extraction, AST-scoped context minimization, and public-ready telemetry reporting:
 
 ```bash
 # Run SWE-bench evaluation and generate JSON report
@@ -92,20 +92,31 @@ minovative-mind-cli eval -i test_instances.jsonl -o predictions.jsonl -r evaluat
 minovative-mind-cli eval -i instances.jsonl --repo astropy/astropy --concurrency 2
 ```
 
----
+> **Token Economics & Efficiency**: With AST-level symbol chunking (`targetElements`), SHA-256 context caching, and in-place historical tool response pruning, benchmark evaluations achieve up to **85%–95% lower token usage per instance**, eliminating token-per-minute (TPM) rate limit thrashing while preserving deep reasoning fidelity.
 
+---
 
 ## Models
 
-Hot-swap during a session using `/models`:
+Minovative Mind CLI features native support for Google's Gemini 3.x reasoning capabilities (`thinking_config`), allocating dynamic thinking budgets before tool execution and code generation. Hot-swap models and customize reasoning levels during a session using `/models`:
+
+| Model                     | Default Thinking Level | Best for                                            |
+| ------------------------- | ---------------------- | --------------------------------------------------- |
+| **Auto** (default)        | `Medium` (`MEDIUM`)    | Automatically selects (3.7 Flash or 3.5 Flash Lite) |
+| **Gemini 3.7 Flash**      | `Medium` (`MEDIUM`)    | Next-gen performance, reasoning & fast execution    |
+| **Gemini 3.6 Flash**      | `Medium` (`MEDIUM`)    | Everyday coding — fast and accurate                 |
+| **Gemini 3.1 Pro**        | `High` (`HIGH`)        | Complex architectural changes & deep reasoning      |
+| **Gemini 3.5 Flash Lite** | `Low` (`LOW`)          | Best for speed and cost efficiency                  |
+
+### Native Thinking & Reasoning Levels
+
+Gemini 3.x models support native provider-level reasoning control via `thinking_config`. When switching models or invoking `/models`, you can interactively customize the thinking depth across three streamlined developer tiers:
 
-| Model                     | Best for                                            |
-| ------------------------- | --------------------------------------------------- |
-| **Auto** (default)        | Automatically selects (3.7 Flash or 3.5 Flash Lite) |
-| **Gemini 3.7 Flash**      | Next-gen performance, reasoning & fast execution    |
-| **Gemini 3.6 Flash**      | Everyday coding — fast and accurate                 |
-| **Gemini 3.1 Pro**        | Complex architectural changes                       |
-| **Gemini 3.5 Flash Lite** | Best for speed and cost efficiency                  |
+- **`Low` (`LOW`)**: Fast, lightweight reasoning for routine tasks, minor bug fixes, and quick code edits.
+- **`Medium` (`MEDIUM`)**: Balanced reasoning depth for multi-file refactoring, debugging, and feature development (default for 3.7 Flash, 3.6 Flash, and Auto).
+- **`High` (`HIGH`)**: Exhaustive chain-of-thought deliberation for complex architectural transformations, intricate algorithmic puzzles, and large-scale migrations (default for 3.1 Pro).
+
+_(Note: Internal `Minimal` reasoning is strictly reserved for lightweight background micro-agents and is excluded from user-facing selection to ensure optimal coding performance.)_
 
 ### BYOK (Bring Your Own Key)
 
@@ -114,17 +125,21 @@ If you prefer to use your own API key instead of credits, you can configure it v
 - **Configuration:** Use `/config-key` in the chat session to set and manage your API key.
 - **Error Handling:** If your key is invalid, expired, or you hit rate limits, the CLI will report a `BYOK AI Error`. Please check your API key status in the [Google AI Studio dashboard](https://aistudio.google.com).
 
-### Auxiliary Model Routing Defaults
+### Auxiliary Model Routing Defaults & Reasoning Invariants
 
-Background tasks automatically route to dedicated auxiliary models with native `responseSchema` constraints for optimal latency, cost efficiency, and structured output reliability:
+Background tasks automatically route to dedicated auxiliary models with native `responseSchema` constraints, AST symbol extractors, persistent caches, and deterministic reasoning invariants for optimal latency, cost efficiency, and structured output reliability:
 
-- **Intent Routing (`routeIntent`)**: `Gemini 3.7 Flash` (Temp 0, native `responseSchema`) — permissive zero-temperature classification into `SEARCH` vs `SKIP` and `CHAT` vs `EXECUTE` with resilient fallback to repository exploration.
-- **Complexity Evaluators (`evaluateInvestigationComplexity`)**: `Gemini 3.7 Flash` (Temp 0, native `responseSchema`) — permissive parallel domain partitioning, global override detection, primary sub-path auto-focusing, and dynamic agent assignment recovery.
-- **Context Compressor**: `Gemini 3.7 Flash` (Temp 0.2) — surgical code distillation for files exceeding 2,000 characters.
-- **Session Titling**: `Gemini 3.7 Flash` (Temp 0.7, native `responseSchema`) — automated concise chat session titling.
-- **Semantic Cache Classifier**: `Gemini 3.5 Flash Lite` (Temp 0, native `responseSchema`) — intent and topic classification for cache hits.
-- **History Summarizer**: `Gemini 3.7 Flash` (Temp 0.2) — 3-part structured conversation compression preserving recent history.
-- **Commit Generator**: `Gemini 3.5 Flash Lite` — conventional commit message synthesis.
+- **Intent Routing (`routeIntent`)**: `Gemini 3.7 Flash` (Temp 0, native `responseSchema`, `MINIMAL` invariant) — permissive zero-temperature classification into `SEARCH` vs `SKIP` and `CHAT` vs `EXECUTE` with resilient fallback to repository exploration.
+- **Complexity Evaluators (`evaluateInvestigationComplexity`)**: `Gemini 3.7 Flash` (Temp 0, native `responseSchema`, `MINIMAL` invariant) — permissive parallel domain partitioning, global override detection, primary sub-path auto-focusing, and dynamic agent assignment recovery.
+- **Context Compressor & Caching**: `Gemini 3.7 Flash` (Temp 0.2, `MINIMAL` invariant) — surgical code distillation for files exceeding 2,000 characters backed by a persistent 2-tier SHA-256 disk cache (`context_cache.json`) capped at 5MB LRU. Files under 2,000 characters retain 100% full fidelity without compression overhead.
+- **AST Symbol Extraction & Targeted Reads**: Polyglot AST declaration extractor (`symbolExtractor.ts`) enabling granular `targetElements` symbol chunking in `read_file`, slashing input token bloat by up to 85%–95%.
+- **In-Place Tool History Pruning**: Active working memory management preserving raw workspace file blocks while compacting historical command/test outputs across multi-turn reasoning loops.
+- **Session Titling**: `Gemini 3.7 Flash` (Temp 0.7, native `responseSchema`, `MINIMAL` invariant) — automated concise chat session titling.
+- **Semantic Cache Classifier**: `Gemini 3.5 Flash Lite` (Temp 0, native `responseSchema`, `MINIMAL` invariant) — intent and topic classification for cache hits.
+- **History Summarizer**: `Gemini 3.7 Flash` (Temp 0.2, `MINIMAL` invariant) — 3-part structured conversation compression preserving recent history.
+- **Commit Generator**: `Gemini 3.5 Flash Lite` (`MINIMAL` invariant) — conventional commit message synthesis.
+- **Micro-Agent Safety Invariants & Normalization**: All internal background micro-agents enforce a hardcoded `MINIMAL` invariant to guarantee zero-latency execution without conversational token burn. The generation pipeline's `normalizeGenerationConfig` automatically strips unsupported internal minimal payloads before dispatching to Google's API, preventing `400 Bad Request` schema errors while ensuring user-selected thinking levels never pollute lightweight background micro-agents.
+- **Subsystem Reasoning Budgets**: Orchestrated subsystems maintain tailored reasoning allocations: **PM Kernel Task Decomposition** operates at `HIGH` reasoning depth for optimal topological dependency sorting; **Investigation & Context Sub-Agents** operate at `MEDIUM` reasoning depth for comprehensive repository reconnaissance; **Syntax Repair Agents** operate at `LOW` reasoning depth for precise AST corrections; and **Execution Sub-Agents / Main Agent** dynamically inherit your configured model thinking level (`LOW` | `MEDIUM` | `HIGH`).
 
 > You pay for auxiliary model background AI operations and for your selected model during chat and code execution. Use `/debug` to inspect real-time routing diagnostics.
 
@@ -136,13 +151,13 @@ Background tasks automatically route to dedicated auxiliary models with native `
 | --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
 | `/config-key`   | Configure custom Google AI Studio API key (BYOK mode)                                                                                           |
 | `/profile`      | View, inspect, delete, or reset global adaptive persona memory and AI side-notes                                                                |
-| `/models`       | Hot-swap the active model                                                                                                                       |
+| `/models`       | Hot-swap the active model or configure its native reasoning thinking level (`Low`, `Medium`, `High`)                                            |
 | `/paste`        | Multi-line input mode (cancel with Ctrl+C)                                                                                                      |
 | `/clear`        | Clear conversation history                                                                                                                      |
 | `/debug`        | Expose internal agent diagnostics                                                                                                               |
 | `/auto-approve` | Toggle skipping confirmation prompts for commands                                                                                               |
 | `/sub-agents`   | Toggle the MMAAK Engine for parallel investigation and execution (concurrency limited to 2)                                                     |
-| `/stats`        | View session and all-time statistics, plus configurations                                                                                       |
+| `/stats`        | View session and all-time statistics, token telemetry, active model settings, and live thinking level runtime telemetry                         |
 | `/commit`       | Generate a conventional commit message from your diff                                                                                           |
 | `/revert`       | Undo changes from the last turn, or toggle the revert logger                                                                                    |
 | `/chats`        | View, resume, rename, or delete previous chat sessions (with centralized token telemetry, Git branch, auto-approve status, and sub-agent state) |
@@ -151,6 +166,54 @@ Background tasks automatically route to dedicated auxiliary models with native `
 
 ---
 
+## 🏷️ @ Context Mentions & Interactive Autocomplete
+
+Minovative Mind CLI features real-time, interactive **@ Context Mentions** directly in your terminal prompt. Type `@` anywhere while writing a prompt to trigger fuzzy-filtered autocomplete and inject targeted codebase context, AST symbols, Git status/diffs, diagnostics, or cross-workspace files directly into the model's reasoning loop without manual copy-pasting or extra discovery tool turns.
+
+### Interactive Autocomplete & Keyboard Navigation
+
+When typing `@`, the interactive terminal autocomplete popup immediately renders:
+- **10-Option Pagination**: Displays up to 10 ranked suggestions per page with dynamic page indexing `(1/10)`.
+- **Cyan Navigation Helper**: Highlights the action footer in light blue (`Tab to insert • ↑/↓ navigate • Esc dismiss`) for clear guidance.
+- **Keyboard Controls**:
+  - `↑` / `↓` (Up / Down Arrows): Cycle smoothly through ranked suggestions with automatic window scrolling.
+  - `Tab` or `Enter`: Select and insert the highlighted mention directly at the cursor.
+  - `Esc`: Dismiss the autocomplete dropdown.
+  - `Backspace` / Alphanumeric keys: Filter suggestions in real-time with fuzzy matching.
+
+### Supported Mention Types
+
+| Mention Syntax | Category Badge | Type | What it Resolves & Injects |
+| :--- | :--- | :--- | :--- |
+| `@<path>` or `@file:<path>` | `[file]` | **File** | Injects the complete content of a workspace file (e.g. `@src/index.ts` or `@file:package.json`). |
+| `@<path>:<start>-<end>` | `[lines]` | **Line Range Slicing** | Surgically slices and injects only the specified line numbers (e.g. `@src/utils/config.ts:10-50`), saving tokens. |
+| `@symbol:<name>` or `@#<name>` | `[sym]` | **AST Symbol** | Injects exact definitions of functions, classes, interfaces, types, methods, or structs (e.g. `@symbol:getUser` or `@#AuthService`) using polyglot AST extraction. |
+| `@symbol:<path>:<name>` | `[sym]` | **Scoped Symbol** | Injects a specific symbol definition directly from a designated source file (e.g. `@symbol:src/services/auth.ts:validateToken`). |
+| `@git:diff` or `@diff` | `[git]` | **Git Diff** | Injects the active unstaged working tree diff. |
+| `@git:staged` | `[git]` | **Git Staged** | Injects currently staged git changes (`git diff --staged`). |
+| `@git:status` | `[git]` | **Git Status** | Injects the current branch state and working tree status (`git status --short`). |
+| `@git:branch` | `[git]` | **Git Branch** | Injects the current active Git branch and upstream tracking info. |
+| `@git:log` | `[git]` | **Git Commit Log** | Injects the recent commit history (last 10 commits with hashes, authors, and messages). |
+| `@diagnostics` / `@problems` / `@errors` | `[diag]` / `[prob]` | **Diagnostics** | Injects active compiler, linter, or syntax error diagnostics. |
+| `@terminal` / `@console` | `[term]` | **Terminal Context** | Injects recent terminal environment context, shell environment, and command execution state. |
+| `@<alias>/<path>` | `[ws]` | **Cross-Workspace File** | Injects file contents from registered external workspaces (e.g. `@backend/src/routes.ts` or `@frontend/src/App.tsx`). |
+| `@<alias>` | `[ws]` | **Workspace Summary** | Injects configuration, manifest overview, and path details for a registered external workspace. |
+
+### Visual Terminal Indicators & Status Tracking
+
+When a prompt with `@` context mentions is submitted, the CLI provides real-time, high-contrast visual confirmation indicators in the terminal:
+- **Success Indicators (`✔`)**: High-contrast green checkmark with dim status summary confirming successful extraction (e.g. `✔ Context @src/index.ts:1-25 (lines 1-25, 420 chars)`, `✔ Context @symbol:startServer (src/index.ts, 12 lines)`, `✔ Context @git:status (short status, clean)`, `✔ Context @diagnostics (syntax scan clean)`, `✔ Context @terminal (Darwin arm64, node v20.x)`, `✔ Context @backend (external workspace)`).
+- **Failure Indicators (`✖`)**: Clear red indicator with explicit error reasoning when resolution fails (e.g. `✖ Context @missing.ts (File does not exist)`, `✖ Context @symbol:unknownFunc (Could not find declaration for symbol)`).
+- **Structured Metadata Status Tracking**: Every resolved mention produces a rich `metadata` envelope (capturing line counts, char counts, symbol kind, git diff stats, and syntax scan metrics) powering both visual indicators and token-budgeted prompt injection.
+
+### Context Resolution & Safety Architecture
+
+- **Token Budgeting & Safety Allocation**: All parsed mentions are resolved into structured XML blocks (`<context_mentions>`) wrapped in CDATA sections with strict token budgeting and prompt injection defenses.
+- **Read-Guard Pre-Registration (`fileReadGuard`)**: Files referenced via `@` mentions are automatically registered in the system's `fileReadGuard`. This allows the AI agent to immediately invoke file modifications (`modify_file`, `write_file`) without redundant `read_file` roundtrips, accelerating execution speed.
+- **Multi-Workspace Path Resolution**: Automatically validates boundaries across registered workspaces via `resolveAndValidateMultiWorkspacePath`, preventing directory traversal escapes (`../`).
+
+---
+
 ## 🌐 Multi-Workspace, Sub-Path Focusing & Security Guardrails
 
 Minovative Mind CLI doesn't restrict you to a single repository. You can logically group multiple external repositories into **Master Workspaces** (Profiles) containing dedicated **Sub-Workspaces** (mapped to short aliases like `@backend` or `@frontend`).
@@ -166,28 +229,28 @@ Minovative Mind CLI doesn't restrict you to a single repository. You can logical
 
 Minovative Mind CLI fundamentally supports **ALL programming languages** for chat, code generation, and execution, as it relies on Gemini's vast training data.
 
-However, the PCV engine features deep, context-aware analysis across **12 major programming language families**. Our core advanced engines—**Smart Dependency Tracing**, **Property-Based & Mutation Verification**, **Performance Auditing** (across 9 language families), and **Ephemeral Analysis Scripts**—provide tailored support depending on the language's syntax and runtime model:
-
-| Language Family              | Supported Extensions                         | Dependency Tracing | Performance Auditing | Ephemeral Analysis |
-| :--------------------------- | :------------------------------------------- | :----------------: | :------------------: | :----------------: |
-| **JavaScript / TypeScript**  | `.js`, `.jsx`, `.ts`, `.tsx`, `.mjs`, `.cjs` |         ✅         |          ✅          |         ✅         |
-| **Python**                   | `.py`, `.pyw`                                |         ✅         |          ✅          |         ✅         |
-| **Rust**                     | `.rs`                                        |         ✅         |          ✅          |         ✅         |
-| **Go**                       | `.go`                                        |         ✅         |          ✅          |         ✅         |
-| **C / C++**                  | `.c`, `.h`, `.cpp`, `.hpp`, `.cc`, `.cxx`    |         ✅         |          ✅          |       ⚠️ \*        |
-| **C#**                       | `.cs`                                        |         ✅         |          ✅          |         ❌         |
-| **Java / Kotlin**            | `.java`, `.kt`, `.kts`                       |         ✅         |          ✅          |       ⚠️ \*        |
-| **PHP**                      | `.php`                                       |         ✅         |          ✅          |         ❌         |
-| **Ruby**                     | `.rb`                                        |         ✅         |          ✅          |         ❌         |
-| **CSS / SCSS / SASS / LESS** | `.css`, `.scss`, `.sass`, `.less`            |         ✅         |          ❌          |         ❌         |
-| **Swift**                    | `.swift`                                     |         ✅         |          ❌          |         ❌         |
-| **Dart**                     | `.dart`                                      |         ✅         |          ❌          |         ❌         |
+However, the PCV engine features deep, context-aware analysis across **12 major programming language families**. Our core advanced engines—**Smart Dependency Tracing**, **AST Symbol Extraction & Chunking**, **Property-Based & Mutation Verification**, **Performance Auditing** (across 9 language families), and **Ephemeral Analysis Scripts**—provide tailored support depending on the language's syntax and runtime model:
+
+| Language Family              | Supported Extensions                         | Dependency Tracing | AST Extraction | Performance Auditing | Ephemeral Analysis |
+| :--------------------------- | :------------------------------------------- | :----------------: | :------------: | :------------------: | :----------------: |
+| **JavaScript / TypeScript**  | `.js`, `.jsx`, `.ts`, `.tsx`, `.mjs`, `.cjs` |         ✅         |       ✅       |          ✅          |         ✅         |
+| **Python**                   | `.py`, `.pyw`                                |         ✅         |       ✅       |          ✅          |         ✅         |
+| **Rust**                     | `.rs`                                        |         ✅         |       ✅       |          ✅          |         ✅         |
+| **Go**                       | `.go`                                        |         ✅         |       ✅       |          ✅          |         ✅         |
+| **C / C++**                  | `.c`, `.h`, `.cpp`, `.hpp`, `.cc`, `.cxx`    |         ✅         |       ✅       |          ✅          |       ⚠️ \*        |
+| **C#**                       | `.cs`                                        |         ✅         |       ✅       |          ✅          |         ❌         |
+| **Java / Kotlin**            | `.java`, `.kt`, `.kts`                       |         ✅         |       ✅       |          ✅          |       ⚠️ \*        |
+| **PHP**                      | `.php`                                       |         ✅         |       ✅       |          ✅          |         ❌         |
+| **Ruby**                     | `.rb`                                        |         ✅         |       ✅       |          ✅          |         ❌         |
+| **CSS / SCSS / SASS / LESS** | `.css`, `.scss`, `.sass`, `.less`            |         ✅         |       ❌       |          ❌          |         ❌         |
+| **Swift**                    | `.swift`                                     |         ✅         |       ✅       |          ❌          |         ❌         |
+| **Dart**                     | `.dart`                                      |         ✅         |       ✅       |          ❌          |         ❌         |
 
 _⚠️\*Support is limited or requires custom local system tooling/environment setup._
 
 ### Why do some features only support specific languages?
 
-1. **Dependency Tracing:** Fully supported across language families. It uses lightning-fast static regex pattern matching to resolve local import structures and determine the "blast radius" of code changes without requiring local compilations.
+1. **Dependency Tracing & AST Symbol Extraction:** Fully supported across major language families. It uses lightning-fast static regex pattern matching and AST outline parsers to resolve local import structures, extract targeted symbol definitions (`targetElements`), and determine the "blast radius" of code changes without requiring heavy compilations.
 2. **Performance Auditing:** Executed natively across 9 major language families (JavaScript/TypeScript, Python, Go, Rust, PHP, C#, Java, C/C++, and Ruby). It uses zero-dependency, ultra-fast (<50ms) language-aware regex heuristics with comment/string stripping and line-preserving offset tracking to detect severe runtime anti-patterns (such as unbounded loops, synchronous I/O, chained array allocations, unnecessary allocations, and unclosed resources).
 3. **Ephemeral Analysis & Property-Based Probing:** Defaults to Node.js as a safe baseline, but natively leverages host-installed runtimes (Python, Rust, Go compilers) and standard libraries whenever available in the workspace.
 

package/dist/services/agent/slashCommands.js

@@ -17,8 +17,8 @@ import { ProxyClient, getAndResetTurnUsage } from '../proxyClient.js';
 import { checkByokSubscription } from '../auth.js';
 import { GEMINI_MODELS, isByokEnabled } from '../../utils/config.js';
 import { loadCredentials, updateCredentialField } from '../../utils/credentialStore.js';
-import { getGlobalActiveModel, setGlobalActiveModel, ProxyChatSession } from '../ai.js';
-import { loadUserProfile, deleteSideNote, clearUserProfile, getUserProfilePath, } from '../userProfileService.js';
+import { getGlobalActiveModel, setGlobalActiveModel, getModelThinkingLevel, setModelThinkingLevel, ProxyChatSession } from '../ai.js';
+import { loadUserProfile, deleteSideNote, clearUserProfile, getUserProfilePath } from '../userProfileService.js';
 /**
  * @file slashCommands.ts
  * @description Interactive slash command handler module for Minovative Mind CLI.
@@ -139,7 +139,41 @@ export async function handleSlashCommand(command, context) {
         if (!p.isCancel(selectedModel)) {
             chat.setModel(selectedModel);
             setGlobalActiveModel(selectedModel);
-            p.log.success(`Model successfully switched to ${pc.cyan(selectedModel)}`);
+            const activeModelThinking = getModelThinkingLevel(selectedModel);
+            const selectedThinking = await p['select']({
+                message: `Configure Thinking Level for ${pc.cyan(selectedModel)} (Current: ${pc.cyan(activeModelThinking)})`,
+                initialValue: activeModelThinking,
+                options: [
+                    {
+                        value: 'LOW',
+                        label: 'Low',
+                        hint: 'Quick reasoning with low token overhead',
+                    },
+                    {
+                        value: 'MEDIUM',
+                        label: 'Medium',
+                        hint: 'Balanced reasoning for everyday coding and debugging',
+                    },
+                    {
+                        value: 'HIGH',
+                        label: 'High',
+                        hint: 'Deepest reasoning for complex architectural tasks',
+                    },
+                ],
+            });
+            if (!p.isCancel(selectedThinking)) {
+                setModelThinkingLevel(selectedModel, selectedThinking);
+                if (typeof chat.setThinkingLevel === 'function') {
+                    chat.setThinkingLevel(selectedThinking);
+                }
+                p.log.success(`Model successfully switched to ${pc.cyan(selectedModel)} with thinking level ${pc.cyan(selectedThinking)}`);
+            }
+            else {
+                if (typeof chat.setThinkingLevel === 'function') {
+                    chat.setThinkingLevel(activeModelThinking);
+                }
+                p.log.success(`Model successfully switched to ${pc.cyan(selectedModel)}`);
+            }
         }
         return { shouldContinue: true };
     }
@@ -149,7 +183,10 @@ export async function handleSlashCommand(command, context) {
     if (lowerCommand === '/debug') {
         const debugMode = toggleDebugMode();
         if (debugMode) {
-            p.log.info('Debug mode enabled. Internal logs will now be shown.');
+            const currentModel = chat.getModel();
+            const currentThinkingLevel = (typeof chat.getThinkingLevel === 'function' ? chat.getThinkingLevel() : undefined) ||
+                getModelThinkingLevel(currentModel);
+            p.log.info(`Debug mode enabled. Active Model: ${pc.cyan(currentModel)} (thinking: ${pc.cyan(currentThinkingLevel)}). Internal logs will now be shown.`);
         }
         else {
             p.log.info('Debug mode disabled.');
@@ -210,12 +247,15 @@ export async function handleSlashCommand(command, context) {
         else {
             displayModel = modelStatsStr || currentModel;
         }
+        const currentThinkingLevel = (typeof chat.getThinkingLevel === 'function' ? chat.getThinkingLevel() : undefined) ||
+            getModelThinkingLevel(currentModel);
         const autoApprove = getApprovalMode() === 'skip-all' ? 'Enabled' : 'Disabled';
         const subAgents = isSubAgentsEnabled() ? 'Enabled' : 'Disabled';
         const byokEnabled = (await isByokEnabled()) ? 'Enabled' : 'Disabled';
         p.log.step(pc.magenta('📊 Session Statistics & Status'));
         console.log(pc.dim('----------------------------------------'));
         console.log(`${pc.bold('AI Model:')}         ${pc.cyan(displayModel)}`);
+        console.log(`${pc.bold('Thinking Level:')}   ${pc.cyan(currentThinkingLevel)}`);
         console.log(`${pc.bold('Auto-Approve:')}     ${autoApprove === 'Enabled' ? pc.green(autoApprove) : pc.yellow(autoApprove)}`);
         console.log(`${pc.bold('Sub-Agents:')}       ${subAgents === 'Enabled' ? pc.green(subAgents) : pc.yellow(subAgents)}`);
         console.log(`${pc.bold('BYOK:')}             ${byokEnabled === 'Enabled' ? pc.green(byokEnabled) : pc.yellow(byokEnabled)}`);
@@ -1024,10 +1064,10 @@ Output ONLY the raw commit message text. Absolutely NO conversational preambles,
 
 Strict Formatting Rules:
 1. First line must follow Conventional Commits format: type(scope): description
-   - Allowed types: feat, fix, refactor, test, docs, chore, perf, style
-   - Subject line must be in imperative mood (e.g. "add support for...", "fix bug in...") and strictly under 50 characters.
+   - Allowed types: feat, fix, refactor, test, docs, chore, perf, style, etc
+   - Subject line must be in imperative mood (e.g. "added support for...", "fixed bug in...") and strictly under limited characters.
 2. Leave a single blank line after the subject.
-3. Provide a concise bulleted list (using '-' or '*') explaining the architectural "what" and "why" of the changes based on the provided diff. If diff spans multiple areas, prioritize the primary architectural change.`;
+3. Provide a concise bulleted list (using '-' or '*') explaining the architectural "what" and "why" of the changes based on the provided diff.`;
             const commitAgent = new ProxyChatSession(GEMINI_MODELS.FLASH_LITE, commitSystemPrompt, [], {});
             const commitResult = await commitAgent.sendMessage(prompt);
             let commitMsg = commitResult.response.text().trim();

package/dist/services/agent/syntaxAgent.js

@@ -1,6 +1,7 @@
 import { ProxyChatSession } from '../ai.js';
 import { GEMINI_MODELS, MAX_OUTPUT_TOKENS } from '../../utils/config.js';
 import { localValidate } from '../../utils/localSyntaxValidator.js';
+import { debugLog } from '../../utils/logger.js';
 /**
  * Extracts a numeric character position from a syntax error message if present.
  */
@@ -100,6 +101,9 @@ Your job is to fix syntax errors in source code snippets extracted from large fi
             const snippetChat = new ProxyChatSession(model, snippetSystemInstruction, [], {
                 maxOutputTokens: MAX_OUTPUT_TOKENS,
                 temperature: 0.1,
+                thinkingConfig: {
+                    thinkingLevel: 'LOW',
+                },
             });
             const snippetPrompt = `File Path: ${filePath}
 Line Range: Lines ${win.startLine} to ${win.endLine} (Error near position ${errorPos})
@@ -109,6 +113,7 @@ Code Snippet to Repair:
 ${win.snippet}
 
 Please fix the syntax error in the snippet above and return ONLY the raw repaired code snippet:`;
+            debugLog(`Attempting AI snippet syntax repair for ${filePath} with model ${model} (thinking: LOW)...`);
             try {
                 const result = await snippetChat.sendMessage(snippetPrompt, undefined, abortSignal);
                 const repairedSnippet = cleanOutput(result.response.text());
@@ -145,6 +150,9 @@ Your sole job is to read source code and verify or repair its syntax.
     const fullChat = new ProxyChatSession(model, fullSystemInstruction, [], {
         maxOutputTokens: MAX_OUTPUT_TOKENS,
         temperature: 0.1,
+        thinkingConfig: {
+            thinkingLevel: 'LOW',
+        },
     });
     const fullPrompt = `File Path: ${filePath}
 
@@ -153,6 +161,7 @@ ${effectiveError}
 
 Content:
 ${content}`;
+    debugLog(`Attempting AI full syntax repair for ${filePath} with model ${model} (thinking: LOW)...`);
     try {
         const result = await fullChat.sendMessage(fullPrompt, undefined, abortSignal);
         const output = cleanOutput(result.response.text());
@@ -215,6 +224,9 @@ Your primary job is to perform fuzzy search matching and replacement on source c
     const chat = new ProxyChatSession(model, systemInstruction, [], {
         maxOutputTokens: MAX_OUTPUT_TOKENS,
         temperature: 0.1,
+        thinkingConfig: {
+            thinkingLevel: 'LOW',
+        },
     });
     const prompt = `File Path: ${filePath}
 
@@ -226,6 +238,7 @@ ${replaceContent}
 
 File Content:
 ${fileContent}`;
+    debugLog(`Attempting AI fuzzy search and replace for ${filePath} with model ${model} (thinking: LOW)...`);
     try {
         const response = await chat.sendMessage(prompt, undefined, options.abortSignal);
         const rawOutput = response.response.text();

package/dist/services/agent-tools.d.ts

@@ -87,7 +87,7 @@ export declare function consumeSkipOnce(): void;
  * @param targetElements - Optional array of specific symbol or function names to extract.
  * @returns A promise resolving to a {@link ToolResult} containing the file content or error details.
  */
-export declare function readFile(workspaceRoot: string, filePath: string, startLine?: number, endLine?: number, targetElements?: string[]): Promise<ToolResult>;
+export declare function readFile(workspaceRoot: string, filePath: string, startLine?: number, endLine?: number, targetElements?: string[], outlineOnly?: boolean): Promise<ToolResult>;
 /**
  * Creates a new file or completely overwrites an existing file with the provided content,
  * performing local syntax validation and iterative AI syntax auto-correction if validation fails.

package/dist/services/agent-tools.js

@@ -570,7 +570,7 @@ async function getIgnoredPaths(workspaceRoot) {
  * @param targetElements - Optional array of specific symbol or function names to extract.
  * @returns A promise resolving to a {@link ToolResult} containing the file content or error details.
  */
-export async function readFile(workspaceRoot, filePath, startLine, endLine, targetElements) {
+export async function readFile(workspaceRoot, filePath, startLine, endLine, targetElements, outlineOnly) {
     try {
         const absPath = resolveAndValidatePath(workspaceRoot, filePath);
         // Check if file is explicitly ignored
@@ -1809,7 +1809,7 @@ export async function executeTool(workspaceRoot, toolName, args, abortSignal) {
             break;
         }
         case 'read_file':
-            result = await readFile(effectiveRoot, resolvedArgs.filePath, resolvedArgs.startLine, resolvedArgs.endLine, resolvedArgs.targetElements);
+            result = await readFile(effectiveRoot, resolvedArgs.filePath, resolvedArgs.startLine, resolvedArgs.endLine, resolvedArgs.targetElements, resolvedArgs.outlineOnly);
             // Record successful reads so the file-read guard allows subsequent modify_file calls
             if (!result.error) {
                 recordFileRead(resolvedArgs.filePath);

package/dist/services/agent.js

@@ -26,7 +26,7 @@ const execAsync = promisify(exec);
 import { debugLog, isDebugOn } from '../utils/logger.js';
 import { ensureProjectStorage, ensureIgnored, readCache, writeCache, invalidateCacheForDependents, } from '../utils/projectStorage.js';
 import { GEMINI_MODELS, TPM_COOLING_DELAYS } from '../utils/config.js';
-import { createSharedChatSession, getGeneralChatConfig, getPlanExecutionConfig, compressTextUsingFlashLite, generateChatTitle, getGlobalActiveModel, summarizeChatHistory, } from './ai.js';
+import { createSharedChatSession, getGeneralChatConfig, getPlanExecutionConfig, compressTextUsingFlashLite, generateChatTitle, getGlobalActiveModel, getModelThinkingLevel, summarizeChatHistory, } from './ai.js';
 import { getAndResetTurnUsage } from './proxyClient.js';
 import { changeLogger } from './changeLogger.js';
 import { chatHistoryService } from './chatHistoryService.js';
@@ -35,7 +35,7 @@ import { verifyChangedFiles } from './verificationService.js';
 import { buildContextInjection } from '../utils/contextPrompts.js';
 import { registerContextFiles } from '../utils/fileReadGuard.js';
 import { historyText } from '../utils/historyPrompt.js';
-import { loadUserProfile, formatUserProfileForContext, extractAndSaveUserInsights, } from './userProfileService.js';
+import { loadUserProfile, formatUserProfileForContext, extractAndSaveUserInsights } from './userProfileService.js';
 // Submodule Imports
 import { AsyncInputHandler } from './agent/inputHandler.js';
 import { processResponse } from './agent/toolLoop.js';
@@ -164,7 +164,7 @@ export async function startAgentLoop(workspaceRoot, version) {
         }
         inputHandler.stop();
         // Input collection (delegated to a helper function to avoid nested loop warning)
-        const { userInput: rawInput, canceled } = await collectUserInput(sessionInputHistory);
+        const { userInput: rawInput, canceled } = await collectUserInput(sessionInputHistory, workspaceRoot);
         if (canceled) {
             p.outro(pc.green('Goodbye! Happy coding. 🚀'));
             return;
@@ -402,6 +402,78 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                     collector.recordCompressedContextSize(contextInjection.length);
                 dynamicSystemInstruction += '\n\n' + contextInjection;
             }
+            // Resolve and inject explicit @ Context Mentions (files, symbols, git diffs, diagnostics, external workspaces)
+            try {
+                const { mentionEngine } = await import('./mentionEngine.js');
+                const resolvedMentions = await mentionEngine.resolveMentions(userInput, workspaceRoot);
+                if (resolvedMentions.hasMentions) {
+                    const isPrompting = inputHandler.isCurrentlyPrompting();
+                    if (!isPrompting) {
+                        spinner.stop();
+                    }
+                    for (const item of resolvedMentions.mentions) {
+                        if (item.resolved) {
+                            const label = item.statusLabel ? ` ${pc.dim(`(${item.statusLabel})`)}` : '';
+                            p.log.step(`${pc.green('✔')} Context ${pc.cyan(item.mention.raw)}${label}`);
+                        }
+                        else {
+                            const reason = item.error ? ` ${pc.dim(`(${item.error})`)}` : '';
+                            p.log.warn(`${pc.red('✖')} Context ${pc.yellow(item.mention.raw)}${reason}`);
+                        }
+                    }
+                    if (!isPrompting) {
+                        spinner.start('Preparing agent configuration...');
+                    }
+                    if (resolvedMentions.formattedContext) {
+                        debugLog(`Resolved ${resolvedMentions.mentions.length} context mention(s) (${resolvedMentions.totalTokens} tokens estimated)`);
+                        dynamicSystemInstruction += '\n\n' + resolvedMentions.formattedContext;
+                        // Pre-register all resolved file mention paths with the read-guard
+                        const mentionedFiles = resolvedMentions.mentions
+                            .filter((m) => m.mention.type === 'file' && m.resolved)
+                            .map((m) => m.mention.target);
+                        if (mentionedFiles.length > 0) {
+                            registerContextFiles(mentionedFiles);
+                        }
+                    }
+                }
+                // Also resolve mentions from any chained follow-up instructions received during investigation
+                if (gatherRes.chainedMessages.length > 0) {
+                    const chainedContent = gatherRes.chainedMessages.join('\n');
+                    const chainedMentions = await mentionEngine.resolveMentions(chainedContent, workspaceRoot);
+                    if (chainedMentions.hasMentions) {
+                        const isPrompting = inputHandler.isCurrentlyPrompting();
+                        if (!isPrompting) {
+                            spinner.stop();
+                        }
+                        for (const item of chainedMentions.mentions) {
+                            if (item.resolved) {
+                                const label = item.statusLabel ? ` ${pc.dim(`(${item.statusLabel})`)}` : '';
+                                p.log.step(`${pc.green('✔')} Chained Context ${pc.cyan(item.mention.raw)}${label}`);
+                            }
+                            else {
+                                const reason = item.error ? ` ${pc.dim(`(${item.error})`)}` : '';
+                                p.log.warn(`${pc.red('✖')} Chained Context ${pc.yellow(item.mention.raw)}${reason}`);
+                            }
+                        }
+                        if (!isPrompting) {
+                            spinner.start('Preparing agent configuration...');
+                        }
+                        if (chainedMentions.formattedContext) {
+                            debugLog(`Resolved ${chainedMentions.mentions.length} chained context mention(s) (${chainedMentions.totalTokens} tokens estimated)`);
+                            dynamicSystemInstruction += '\n\n' + chainedMentions.formattedContext;
+                            const chainedFiles = chainedMentions.mentions
+                                .filter((m) => m.mention.type === 'file' && m.resolved)
+                                .map((m) => m.mention.target);
+                            if (chainedFiles.length > 0) {
+                                registerContextFiles(chainedFiles);
+                            }
+                        }
+                    }
+                }
+            }
+            catch (mentionErr) {
+                debugLog(`Context mention resolution encountered an error: ${mentionErr?.message || mentionErr}`);
+            }
             // Inject global adaptive user persona and learned preferences
             try {
                 const userProfile = await loadUserProfile();
@@ -429,10 +501,20 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                     selectedModel = complexity === 'EASY' ? GEMINI_MODELS.FLASH_LITE : GEMINI_MODELS.FLASH;
                 }
                 chat.setModel(selectedModel);
-                debugLog(`Auto-routing to model ${selectedModel} based on intent ${effectiveTargetAgent}`);
+                const thinkingLevel = getModelThinkingLevel(selectedModel);
+                if (typeof chat.setThinkingLevel === 'function') {
+                    chat.setThinkingLevel(thinkingLevel);
+                }
+                debugLog(`Auto-routing to model ${selectedModel} (thinking: ${thinkingLevel}) based on intent ${effectiveTargetAgent}`);
             }
             else {
-                chat.setModel(getGlobalActiveModel());
+                const activeModel = getGlobalActiveModel();
+                chat.setModel(activeModel);
+                const thinkingLevel = getModelThinkingLevel(activeModel);
+                if (typeof chat.setThinkingLevel === 'function') {
+                    chat.setThinkingLevel(thinkingLevel);
+                }
+                debugLog(`Active model set to ${activeModel} (thinking: ${thinkingLevel})`);
             }
             if (ac.signal.aborted) {
                 spinner.stop();
@@ -599,6 +681,10 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
             // Send the formulated prompt payload to the generative model
             let result;
             try {
+                const activeModel = chat.getModel();
+                const currentThinking = (typeof chat.getThinkingLevel === 'function' ? chat.getThinkingLevel() : undefined) ||
+                    getModelThinkingLevel(activeModel);
+                debugLog(`Dispatching turn to model ${activeModel} (thinking: ${currentThinking})`);
                 result = await chat.sendMessage(finalInput, undefined, ac.signal);
             }
             catch (e) {
@@ -794,14 +880,40 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
         }
     });
 }
-async function collectUserInput(history) {
+async function collectUserInput(history, workspaceRoot = process.cwd()) {
     let lines = [];
     let isMultiLine = false;
     while (true) {
         const userInputRaw = await historyText({
             message: isMultiLine ? '  ' : pc.magenta('❯'),
-            placeholder: isMultiLine ? '' : 'Use ' + String.fromCharCode(92) + ' for new lines',
+            placeholder: isMultiLine
+                ? ''
+                : 'Use ' + String.fromCharCode(92) + ' for new lines or @ to mention file paths and more',
             history,
+            autocomplete: {
+                workspaceRoot,
+                getSuggestions: async (query) => {
+                    try {
+                        const { mentionEngine } = await import('./mentionEngine.js');
+                        const suggestions = await mentionEngine.getSuggestionsForQuery(query, { workspaceRoot });
+                        return suggestions.map((s) => ({
+                            value: s.value,
+                            label: s.label,
+                            category: s.category,
+                            description: s.description,
+                            metadata: {
+                                filePath: s.filePath,
+                                symbol: s.label,
+                                helperLabel: s.helperLabel,
+                                symbolKind: s.symbolKind,
+                            },
+                        }));
+                    }
+                    catch {
+                        return [];
+                    }
+                },
+            },
         });
         if (p.isCancel(userInputRaw)) {
             if (isMultiLine) {

package/dist/services/ai.d.ts

@@ -1,9 +1,23 @@
 import { type Content, type FunctionCall } from '@google/generative-ai';
+import { type ThinkingLevel } from '../utils/config.js';
 export declare function getMultiWorkspaceBlock(): string;
 export declare function setModelOverride(agent: 'context' | 'execution', overrideStr: string): void;
 export declare function clearModelOverrides(): void;
 export declare function setGlobalActiveModel(model: string): void;
 export declare function getGlobalActiveModel(): string;
+/**
+ * Gets the thinking reasoning level configured for a specific model or active model.
+ * Falls back to default model thinking levels or 'MEDIUM' if not explicitly configured.
+ */
+export declare function getModelThinkingLevel(model?: string): ThinkingLevel;
+/**
+ * Sets the user-configured thinking reasoning level for a specific model.
+ */
+export declare function setModelThinkingLevel(model: string, level: ThinkingLevel): void;
+/**
+ * Resets user-configured thinking levels back to default model presets.
+ */
+export declare function resetModelThinkingLevels(): void;
 export declare class ProxyChatSession {
     private history;
     private fullHistory;
@@ -12,6 +26,7 @@ export declare class ProxyChatSession {
     private tools;
     private toolConfig?;
     private generationConfig;
+    private configuredThinkingLevel?;
     private latestUsageMetadata;
     constructor(modelName: string, systemInstruction: string, tools: any[], generationConfig: any, toolConfig?: any);
     getLatestUsageMetadata(): any;
@@ -20,6 +35,10 @@ export declare class ProxyChatSession {
     getToolConfig(): any;
     setModel(modelName: string): void;
     getModel(): string;
+    setThinkingLevel(level: ThinkingLevel): void;
+    getThinkingLevel(): ThinkingLevel | undefined;
+    setGenerationConfig(generationConfig: any): void;
+    getGenerationConfig(): any;
     clearHistory(): void;
     getRawHistory(): Content[];
     getFullHistory(): Content[];