⚡ Minovative Mind CLI

The Autonomous AI Coding Agent Powered by Precision Context & Formal Verification.

Ship production-grade features in minutes, not hours. Zero token markups, mathematical deductive proofs, and sub-5ms AST dependency intelligence directly in your terminal.

# 🚀 Get started in under 60 seconds:
npm install -g minovative-mind-cli@latest
minovative-mind-cli login
minovative-mind-cli chat

📑 Table of Contents

• 🚀 Quick Start
• 💡 Why Minovative Mind?
• ⚡ Core Pillars & Architecture
  • Pillar I: Precision Context & Materialized AST Tracing
  • Pillar II: Deductive Formal Verification & Sandboxed Fuzzing
  • Pillar III: Multi-Agent Swarms & Plan-Driven Roadmaps
  • Pillar IV: Workstation Protection & Self-Healing Resilience
• ⌨️ Interactive CLI Experience
  • Slash Commands (/)
  • Precision Context Mentions (@)
• 💰 Transparent, Zero-Markup Pricing
• 🔒 Enterprise-Grade Security & Privacy
• 📚 Documentation & Architectural Deep Dives
• ⚖️ Legal & License

🚀 Quick Start

Get up and running with Minovative Mind CLI in three simple steps:

1. Installation

Install the global CLI via npm:

npm install -g minovative-mind-cli@latest

[!TIP] To update an existing installation to the latest version at any time, run npm update -g minovative-mind-cli.

2. Authentication

Authenticate your GitHub account and activate your workspace session:

minovative-mind-cli login

3. Launch Interactive Chat & Configure BYOK

Navigate to your project repository and fire up the agent:

cd /path/to/your/project
minovative-mind-cli chat

Configure your Google AI Studio API key (obtain a free key at Google AI Studio):

/config-key

Your API key is securely encrypted in your operating system's native keychain (AES-256-GCM) and remains active across sessions.

💡 Why Minovative Mind? (The Paradigm Shift)

Traditional AI coding assistants dump entire directory trees into bloated prompt windows, hallucinate broken imports, and charge you a 300% markup on token credits.

Minovative Mind CLI is engineered from the ground up for software craftspeople who demand mathematical accuracy, predictable blast radiuses, and transparent wholesale pricing.

| Feature / Metric | Traditional AI Assistants | Minovative Mind CLI | | :--- | :--- | :--- | | Context Strategy | ❌ Raw full-file dumps causing token bloat & forgetfulness | ✅ Precision-Context Verification (PCV): 85–95% token compression via AST skeletons | | Dependency Awareness | ❌ Naive grep searches; misses transitive dependents | ✅ Materialized Dependency Graphs: Persistent SHA-256 disk cache with sub-5ms cold starts | | Execution & Planning | ❌ Ephemeral mental state with context drift & amnesia | ✅ Plan-Driven UI & Persistent Roadmaps: Interactive terminal checklists, markdown blueprints as single source of truth (create_plan, read_plan) | | System Host Safety | ❌ Rogue compilers freeze your machine; swap thrashing & lag | ✅ Process & Resource Supervisor (PRS): Dynamic RAM ceilings (25% host RAM), CPU priority demotion (nice 10), tree killing, zero freezes | | Session Continuity | ❌ Corrupted thought signatures crash turns & lose context | ✅ Cryptographic Thought Signature Engine: Visible text disambiguation + self-healing retry on API errors | | Verification Method | ❌ "Looks good to me" probabilistic guessing | ✅ Deductive Formal Proofs: Machine-checked Lean 4 invariants & sandboxed fuzzing | | Pricing & Margins | ❌ $20–$50/mo seat fees or inflated token markups | ✅ $3.99/mo Flat Platform Fee + direct wholesale BYOK (Google AI Studio) | | Agent Concurrency | ❌ Single-threaded serial execution | ✅ MMAAK Engine: Parallel multi-agent swarms with virtual patch staging & blackboard cards | | Search Dumps | ❌ Prompt overflow from noisy grep/build outputs | ✅ Scratchpad Manager: Paginated line/byte slicing with bounded 50MB footprint | | Workspace Control | ❌ Unbounded directory wandering | ✅ Session-Scoped Workspace Whitelisting: Deterministic multi-repo isolation |

