=== LolaCore – AI Admin Agent ===
Contributors: vanguardhive
Tags: ai agent, woocommerce, ai assistant, automation, admin
Requires at least: 7.0
Tested up to: 7.0
Requires PHP: 8.0
Stable tag: 1.6.3
License: GPLv2 or later
License URI: https://www.gnu.org/licenses/gpl-2.0.html

The AI admin for WordPress 7.0 that doesn't forget. Executes 52 actions through chat — every change confirmed before it runs.

== Description ==

Every AI tool you've used to manage WordPress has the same problem: amnesia. You open a chat, explain your setup, get a useful answer — and tomorrow it's all gone. New session, same questions, same context dump. Multiply that by 10 client sites and you've lost your morning.

LolaCore fixes this with something no other AI plugin for WordPress has: **a memory that persists across sessions, built natively on the WordPress 7.0 AI Client and the new Abilities API.**

Her name is Lola. She lives inside your wp-admin, scans your site on first launch, and remembers what she finds — not for one conversation, but permanently. Plugin conflicts from last month. Database cleanup you ran on Tuesday. The SEO fix you asked about in March. She retains it all, and the irrelevant stuff fades naturally over time. Important events anchor themselves. Noise disappears.

The result: **every conversation picks up where the last one left off.** No context window resets. No copy-pasting your plugin list into ChatGPT for the fifth time this week.

= What Lola is NOT =

Lola is not a content generator. She doesn't write blog posts, invent marketing copy, or hallucinate data she doesn't have. She doesn't browse the web, scrape pages, or fetch arbitrary URLs. She doesn't touch your theme files or edit PHP.

Lola is a site admin who happens to be an AI. She reads real data from your WordPress database, reasons about it, and executes real actions — with your explicit approval, every single time.

If you want an AI that writes articles for you, this is the wrong plugin. If you want an AI that actually knows your site and manages it through conversation, keep reading.