⚡ Core Pillars & Architecture

Pillar I: Precision Context & Materialized AST Tracing

🎯 1. Precision-Context Verification (PCV Engine)

Don't waste context on boilerplate. Our AST skeleton extractor isolates only the type definitions, function signatures, and exported interfaces needed for the task—slashing token consumption by 85–95% while dramatically increasing model reasoning precision.

🏎️ 2. Sub-5ms Materialized Dependency Tracing

Know the exact blast radius of every change before modifying a single line. With bidirectional import tracing across 11 language profiles (TypeScript, JavaScript, Python, Go, Rust, C/C++, Java, Ruby, PHP, Clojure, Lean 4) and tri-factor SHA-256 file fingerprinting, cold-start rehydration is virtually instantaneous.

Pillar II: Deductive Formal Verification & Sandboxed Fuzzing

🔬 3. Machine-Checked Deductive Proofs (Lean 4)

Move beyond probabilistic unit tests. Minovative Mind integrates Lean 4 formal theorem verification (verify_formal_proof) to formally verify algorithms, mathematical bounds, and state machine invariants without shortcuts, mocks, or bypasses.

🛡️ 4. Sandboxed Dynamic Verification Suite

Every change is rigorously validated in sandboxed OS temp storage (os.tmpdir()):

• Automated Property Fuzzing (run_fuzz_probe): Boundary testing with randomized deterministic seeds.
• Heap Memory Delta Inspection (check_heap_delta): Proactively catches memory leaks before they reach staging.
• Behavioral Drift Checks (check_behavioral_drift): Side-by-side candidate execution to prevent regressions.
• Static Heuristic Performance Auditing: Real-time enforcement against anti-patterns (O(n²) loops, unbounded queries, chained allocations).

Pillar III: Multi-Agent Swarms & Plan-Driven Roadmaps

🤝 5. Multi-Agent Swarm Orchestration (MMAAK Engine)

Turn complex refactors into parallelized workflows. The Multi-Model Autonomous Agent Kernel (MMAAK) decomposes objectives into acyclic dependency graphs (DAGs), initializes persistent markdown roadmaps (.minovativemind/scratchpad/plans/orchestration_plan.md), dynamically checks off completed wave milestones (- [x]), coordinates sub-agents via inter-agent blackboard cards, and resolves concurrent file edits using atomic two-phase virtual patch staging.

🗺️ 6. Plan-Driven UI & Markdown Roadmap Single Source of Truth

Never wonder what your AI is doing or whether it forgot its plan. Execution plans are persistent markdown roadmaps on disk (.minovativemind/scratchpad/plans/) that serve as the single source of truth for both technical specifications and live interactive terminal UI checklist rendering.

• Interactive Terminal Checklist UI (renderPlanChecklistUI): Watch phases unfold in real-time with vibrant status indicators: [x] (completed in green), [/] (in progress in yellow), [!] (failed in red), and [ ] (pending in dim), dynamically grouped by markdown phase headers (## Phase 1...).
• Advanced Markdown Parsing Engine (planParser.ts): Supports full lifecycle manipulation (extractPlanChecklist, updateChecklistItemStatus, formatTasksAsMarkdownPlan), mapping indices and task text to checkboxes across - [ ], * [x], + [/], and 1. [!].
• Legacy Compatibility Shims & Tool Scoping: Existing create_todo_list calls are transparently bridged to persistent markdown plans, while execution agents are scoped to create_plan and update_plan_progress to slash token overhead.
• Execution Agent Rule 0: Mandates roadmap creation on Turn 1, ensuring every refactor and feature has explicit contracts, state invariants, and rollback boundaries.

Pillar IV: Workstation Protection & Self-Healing Resilience

🧊 7. Host Resource Governance & Anti-Freeze Protection (PRS)

Safeguard your developer workstation from runaway compilers, memory leaks, fork bombs, and system lockups. The Process & Resource Supervisor (PRS) guarantees that autonomous tasks never monopolize your hardware, ensuring even lower-spec machines (such as 8 GB Apple Silicon M1 MacBooks) run smoothly without desktop freezing, mouse pointer stutter, or forced hard power reboots:

• Cross-Platform Tree Termination (treeKiller.ts): Spawns subprocesses in detached process groups (-pgid on POSIX) and executes recursive pgrep -P descendant discovery and Windows taskkill /PID /T /F to eliminate orphaned compilers. Standard I/O streams are forcefully destroyed to eliminate 64 KB kernel pipe-buffer deadlocks.
• Active RSS Memory Watchdogs (memoryWatchdog.ts): Polls Resident Set Size every 250ms via ps -o rss= and enforces dynamic physical-RAM ceilings (calculateDynamicMemoryCeilingBytes: 20–25% of RAM, capped between 512MB and 4GB). Exceeded processes are terminated via SIGKILL before OS swap thrashing occurs.
• CPU Scheduling Priority Demotion (nice 10): Demotes heavy subprocesses to background priority (os.setPriority(pid, 10)), guaranteeing that WindowServer, your IDE, and browser retain full CPU responsiveness.
• Static Command Safety & Daemon Neutralization: Proactively blocks persistent dev servers (npm run dev, vite, next dev) and infinite watch flags (--watch), while neutralizing Gradle (--no-daemon), Maven (-Dmaven.compiler.fork=false), Jest (--runInBand), Vitest (--no-file-parallelism), and Docker (--rm).
• Inter-Wave Process Sweeping & File Safeguards: Reaps lingering zombie compilers between orchestration waves, cleans up stale .git/index.lock files, and enforces strict in-process Node memory shields (5MB file size limit, 15-level directory traversal cap, circular symlink cycle detection).

🧠 8. Cryptographic Thought Signature Preservation & Recovery

Ensure uninterrupted reasoning continuity when pairing with Google Gemini's frontier thinking models:

• Cryptographic Signature Preservation: Gemini 3.x models attach cryptographic HMAC signatures (thoughtSignature / thought_signature) to reasoning tokens and tool calls. Minovative Mind CLI guarantees that signatures are preserved intact throughout multi-turn tool loops.
• Visible Text Disambiguation (extractModelTurnText): Gemini attaches thought signatures to final visible conversational text responses as well as internal thoughts. Our semantic parser discriminates between internal reasoning (p.thought === true) and visible output, guaranteeing that model answers and explanations are never accidentally filtered out.
• Self-Healing Thought Signature Recovery: If Google's API rejects a turn with an HTTP 400 "Corrupted thought signature" error, the CLI automatically detects the rejection, strips stale/corrupted signatures across history (stripThoughtSignaturesFromContents), and retries the generation turn seamlessly without crashing or aborting your workflow.

⌨️ Interactive CLI Experience

Command the AI agent with surgical precision directly within your terminal prompt:

⚡ Slash Commands (/)

| Command | Category | Description | | :--- | :--- | :--- | | /config-key | Configuration | Configure, inspect, or clear your custom Google AI Studio BYOK key | | /models | AI & Reasoning | Hot-swap active reasoning models (Gemini 3.8 / 3.7 Flash, Pro, Thinking budgets) | | /sub-agents | Swarm Execution | Toggle parallel MMAAK multi-agent swarm orchestration | | /auto-approve| Automation | Toggle automatic tool approval for headless autonomous execution | | /workspaces | Multi-Repo | Whitelist and manage cross-repository workspace aliases (@alias/) | | /commit | Git & Changes | Inspect git diffs and auto-generate clean Conventional Commit messages | | /revert | Git & Changes | Interactive undo/revert menu powered by disk-backed transaction ledgers | | /chats | Sessions | Search, resume, export, or manage persistent JSONL conversation sessions | | /clear | Sessions | Clear chat history and reset session state | | /profile | Memory & Traits| Inspect or curate adaptive persona traits (Tier 1) and repo project memory (Tier 2) | | /stats | Telemetry | View real-time session telemetry, token savings, and cache hit metrics | | /paste | Input | Enter multi-line paste mode for large snippets, logs, and prompt drafts (Ctrl+D to submit) | | /debug | Diagnostics | Toggle verbose diagnostic logs and real-time telemetry tracing | | /help | Help | Display interactive help menu with all available commands | | stop | Execution | Instantly abort running tool executions or AI model generation turns | | exit / quit| Session | Gracefully terminate and exit the CLI session |

🎯 Precision Context Mentions (@)

Tag exact code symbols, files, and environmental state without manual copy-pasting:

| Mention Syntax | Target | Description | | :--- | :--- | :--- | | @file:src/services/agent.ts | Whole File | Injects complete file contents with AST skeleton compression | | @src/routes.ts:10-45 | Line Slice | Injects a precise slice of line numbers directly into context | | @symbol:startAgentLoop | Symbol AST | Injects exact declaration and interface ASTs (also supports @#symbolName) | | @git:diff | Unstaged Changes | Feeds current working tree diffs into agent context | | @git:staged | Staged Changes | Feeds staged git index patches into agent context | | @diagnostics | LSP & Compilers | Attaches active LSP, compiler, and linter diagnostic error frames | | @terminal | Terminal Buffer | Injects latest terminal output and recent command execution logs | | @alias/src/model.ts | External Repo | Cross-references files from external registered workspaces |

💰 Transparent, Zero-Markup Pricing

Why pay middleman markups on LLM tokens? We believe developers should have direct access to frontier models at wholesale cost.

| Plan | Platform Fee | AI Token Cost | Included Features | | :---: | :---: | :---: | :--- | | Standard Pro | $3.99 / month | $0 Markup (BYOK) | Full PCV & MMAAK Engines, 19 Execution Tools, Lean 4 Verification, Multi-Workspace, Scratchpad Storage |

🎁 Special Launch Offer: Use promo code MMCLI at checkout to get 1 Month Free!

[!NOTE] How BYOK Works: Minovative Mind CLI defaults to BYOK mode first. Simply plug in your free or paid Google AI Studio API key via /config-key (or export GEMINI_API_KEY). Your key is saved locally in OS secure storage and automatically remains active across logins and logouts. You pay Google directly at raw wholesale rates (e.g. Gemini 3.7 Flash / Gemini 3.5 Flash / Pro) with zero markup, rate-limit throttling, or hidden fees.

🔒 Enterprise-Grade Security & Privacy

Your code is your most valuable intellectual property. Minovative Mind CLI is designed with a privacy-first zero-trust architecture:

• 🛡️ 100% Client-Side Encryption: Custom API keys and credentials are encrypted on your local machine using your operating system's native secure keychain (AES-256-GCM).
• 🚫 Zero Code Retention: We never store, index, or train on your source code. Requests travel directly to the underlying model provider.
• 🚷 Hardened Sandbox Isolation: All dynamic debugging, test runs, and fuzzing probes execute in isolated temporary directories (os.tmpdir()) with non-interactive subshell protections and strict sudo bans.
• 🔐 Anti-Cheating Guardrails: Strict policy engine blocks unauthorized configuration modifications (tsconfig.json, next.config.js) and proof bypasses (sorry, @ts-ignore).
• 🧊 Host Anti-Freeze Resource Shields (PRS): Dynamic physical RAM ceilings (1–4 GB), CPU background priority demotion (nice 10), active RSS polling (250ms), and detached process group tree termination (-pgid + taskkill /T /F) prevent runaway child compilers from consuming excessive memory or locking up your computer.
• 🔄 Self-Healing Session Resilience: Automated thought signature recovery intercepts Google API 400 rejections, strips corrupted tokens, and heals session history in-flight with zero data loss.

📚 Documentation & Architectural Deep Dives

Explore our in-depth technical documentation and engine specifications:

• 🏛️ System Architecture — Comprehensive technical architecture, runtime pipelines, and subsystem layouts.
• ⚡ Features Specification — Exhaustive catalog of tools, capabilities, and system specifications.
• 🎯 PCV Engine Specification — Precision-Context Verification AST skeleton extraction and compression mechanics.
• 🤝 MMAAK Engine Specification — Multi-agent swarm DAG scheduling and virtual patch staging.
• 🚀 Performance & Scaling Guide — Workstation resource optimization and tuning guide.
• 📝 Project Changelog — Version history, updates, and release notes.

⚖️ Legal & License

• 📜 License — Proprietary / All rights reserved.
• 📄 Terms of Service — Platform terms of service.
• 🔐 Privacy Policy — Data protection and privacy guarantees.

Built with precision for developers who build the future.
© 2026 Minovative Mind. All rights reserved.