For the complete picture — memory mechanics, ability reference, prompt library, and configuration walkthrough — see the [full documentation](https://lolacore.com/documentation/).

= Persistent memory =

This is the part that changes how you work.

Lola remembers facts across sessions. Plugin conflicts, security findings, your preferences, decisions you've made — stored locally in your WordPress database.

Her memory works the way human memory works: recent and important findings stay sharp, trivial details from months ago fade out, and critical events — like a fatal plugin conflict — stay forever.

When you start a new conversation, Lola already knows what happened last time. You don't re-explain your stack. You don't repeat what was decided last month. You pick up the thread.

How decay, boosting, and export/import work under the hood: [persistent memory guide](https://lolacore.com/documentation/#persistent-memory).

= 52 abilities. 8 domains. One chat. =

Lola ships with 52 built-in abilities split across 8 functional domains:

**Site diagnostics** — WordPress version, PHP status, HTTPS, database size, permalink structure, security headers, SEO audit, debug mode detection. Lola tells you what's broken before your client does.

**Plugins** — Search WordPress.org, install, activate, deactivate, update one or all at once. "Update all plugins" — done in one sentence. No clicking through 14 update screens.

**Content & metadata** — Create pages, edit posts, change status, update slugs, read and write post meta. "Create a draft page called Services with this text" — done. "Change the SEO title of post 42" — done. Works with Yoast, RankMath, and any plugin that stores data in post meta.

**Users** — Create accounts, change roles, remove users with automatic content reassignment. The kind of admin task that takes 6 clicks, solved in one sentence.

**Database maintenance** — Clean post revisions, expired transients, orphaned cron jobs, spam comments. The cleanup WordPress never does for you.

**Taxonomies, comments, media, menus, themes, options** — Read and manage across the board. Every write action requires your confirmation first.

Full breakdown of every ability with domain details: [ability reference](https://lolacore.com/documentation/#what-lola-can-do).

= WooCommerce: 13 dedicated tools =

If WooCommerce is active, Lola detects it automatically and unlocks 13 additional abilities:

* List and inspect products with price, stock, SKU, and status
* Get full order details — line items, billing, shipping, payment method
* View customer history — total spent, order count, registration date
* Browse product categories with hierarchy and product counts
* Manage coupons — create, edit, delete with discount type, limits, and expiration
* Sales reports — total revenue, net sales, taxes, items sold, and top 5 products for any period
* Create products, update prices, change order status — all from the chat

"How much revenue did we do this week?" — Lola pulls the number from your actual WooCommerce data. No dashboard required.

Full WooCommerce tool reference with examples: [WooCommerce abilities](https://lolacore.com/documentation/#woocommerce-core).

= How Lola stays safe =

**Your data never touches our servers.** There are no LolaCore servers. No telemetry. No analytics. No "anonymous usage data." Your conversations go from your hosting to your AI provider. That's it.

**Nothing happens without your approval.** Every write action — every plugin update, every post edit, every database cleanup — shows a preview card with exactly what Lola is about to do. You confirm or cancel. No background operations. No surprises.

**Every change is logged.** Before/after snapshots for every action executed. If something goes wrong, you know exactly what changed and when.

**Admin-only by design.** Lola only appears for users with full administrator capabilities. No accidental exposure to editors, authors, or subscribers.

= Any model, your choice =

Lola works natively with whatever AI provider you configure in your WordPress 7.0 settings. You are never locked into a single ecosystem. We highly recommend these agentic models for optimal performance:

* **OpenAI** — GPT-5.5, GPT-5.5 Pro
* **DeepSeek** — DeepSeek V4 Pro, DeepSeek V4 Flash
* **Anthropic** — Claude 4.6 Sonnet, Claude Opus 4.7

However, because Lola relies on the native WordPress connector, you can also use Gemini, Grok, local models via Ollama, or access thousands of models (including free ones) through OpenRouter.

You pay your provider directly. LolaCore doesn't charge per token and doesn't add a markup. The conversation goes from your WordPress server directly to your configured AI provider. Nobody else sees it.

Step-by-step setup for providers: [connecting your AI provider](https://lolacore.com/documentation/#api-provider-setup).

= Native to WordPress 7.0 =

LolaCore runs entirely on the native WordPress AI Client and Abilities API introduced in WordPress 7.0. No external HTTP libraries. No custom credential vaults maintained by one developer. No vendor folder full of third-party packages.

When WordPress updates its AI infrastructure, LolaCore updates with it. That's why we require WordPress 7.0 — and that's why the plugin stays small, fast, and current.

= Lola's lane =

A tool that does everything does nothing well. Lola is built narrow on purpose.

* She doesn't edit code — no PHP, no theme files, no server config
* She doesn't see your frontend — Lola lives inside wp-admin
* She works on one site at a time — multi-site management is on the roadmap

Why these boundaries exist and what's on the roadmap: [what Lola cannot do](https://lolacore.com/documentation/#what-lola-cannot-do).

= MCP compatible — use Lola from your IDE =

Every one of Lola's 52 abilities is exposed through the WordPress Abilities API. LolaCore now includes a bundled **Zero-Config MCP Server**.

That means you can connect Claude Desktop, Cursor, Windsurf, or any MCP-compatible client and use Lola's persistent memory, scanner, and all 52 tools without opening your browser.

Lola no longer lives just in your wp-admin. She now lives directly in your IDE. She shares the exact same persistent memory, the exact same context, and the exact same toolset. What Lola knows in the web chat, she knows in your IDE.

One engine. Two doors. The chat widget for people who think in conversations. The MCP endpoint for people who think in terminals.

= Skills: teach Lola new behaviors =

Skills are short behavioral guides written in plain Markdown. When a conversation matches certain triggers, the relevant skill loads — shaping how Lola approaches the task without granting new abilities or data access.

LolaCore ships with 10 built-in skills, active by default. You can also create your own: write a Markdown file with YAML frontmatter, import it through the settings panel, or ask Lola to build one for you directly in the chat.

Skills are Lola's judgment layer. Abilities define what she can do. Skills define how she thinks about doing it.

How skills work, trigger conditions, and the custom skills beta: [skills guide](https://lolacore.com/documentation/#skills).

= Don't know what to say? Start here. =

Lola understands natural language — no commands, no syntax. But if you want a head start, here are six prompts you can copy and paste right now:

> "Give me a quick briefing on the site — anything that needs attention today."

> "Run a complete security audit. Tell me what actually needs attention, not just a checklist."

> "Update all plugins except Elementor and [plugin name]. Show me the list first."

> "How much have we sold this week? Compare it to last week."

> "Check the database and tell me what's worth cleaning up."

> "Remember that [important fact about your site or client preference]."

These six cover diagnostics, security, plugins, WooCommerce, database, and memory. There are 42 more in the complete library — daily check-ins, content workflows, and multi-step session combos: [prompt library](https://lolacore.com/documentation/#prompt-library).

== Installation ==

1. Upload the `lolacore` folder to `/wp-content/plugins/` or install via the WordPress plugin screen.
2. Activate the plugin through the "Plugins" screen in WordPress.
3. Configure your AI provider through WordPress's built-in AI settings (Settings → AI).
4. Open the floating chat widget in your admin dashboard.
5. Start managing your site through conversation.

= Requirements =

* WordPress 7.0 or higher
* PHP 8.1 or higher
* MySQL 5.7+ or MariaDB 10.3+ (JSON column support required)
* An AI provider configured through WordPress's AI Client settings
* WooCommerce 8.0+ (optional — for store management abilities)

Detailed setup instructions and first-conversation tips: [getting started guide](https://lolacore.com/documentation/#installation).

== Frequently Asked Questions ==

= Where is my data stored? =

All data — memory facts, chat history, configuration — is stored in your WordPress database. Five dedicated tables are created on activation. Nothing is sent to external servers except your chat messages to your configured AI provider when you actively use the chat.

= What data is sent to AI providers? =

When you chat with Lola: your messages, a summary of your site scan (WordPress version, plugin list, PHP version), and relevant memory facts. Passwords, API keys, and personal user data are never included in the AI context.

= Can Lola break my site? =

Every write action requires explicit confirmation. Lola shows you exactly what she is about to do, and you approve or cancel. Safety guards prevent deactivating LolaCore itself, deleting the last administrator, and permanent content deletion without warning. All executed actions are logged with before/after snapshots.

= What happens when I deactivate the plugin? =

Deactivation clears scheduled cron events but preserves all your data. Uninstalling the plugin permanently deletes all database tables and stored options. Your choice.

= Does LolaCore work with WooCommerce? =

Yes. If WooCommerce is active, Lola automatically detects it and enables 13 additional abilities for product management, order tracking, customer data, coupons, categories, and sales reporting.

= Does LolaCore work with other plugins? =

Lola reads and writes standard WordPress data — options, post meta, users. She works alongside Yoast SEO, RankMath, ACF, Contact Form 7, and any plugin that stores data in the WordPress database.

= Can I use LolaCore for client sites? =

Yes. Install LolaCore on each client site independently. Each installation has its own memory, its own logs, its own context. Many consultants use it to speed up monthly maintenance and generate faster client reports.

= Does LolaCore work with MCP clients? =

Yes. LolaCore exposes all 52 abilities through the WordPress Abilities API. With the bundled MCP Adapter, Lola works natively as a full MCP server compatible with Claude Desktop, Cursor, Windsurf, and any MCP client. Zero extra configuration required.

= Why does LolaCore require WordPress 7.0? =

LolaCore is built entirely on the native AI Client introduced in WordPress 7.0. This eliminates external HTTP dependencies, uses WordPress's own credential management, and ensures long-term compatibility as the platform evolves. No shims, no polyfills, no fallback layers.

These are the quick answers. For 45+ questions across memory, skills, licensing, safety, and troubleshooting, see the [complete FAQ](https://lolacore.com/documentation/#faq).

== Documentation & Resources ==

This readme covers the essentials. The full documentation goes deeper — memory mechanics, the complete ability catalog with examples, a prompt library with 42 ready-to-use conversation starters, and a detailed settings walkthrough.

**[LolaCore Documentation](https://lolacore.com/documentation/)**

Key sections:

* [What is LolaCore?](https://lolacore.com/documentation/#what-is-lolacore) — Architecture, philosophy, and the agent-vs-chatbot distinction
* [Persistent Memory](https://lolacore.com/documentation/#persistent-memory) — How decay, boosting, and fact scoring work
* [Settings Panel Reference](https://lolacore.com/documentation/#settings-panel) — Every option explained
* [Ability Reference](https://lolacore.com/documentation/#what-lola-can-do) — The full table of every tool across all domains
* [Prompt Library](https://lolacore.com/documentation/#prompt-library) — 42 conversation starters organized by task
* [Frequently Asked Questions](https://lolacore.com/documentation/#faq) — 45+ answers across 12 categories
* [Extending Lola with addons](https://lolacore.com/add-ons/) — How Lola's capabilities extend into specialized domains

== Screenshots ==

1. Lola's first scan — a specific, actionable report about your site, not a generic greeting.
2. Security audit results with severity flags and fix suggestions.
3. Plugin installation through chat — Lola finds, downloads, and asks before installing.
4. Action confirmation flow — every write operation shows a preview and requires approval before executing.
5. The ability panel — 52 abilities across 8 domains, each toggleable from the settings page.

== Changelog ==

= 1.6.3 =
* Fix: Database optimization (`optimizeDatabase`) now processes revisions, spam comments, orphaned postmeta, and expired transients in safe batches of 1,000 rows — preventing timeouts and table locks on large databases with 100k+ revisions.
* Fix: Database optimization now verifies each batch for errors and stops safely on failure, reporting exactly what was cleaned and what remains.
* Improvement: Database optimization now reports actual space recovered (MB) instead of a hardcoded zero.
* Improvement: A time guard stops the cleanup at 80% of `max_execution_time` and reports partial progress — the user can run it again to continue where it left off.
* Improvement: Orphaned `wp_postmeta` rows (left behind by deleted revisions) are now cleaned automatically.
* Improvement: Expired transients are now included in the database cleanup.

= 1.6.2 =
* Fix: Gemini compatibility — empty tool-call arguments now serialize as `{}` instead of `[]`, preventing HTTP 400 errors when replaying chat history or calling no-parameter tools like `optimizeDatabase`.
* Fix: Gemini empty responses — when the intent router injected the full toolset (130+ declarations), Gemini returned candidates without content parts. Google provider requests now cap function declarations and use a discover-first toolset (`getSiteStatus`, `getDiscoveredAbilities`, `requestFullToolset`, `addMemoryFact`).
* Improvement: Google free-tier quota — the semantic intent classifier LLM call is skipped for Gemini to reduce API requests per message; quota and rate-limit errors now show a clear user-facing message instead of a generic server configuration warning.

= 1.6.1 =
* Fix: Resolved a critical issue where LolaCore's global MCP filters inadvertently blocked third-party standalone MCP servers (like `lolacore-for-elementor`) from discovering and executing their tools. Global tool filters are now strictly scoped to the LolaCore server ID.
* Fix: Prevented a JSON schema validation error ("action_id is a required property") by correctly formatting raw external tool responses (e.g. from Elementor) into the standard LolaCore action shape via `ActionExecutor`.
* Fix: Silenced a PHP 8.1 deprecation warning in the vendorized MCP adapter (`McpObservabilityHelperTrait`) that could corrupt JSON payloads when WP_DEBUG was active.

= 1.6.0 =
* Feature: Zero-Config MCP Server. LolaCore now natively bundles the Model Context Protocol (MCP) Adapter. You no longer need to install or configure external plugins to connect Lola to your IDE.
* Feature: Full IDE Parity. Lola now lives inside Cursor, Windsurf, and Claude Desktop with the exact same 52 capabilities she has in the Web Chat. The tools you enable and the domains you configure in wp-admin are instantly and perfectly mirrored in your IDE.
* Feature: Cross-Environment Persistent Memory. What Lola learns in your IDE, she remembers in the Web Chat. What you tell her in the Web Chat, she applies in Cursor. The anthropomorphization of Lola is now complete: she is a single agent, with a single memory bank, accessible through any interface you choose to work in.
* Improvement: Dynamic Tool Syncing. The MCP bridge now dynamically reads your exact active toolset and categories from your LolaCore panel in real time.

= 1.5.0 =
* Feature: Theme management — 5 new abilities (searchThemes, installTheme, updateTheme, bulkUpdateThemes, deleteTheme) bring themes to full parity with the existing plugin lifecycle. Lola can now discover themes on WordPress.org, install, update one or many, and safely delete (active theme and parents of active child themes are protected).
* UX Fix: When approved actions succeed but the follow-up summary call to the AI provider fails, the chat now confirms the actions ran instead of showing a misleading "I couldn't get a response" error. Users keep visibility into what executed.
* UX Fix: Tool confirmation cards are now idempotent on the client. A second submission of the same action_id (rare reload-and-reclick scenarios, accessibility tools firing duplicate events) is silently ignored, preventing the spurious "That confirmation has expired" message after a successful execution.

= 1.4.1 =
* Fix: Resolved a critical "Bad Request (400)" error triggered by orphan tool_call_ids during multi-tool execution (e.g. bulk plugin updates). The root cause was non-deterministic message ordering — MySQL's 1-second datetime resolution caused tool responses to appear out of sequence when multiple tools executed within the same second.
* Fix: Message history query now uses the auto-increment primary key for ordering instead of the datetime column, guaranteeing insertion-order fidelity regardless of timestamp collisions.
* Fix: The history sanitizer now detects and drops stale tool messages that reference tool_call_ids never declared by any assistant message in the session.
* Improvement: Added a defense-in-depth architecture for tool_call/tool_response pairing with four validation layers: deterministic DB ordering, history sanitizer with per-ID logging, post-sanitization assertion, and an HTTP-layer safety net that patches orphans in the final API request body.
* Improvement: Sanitizer telemetry now logs the exact orphaned tool_call_ids and function names, replacing the previous generic message.

= 1.4.0 =
* Feature: Skills.MD — Lola can now author, store and apply behavioral skills described in plain Markdown with YAML frontmatter. Skills inject specialized instructions into Lola's reasoning under deterministic conditions (always-on, keyword triggers, or environment conditions) without touching PHP.
* Feature: Skills are loaded from four sources with documented precedence (built-in, addon-registered, user filesystem at `wp-content/lolacore-skills/`, and database). The `lolacore_register_skills` filter lets addons register their own skill directories.
* Feature: Settings → Skills panel — visualize every loaded skill grouped by origin, toggle each one on or off, view the source markdown, import skills from .md files, and configure advanced parameters (max active, char budget, max per prompt).
* Feature: Conversational skill authoring — ask Lola "create a skill that…" and she generates the markdown, saves it inactive, and asks before activating. Full toolset: `addSkill`, `activateSkill`, `deactivateSkill`, `updateSkill`, `deleteSkill`, `listSkills`.
* Architecture: Single-axis state model for skills. Each skill is either `active` (firing) or `inactive` (off) — managed by one toggle in the admin, one verb in the chat. Runtime diagnostics (`no-triggers`, `incompatible`, `unmet-dependencies`) surface as informational badges, not as states the user manipulates.
* Architecture: Two-layer skill cache — hot transient with filesystem-hash validation and cold snapshot in `wp_lolacore_config` (capped at 1 MB serialized) — keeps the loader budget under 5 ms on the cache-hit path.
* Architecture: Skills system is gated behind a master toggle (Beta) so the entire feature can be disabled with a single switch without uninstalling.
* Database: Migration to schema version 0.3.0 — adds the `wp_lolacore_skills` table and consolidates legacy in-progress states into the unified `active`/`inactive` model.
* Improvement: `SystemPromptBuilder` enforces a ground-truth rule (`listSkills` before answering any state question) that prevents Lola from confabulating phantom skills from stale session summaries.
* Improvement: Session summaries now respect the language the user spoke in during the conversation rather than forcing a single locale.

= 1.3.0 =
* Performance: Memory fact extraction (`extractFacts`) is now deferred out of the user-facing response path via a non-blocking background request. Reduces perceived response time by ~5–19s on fact-heavy sessions (47% of observed median latency). Compatible with all PHP SAPIs — uses `fastcgi_finish_request()` on PHP-FPM (Linux/production) and `wp_remote_post(blocking=false)` with HMAC authentication on CGI/other environments.
* Performance: DeepSeek V4 think-mode is now disabled for the intent classifier call. The classifier task is pure JSON categorization — disabling reasoning reduces classifier latency by ~34% with no accuracy regression.
* Fix: Meta-tool query patterns ("¿qué puedes hacer?", "¿qué funciones tienes?") were stored with mojibake-encoded characters that never matched real UTF-8 input. Replaced with accent-agnostic character classes (`qu[eé]`, `cu[aá]ntas`, etc.).
* Fix: Holistic and meta-intent detectors now inspect only the current user message, not the conversation history window. Eliminates false positives on subsequent turns when a prior message happened to contain a capability-query phrase.

= 1.2.0 =
* Feature: Memory Bootstrap — Lola now seeds baseline facts from each active addon on activation and refreshes them every 6 hours via a unified background job. Compatible addons (WooCommerce Pro, WPCode Snippets, Fluent Support) contribute live site-state data so Lola has meaningful context from the very first conversation, with no manual "remember this" prompting required.
* Feature: Holistic monitoring queries ("what needs my attention?", "give me a full site overview", "morning briefing") now automatically activate the full tool set across all active domains without requiring a round-trip escalation. Extensible via the `lolacore_holistic_monitoring_patterns` filter.
* Architecture: Added `MemoryBootstrapInterface` and `MemoryBootstrapRunner` with an adaptive global budget (24 baseline facts, minimum 2 guaranteed per addon, competitive allocation by importance score). Bootstrap facts are immune to the memory decay engine and capped at 40% of the context window to prevent crowding out conversational memory.
* Improvement: Category affinity map expanded with bidirectional links across all Business Bundle domains (WooCommerce Pro ↔ WPCode Snippets ↔ Fluent Support). Cross-addon queries now resolve in a single pass without requiring a follow-up escalation.
* Improvement: The semantic intent classifier maximum category cap is now adaptive — scales from 3 to 5 based on the number of active addon domains, allowing genuine multi-domain queries (e.g., "compare my WooCommerce revenue against open support tickets") to resolve correctly on complex sites.
* Fix: Resolved "insufficient tool messages following tool_calls message" (HTTP 400) errors that could surface after an abandoned write confirmation, leaving the chat session permanently broken until reload. Affected DeepSeek and OpenAI-compatible providers.
* Fix: Added a defensive history sanitizer that detects orphan `tool_call_id`s in stored conversation history and injects synthetic placeholders before each provider request, preserving the assistant→tool pairing contract required by the OpenAI message format.
* Fix: Widened executor exception capture from `\Exception` to `\Throwable` so that a `TypeError` in any Domain Handler still produces a valid `tool` message instead of orphaning the assistant's `tool_call`.
* Fix: Provider responses with missing or null `tool_call_id` are now backfilled with a synthetic UUID, preventing silent round-trip pairing failures.
* Fix: Memory extraction job now uses an explicit 30-second transport timeout, eliminating silent extraction failures (`cURL error 28`) on reasoning-capable providers such as DeepSeek.
* Fix: DeepSeek V4 `reasoning_content` is now re-injected only when the assistant message includes `tool_calls`, following the V4 spec exactly. Previously re-injected unconditionally, wasting 500–2,000 tokens per conversational turn.
* Improvement: DeepSeek V4 models (`deepseek-v4-pro`, `deepseek-v4-flash`) now appear first in the model selector. Legacy V3 models (`deepseek-chat`, `deepseek-reasoner`, deprecated 2026-07-24) are sorted last.
* Improvement: Reduced average token usage per request by ~30–40% through four independent optimizations: system prompt restructuring to maximise prefix cache hits, site scan summary compression (JSON → compact text), adaptive memory budget that scales with message length (10/20/30 facts), and tool schema description compression for always-present tools.

= 1.1.3 =
* Architecture: Major overhaul of the Long-Term Memory persistence pipeline to prevent "amnesia" and ensure context retention across sessions.
* Architecture: Introduced "Immortal Facts" (is_pinned schema column). Important memory facts can now be pinned, making them permanently immune to the decay relevance engine.
* Architecture: Importance-Aware Decay. The memory decay formula now scales mathematically based on fact importance — critical facts decay 2x slower than trivial observations.
* Feature: Proactive Memory Directives. Lola is now instructed at the system-prompt level to automatically save structural decisions, stack choices, and business preferences without waiting to be told "remember this".
* Feature: Contextual Fact Boosting. The retrieval engine now dynamically filters and boosts memory relevance in real-time based on keyword matches with your current chat message.
* Feature: Session Summary Persistence. Chat session summaries are now preserved as high-priority memory facts instead of being destructively overwritten by the newest session.
* Fix: Multi-Turn Memory Extraction. The background memory extraction job now observes the last 5 conversation turns (instead of just 1), preventing blind spots in extended discussions.
* Fix: Model Desync. Memory extraction now actively resolves the selected AI provider/model from settings, fixing a bug where extraction would fail silently on non-default models like DeepSeek.
* Fix: Scanner Budgeting. Scanner-generated facts (site_state) are now hard-capped at 35% of the memory window, preventing plugin lists from crowding out actual conversational memory.
* Fix: Added robust local PHP diagnostic logging (via error_log) to the memory extraction background job to eliminate silent failures.
* Compliance: Replaced hardcoded AJAX endpoint with dynamically localized URL via wp_localize_script.
* Compliance: Migrated widget state injection from inline script tag to wp_add_inline_script for WordPress enqueue standards.
* Compliance: Updated DOMPurify to 3.4.2 and marked.js to 18.0.3 (latest stable releases).
* Compliance: Escaped all dynamic values in exception messages across all Domain Handlers (esc_html).
* Compliance: Converted raw DB_NAME concatenation to $wpdb->prepare() in database size query.
* Compliance: Fixed translators comment placement for PHPCS MissingTranslatorsComment compliance.
* Compliance: Removed development-only files (scratch.php, extractor.php) from plugin root.

= 1.1.2 =
* Architecture: Complete refactoring of ActionExecutor into 12 modular Domain Handlers (ContentHandler, PluginHandler, UserHandler, SystemHandler, MediaHandler, MetaHandler, TaxonomyHandler, CommentHandler, NavigationHandler, MemoryHandler, WooReadHandler, WooWriteHandler) behind a HandlerRouter with ActionHandlerInterface contract.
* Architecture: Introduced HandlerRouter with deterministic dispatch — each handler declares its owned actions via getSupportedActions(), eliminating the monolithic switch/case in ActionExecutor.
* Feature: Added getDiscoveredAbilities tool for Lola to introspect all registered WordPress Abilities at runtime.
* Feature: Added manageRoles tool enabling Lola to create, delete, and modify WordPress user roles and capabilities from chat.
* Fix: Intent Router reordering — meta-intent detection (Layer 0.5) now executes before keyword matching (Layer 1), preventing false-positive category captures on meta-queries like "What tools do you have?".
* Fix: Enabled 'meta' as a valid category in the semantic classifier (Layer 2), providing a second safety net for meta-queries that bypass Layer 0.5.
* Fix: Plugin search (searchPlugins) now handles both object and array response formats from the WordPress.org plugins_api(), resolving empty results on certain PHP/WP versions.
* Fix: Chat UI now auto-links plain-text URLs in assistant responses, converting them into clickable links.
* Fix: Export download links (.xml, .json, .csv, .zip) now include the HTML download attribute, forcing browser download instead of inline rendering.
* Fix: URL autolink regex excludes backtick characters to prevent trailing %60 in generated links.
* Improvement: Keyword inference from tool descriptions is now isolated from meta-query routing, reducing false-positive matches in the intent router.
* Improvement: Removed legacy direct-method dispatch from ActionExecutor — all 51 actions now route exclusively through Domain Handlers.
* Improvement: Addon integration updated — WooCommerce Pro tools route through category affinity system for reliable domain escalation.
* Architecture: New `LolaCore\I18n` namespace with `ErrorMessages` and `StatusMessages` classes — every user-facing string is now centralized and WordPress i18n-ready (`__()` wrappers for future translation).
* Architecture: Backend error sanitization via `ErrorMessages::wrapServerError()` — stack traces, PHP class names, and raw exception details are filtered before reaching the frontend.
* Improvement: Chat error messages rewritten for cognitive ergonomics — first-person voice, no jargon, actionable next step in every message.
* Improvement: Replaced emoji-prefixed error indicators (`⚠️`) with CSS-driven visual treatment (`.lola-error-message` class with salmon accent border and tinted background).
* Improvement: `appendMessage()` in chat JS now accepts an `isError` flag for proper error styling without breaking Markdown rendering or autolink functionality.
* Improvement: All hardcoded error strings in `Controller.php`, `Settings.php`, and `WPAIClientAdapter.php` replaced with centralized `ErrorMessages` / `StatusMessages` method calls.

= 1.1.1 =
* Fix: Added full taxonomy assignment support (categories and tags) to createContent and editContent.
* Fix: Added featured_image assignment support to createContent and editContent.
* Feature: Added uploadMedia tool to allow autonomous sideloading of external images into the Media Library.

= 1.1.0 =
* UI Redesign: Complete overhaul of the settings panel to match LolaCore's design system.
* Feature: Added ability to manage Lola's persistent memory directly from the settings panel (Maintenance ops: Scan, Export, Import, Compact).
* Feature: Autonomous Tool Escalation added. Lola can now dynamically break out of restricted domains when she determines a tool is needed but restricted.
* Improvement: Modularized system prompt generation and unified safety toggles using a SafetyConfig architecture.
* Improvement: Integrated addon infrastructure (Door 4 & 5) enabling unified management and license validation for extensions like WPCode.
* Improvement: Minor UI updates and padding adjustments for broader screen compatibility.

= 1.0.2 =
* Fix: Preserved raw HTML/code syntax in user chat messages without stripping tags.
* Enhancement: Implemented Markdown rendering in chat UI for rich text, tables, and formatted code blocks (ChatGPT-like experience).
* Enhancement: Enqueued marked.js and DOMPurify for secure frontend Markdown parsing.

= 1.0.1 =
* Added: `lolacore_execute_external_action` filter for external addon action dispatch.
* Added: `lolacore_sop_map` filter for dynamic SOP injection by addon plugins.
* Improvement: LolaCore is now fully extensible for third-party addon plugins.

= 1.0.0 =
* Initial public release.
* 51 abilities across 13 domains (27 read + 24 write).
* Persistent memory engine with decay-based relevance scoring.
* Algorithmic site scanner with 11 data collection modules.
* 13 dedicated WooCommerce tools — products, orders, customers, coupons, categories, sales reports.
* Built on the WordPress 7.0 native AI Client — zero external production dependencies.
* All abilities exposed via the WordPress Abilities API.
* MCP server compatibility — works with Claude Desktop and any MCP client.
* Intent router — filters abilities per message to reduce token usage and improve accuracy.
* Floating chat widget with drag, minimize, and session persistence.
* Preview → Confirm → Execute pattern for all write operations.
* Safety guards: self-deactivation block, last-admin protection, delete limit warnings.
* Three AI providers supported: Anthropic, OpenAI, DeepSeek.

== External Services ==

LolaCore connects to the following external services. Each connection is documented below with what triggers it, what data is sent, and links to the relevant terms and privacy policies.

= AI Providers (Chat Feature) =

When you use the chat widget, your messages are sent to whichever AI provider you have configured in WordPress's built-in AI settings (Settings → AI). LolaCore does not operate its own servers and does not route data through any intermediary.

**Data sent to your provider:**
- Your chat messages
- A summary of your site scan (WordPress version, active plugin list, PHP version)
- Relevant memory facts (site observations stored in your local database)

**Data never sent:**
- Passwords, API keys, wp-config values, or database credentials
- Personal user data (emails, addresses, payment info)

**When this happens:** Only when you actively send a message in the chat widget. No background calls.

**Supported providers:**
- OpenAI — [https://openai.com](https://openai.com) | [Terms of Use](https://openai.com/policies/terms-of-use) | [Privacy Policy](https://openai.com/privacy)
- Anthropic — [https://anthropic.com](https://anthropic.com) | [Terms of Service](https://www.anthropic.com/legal/consumer-terms) | [Privacy Policy](https://www.anthropic.com/privacy)
- DeepSeek — [https://deepseek.com](https://deepseek.com) | [Terms of Use](https://chat.deepseek.com/downloads/DeepSeek%20Terms%20of%20Use.html) | [Privacy Policy](https://chat.deepseek.com/downloads/DeepSeek%20Privacy%20Policy.html)

= Wordfence Vulnerability API =

LolaCore can check your installed plugins against the public Wordfence vulnerability database to identify known security issues.

**Endpoint:** `https://www.wordfence.com/api/intelligence/v2/vulnerabilities/scanner`

**Data sent:** An HTTP GET request with no request body. LolaCore sends only a User-Agent header identifying itself (`LolaCore WordPress Plugin`). No plugin lists, site URLs, or user data are transmitted to Wordfence.

**Data received:** A public JSON feed of known WordPress plugin vulnerabilities. LolaCore compares this list locally against your installed plugin slugs and versions to surface relevant findings.

**When this happens:** Only when you explicitly request a vulnerability check through the chat (e.g., "check my plugins for vulnerabilities"). This call is never made automatically during plugin activation, scheduled scans, or background operations.

**Service links:**
- Wordfence — [https://www.wordfence.com](https://www.wordfence.com) | [Terms of Service](https://www.wordfence.com/terms-of-use-and-privacy-policy/) | [Privacy Policy](https://www.wordfence.com/privacy-policy/)

= WordPress.org Plugin API =

When you ask Lola to search for or install plugins, LolaCore queries the official WordPress.org Plugin API.

**Data sent:** Plugin search keywords or slug identifiers.
**Data received:** Plugin metadata, descriptions, and download URLs from the WordPress.org repository.

**When this happens:** Only when you use plugin search or install features through the chat.

- Service: [https://wordpress.org](https://wordpress.org) | [API Documentation](https://codex.wordpress.org/WordPress.org_API)

= Google Fonts =

The admin settings page loads two font families (Plus Jakarta Sans and JetBrains Mono) from Google Fonts for the plugin's admin interface.

**Data sent:** Standard HTTP font file requests. Google receives the requesting IP address and browser User-Agent.
**When this happens:** Each time an administrator opens the LolaCore settings page.

- Service: [https://fonts.google.com](https://fonts.google.com) | [Terms of Service](https://developers.google.com/terms) | [Privacy Policy](https://policies.google.com/privacy)