Title: LolaCore – AI Admin Agent
Author: Fran Barbero
Published: <strong>મે 22, 2026</strong>
Last modified: જુલાઇ 3, 2026

---

પ્લગીન શોધો

![](https://ps.w.org/lolacore/assets/banner-772x250.png?rev=3595457)

![](https://ps.w.org/lolacore/assets/icon-256x256.png?rev=3544434)

# LolaCore – AI Admin Agent

 [Fran Barbero](https://profiles.wordpress.org/vanguardhive/) દ્વારા

[ડાઉનલોડ](https://downloads.wordpress.org/plugin/lolacore.2.0.0.zip)

 * [વિગતો](https://gu.wordpress.org/plugins/lolacore/#description)
 * [સમીક્ષાઓ](https://gu.wordpress.org/plugins/lolacore/#reviews)
 *  [સ્થાપન](https://gu.wordpress.org/plugins/lolacore/#installation)
 * [ડેવલપમેન્ટ](https://gu.wordpress.org/plugins/lolacore/#developers)

 [સપોર્ટ](https://wordpress.org/support/plugin/lolacore/)

## વર્ણન

> **You:** Run the weekly cleanup.
> **Lola:** Last week you decided to keep post revisions for 30 days and leave the
> ones on your landing pages alone. Going by that, 1,240 revisions and 1.2K expired
> transients are safe to clear, about 34 MB. I’ll show you the exact list before
> anything runs. Proceed?

You didn’t repeat your rules. You didn’t re-explain last week. Lola already knew,
because she remembers your site across sessions while every other AI tool forgets
the moment you close the tab. That is the difference between a chatbot and an agent
that runs your site.

Running WordPress once is easy; running it every day wears you down—separate screens,
repeated clicks, context gone when you close the session. That grind has a name:
[admin fatigue](https://lolacore.com/admin-fatigue/), the real cost of running a
site. It hits hardest in WooCommerce, where every order and stock update adds another
screen. I ran a store for ten years; what burned me out was never the selling—it
was the admin.

LolaCore is where that stops. Lola is an AI agent inside your wp-admin. You tell
her what you need; she does the admin work and shows you exactly what she will change
before anything happens. No new dashboard. No external tool. She works where you
already work.

She is **built natively on the WordPress 7.0 AI Client and the Abilities API**. 
She reads your database, reasons about it, and executes real actions only with your
explicit approval. Full picture: [documentation](https://lolacore.com/documentation/).

#### Persistent memory

Memory is the foundation everything else stands on.

Lola remembers facts across sessions: plugin conflicts, security findings, your 
preferences, decisions you have made—all stored locally in your WordPress database.
Important findings stay sharp; old trivia fades; pinned facts stay longer. When 
you start a new conversation, you don’t re-explain your stack. You pick up the thread.
How decay, boosting, and export/import work: [persistent memory guide](https://lolacore.com/documentation/#persistent-memory).

#### 75 abilities. 10 domains. One chat.

 * **Site diagnostics** (4 abilities). WordPress and PHP status, HTTPS, database
   size, security headers, SEO audit. Lola tells you what’s broken before your client
   does.
 * **Plugins** (6). Search WordPress.org, install, activate, deactivate, update 
   one or all. “Update all plugins” is one sentence, not 14 update screens.
 * **Plugin Builder** (9). Describe a custom plugin in chat. Lola reads your site,
   co-designs a short plan, generates files with safety checks and AI code review,
   then you test in Playground before it touches your live site.
 * **Block Builder** (9). Same flow for custom Gutenberg blocks: Lola scaffolds `
   block.json`, editor scripts, and the PHP render callback; you preview in Playground,
   then install on approval.
 * **Content & metadata** (7). Create pages, edit posts, change status, update slugs,
   read and write post meta. Works with Yoast, RankMath, and other post-meta plugins.
 * **Users** (4). Create accounts, change roles, remove users with automatic content
   reassignment.
 * **Database & cache** (3). Clean post revisions, expired transients, orphaned 
   postmeta, and spam comments. The cleanup WordPress never does for you.
 * **Taxonomies & media** (7). Categories, tags, comments, and media files.
 * **Themes & settings** (13). Install, update, and delete themes with safety warnings,
   read and write site options, manage navigation menus, review cron jobs.
 * **WooCommerce** (13). Detected automatically. Products, orders, customers, coupons,
   categories, sales reports. “How much revenue this week?”—from your store data,
   not a dashboard.

Every ability in detail: [ability reference](https://lolacore.com/documentation/#what-lola-can-do).
Store tools with examples: [WooCommerce abilities](https://lolacore.com/documentation/#woocommerce-core).

#### How Lola stays safe

**Your data never touches our servers.** No telemetry, no analytics. Your conversations
go from your hosting to your AI provider. That’s it.

**Nothing happens without your approval.** Every write action shows a preview card
with exactly what Lola is about to do. You confirm or cancel. Every action is logged
with before/after snapshots. Admin-only.

#### She has an opinion

Lola has judgment. When a change would hurt your site, she tells you before you 
commit and offers a safer way to get what you want. If you still want to proceed,
she does it your way and records the decision, so the next time it comes up the 
context is already there.

#### Any model, your choice

Lola works with whatever AI provider you configure in WordPress 7.0 (Settings  AI).
Agentic models perform best: GPT-5.5, DeepSeek V4, Claude 4.6 Sonnet or Opus 4.7.
Gemini, Grok, Ollama, and OpenRouter work through the native connector.

You pay your provider directly—no token markup from LolaCore. Each message sends
only the abilities your request needs, not the full catalog. Setup: [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. No external
HTTP libraries, no custom credential vaults. When WordPress updates its AI infrastructure,
LolaCore updates with it.

#### Lola’s lane

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

 * She doesn’t edit theme files, core, or server config. Plugin Builder and Block
   Builder are the exceptions: she generates custom plugins and blocks that you 
   own and iterate in chat.
 * She doesn’t see your frontend. Lola lives inside wp-admin.
 * In wp-admin, she works on one site at a time. Over MCP, your editor can hold 
   the whole fleet.

Why these boundaries exist: [what Lola cannot do](https://lolacore.com/documentation/#what-lola-cannot-do).

#### Skills and playbooks: teach Lola how you work

Skills are short behavioral guides in plain Markdown that shape how Lola approaches
a task. LolaCore ships with 14 built in, and you can write your own or ask Lola 
to create one for you in chat. [Skills guide](https://lolacore.com/documentation/#skills).

A playbook is a curated manual for one area of work: your brand guidelines, your
FSE build conventions, an internal process. Upload a document (TXT, Markdown, DOCX,
or HTML), Lola distills it into a draft, you review and activate it. From then on
she consults it whenever that domain comes up. [Playbooks guide](https://lolacore.com/documentation/#playbooks).

#### Free addons teach Lola your stack

When you work with a specific tool every day, a free addon teaches Lola that domain—
all sharing the same site memory:

 * [LolaCore for Elementor](https://lolacore.com/lolacore-for-elementor/): manage
   your Elementor pages and templates from chat
 * [LolaCore for ACF](https://lolacore.com/lolacore-for-acf/): read and write Advanced
   Custom Fields in plain language
 * [LolaCore for SEO](https://lolacore.com/lolacore-for-seo/): audit and edit your
   SEO without opening another panel
 * [LolaCore for Forms](https://lolacore.com/lolacore-for-forms/): work with your
   forms and their entries from the chat
 * [LolaCore for Statistics](https://lolacore.com/lolacore-for-statistics/): ask
   about your traffic and get the number, not a dashboard
 * [LolaCore for FSE](https://lolacore.com/lolacore-for-fse/): a block and template
   builder for block themes

Browse them all: [lolacore.com/add-ons](https://lolacore.com/add-ons/).

#### For agencies and consultants

Run WordPress for clients and the admin work multiplies with every site. Free addons
go deep on the stack you build with: 91 for Elementor, 26 for ACF, 22 for SEO, 18
for Statistics, 15 for Forms, 17 for FSE—189 abilities on top of Lola’s core.

Each client site is a separate install with its own memory; contexts never bleed
across clients. Preview cards and logs mean you always know what changed on a live
site.

LolaCore bundles a zero-config MCP server—each client site becomes a tool in Cursor,
Claude Code, or any MCP client. Connect the fleet and one agent runs it: “update
plugins on site A”, “how did site B sell this week”, “SEO audit on every site”. 
Your agent, your rules, Lola’s full toolset—abilities, memory, builders, skills,
playbooks.

#### Don’t know what to say? Start here.

No commands, no syntax. Three prompts you can paste right now:

> “Give me a quick briefing on the site. Anything that needs attention today.”
> “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.”

There are 45 more in the [prompt library](https://lolacore.com/documentation/#prompt-library):
daily check-ins, maintenance routines, session combos.

### External Services

LolaCore connects to the following external services. Each connection is documented
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)

## સ્ક્રીનશોટ

[⌊Lola's first scan: a specific, actionable report about your site, not a generic
greeting.⌉⌊Lola's first scan: a specific, actionable report about your site, not
a generic greeting.⌉[

Lola’s first scan: a specific, actionable report about your site, not a generic 
greeting.

[⌊Security audit results with severity flags and fix suggestions.⌉⌊Security audit
results with severity flags and fix suggestions.⌉[

Security audit results with severity flags and fix suggestions.

[⌊Plugin installation through chat. Lola finds, downloads, and asks before installing.⌉⌊
Plugin installation through chat. Lola finds, downloads, and asks before installing
.⌉[

Plugin installation through chat. Lola finds, downloads, and asks before installing.

[⌊Action confirmation flow: every write operation shows a preview and requires approval
before executing.⌉⌊Action confirmation flow: every write operation shows a preview
and requires approval before executing.⌉[

Action confirmation flow: every write operation shows a preview and requires approval
before executing.

[⌊The ability panel: 75 abilities across 10 domains, each toggleable from the settings
page.⌉⌊The ability panel: 75 abilities across 10 domains, each toggleable from the
settings page.⌉[

The ability panel: 75 abilities across 10 domains, each toggleable from the settings
page.

## સ્થાપન

 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.0 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).

## એફએક્યુ (FAQ)

### What is admin fatigue?

Admin fatigue is the cumulative cost of running a WordPress site through a panel
that puts dozens of clicks between the simple thing you want to do and actually 
getting it done. It is worst in WooCommerce stores, but every WordPress admin feels
it. LolaCore exists to remove it: you describe the task, Lola does the admin work
from chat. Full explanation: [what is admin fatigue](https://lolacore.com/admin-fatigue/).

### Do I need to know how to code?

No. You tell Lola what you need in plain language, the same way you would explain
it to an employee. No commands, no syntax, nothing to memorize. If you can describe
the task, Lola can run it.

### 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’s the difference between memory, skills, and playbooks?

Memory is what Lola knows about your site: facts, decisions, and preferences she
has picked up over time. Skills shape how she works a task; one might load a safety
protocol before a bulk deletion. Playbooks are curated manuals for a whole domain,
like the rules of your FSE build or your brand guidelines, and she reads the matching
one before she works in that area. All three sit on top of her abilities, which 
are the actions she actually takes in WordPress.

### Does LolaCore charge per use?

No. LolaCore is free. The only cost is your own AI provider: you connect your account
in WordPress settings and pay that provider directly for what you use. LolaCore 
takes no cut, adds no markup, and never charges per message.

### Does LolaCore work with WooCommerce?

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

### Is LolaCore only for WooCommerce stores?

No. The store owner feels admin fatigue most acutely, so a lot of the examples are
about WooCommerce, but 62 of Lola’s 75 abilities are general WordPress work: diagnostics,
plugins, content, users, database, themes, and settings. If you run any WordPress
site, Lola earns her keep with or without WooCommerce.

### 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.

### Where is my data stored?

All data (memory facts, chat history, configuration) is stored in your WordPress
database. Six dedicated tables are created on activation (`lolacore_memory`, `lolacore_log`,`
lolacore_config`, `lolacore_sessions`, `lolacore_messages`, `lolacore_skills`). 
Nothing is sent to external servers except your chat messages to your configured
AI provider when you actively use the chat.

### 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 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 keeps
its own memory and its own logs, so one client’s context never bleeds into another’s.
The free addons cover the tools you build with (Elementor, ACF, SEO, forms, analytics,
block themes), and consultants use Lola to cut down monthly maintenance and produce
client reports from a conversation.

### Can I use Lola from an IDE?

Yes. Every ability is exposed through the WordPress Abilities API, and LolaCore 
bundles a zero-config MCP server. Over MCP, your own agent (Claude Code, Cursor,
Claude Desktop) drives Lola’s toolset directly under the rules you set for it: all
abilities, the persistent memory, skills, playbooks, Plugin Builder and Block Builder.
Agencies use this to run a fleet: add each client site’s MCP server to one editor
and a single agent updates, audits, and reports across all of them. Plugins and 
blocks built over MCP still have to pass WordPress Playground before they can be
installed. Lola herself, with her judgment and confirm-before-write flow, lives 
in the wp-admin chat.

### 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.

### Where is the full documentation?

This readme covers the essentials. The full documentation goes deeper: memory mechanics,
the complete ability catalog with examples, a prompt library with 48 ready-to-use
conversation starters, a detailed settings walkthrough, and 45+ answers across 12
FAQ categories. **[LolaCore Documentation](https://lolacore.com/documentation/)**

## સમીક્ષાઓ

આ પ્લગઇન માટે કોઈ સમીક્ષાઓ નથી.

## ફાળો આપનાર & ડેવલપર્સ

આ ઓપન સોર્સ સોફ્ટવેર છે. નીચેના લોકો એ આ પ્લગિન માટે ફાળો આપ્યો છે.

ફાળો આપનારા

 *   [ Fran Barbero ](https://profiles.wordpress.org/vanguardhive/)

[“LolaCore – AI Admin Agent” ને તમારી ભાષામાં અનુવાદ કરો.](https://translate.wordpress.org/projects/wp-plugins/lolacore)

### વિકાસમાં રસ ધરાવો છો?

[કોડ બ્રાઉઝ કરો](https://plugins.trac.wordpress.org/browser/lolacore/), જોવો[અસ્વીએન રેપોઝિટરીમાંથી](https://plugins.svn.wordpress.org/lolacore/),
અથવા સબ્સ્ક્રાઇબ કરો[ડેવલપમેન્ટ](https://plugins.trac.wordpress.org/log/lolacore/)
દ્વારા[આરઅસઅસ](https://plugins.trac.wordpress.org/log/lolacore/?limit=100&mode=stop_on_copy&format=rss).

## ચેન્જલૉગ

#### 2.0.0

 * Feature: **Block Builder** — describe a custom Gutenberg block in chat; Lola 
   scaffolds block files, saves to the **Built Blocks** library, tests in WordPress
   Playground, and installs to `wp-content/lolacore-blocks/` after your approval.
   Nine Block Builder abilities (`createBlock`, `updateBlockCode`, `listBuiltBlocks`,`
   getBuiltBlock`, `getInstalledBlock`, `testBlock`, `installBlock`, `uninstallBlock`,`
   deleteBuiltBlock`).
 * Feature: System playbook **`block-development`** for Block Builder scaffolding
   and iteration.
 * Improvement: Broader **Spanish (Spain)** coverage for builders, chat, and action
   handlers.
 * Improvement: **Playbook distiller** — clearer format contract, YAML frontmatter
   repair, and persistent error UX when distillation fails.

#### 1.9.0

 * Feature: **Playbooks** — curated domain manuals Lola consults when working in
   a specific area. Built-in `playbook-format` contract, system playbook `plugin-
   development` for Plugin Builder, database and filesystem sources, model-adaptive
   delivery (inline hints for lightweight models, full attachment on ability use),
   and seven playbook abilities for chat and MCP.
 * Feature: Playbooks admin under **Lola  Playbooks** — list, create, edit, activate,
   upload (TXT/MD/DOCX/HTML), AI distillation with review before save, and reload.
   Skills moved to its own submenu (**Lola  Skills**).
 * Improvement: Upload guardrail with a clear notice when extracted document text
   exceeds 40,000 characters.

#### 1.8.9

 * Fix: Plugin Builder Playground works again on production hosting. Opening Playground
   no longer depends on a loopback scrape on your live server (which often fails
   and was blocking every library plugin with a false “fatal error”). Runtime load
   checks still run when saving code for review and before installing on your site.
 * Improvement: Playground links are short and shareable. The blueprint is served
   from your site via a signed REST URL (`blueprint-url`), so MCP and chat agents
   can give you a clickable link that opens Playground in the browser without copying
   a megabyte-long URL from wp-admin.

#### 1.8.8

 * Improvement: The Plugin Builder now works over MCP. A connected code editor can
   create and iterate plugins straight into your Plugin Builder library by sending
   the exact code — the site no longer asks its own AI to rebuild code the external
   tool already wrote. The wp-admin chat is unchanged: there you describe what you
   want and Lola writes it. Plugins added over MCP go through the same static safety
   checks and must still be tested in Playground before they can be installed.
 * Fix: LolaCore for Forms now appears on the Addons screen before you install it,
   with a one-click install from WordPress.org — the same pattern as the other free
   bridge addons (ACF, SEO, Statistics).

#### 1.8.7

 * Fix: On the Addons screen, installed free bridge addons now show **Learn more**
   and link to their lolacore.com landing pages instead of **Download free ** (which
   only applies before install). Install-from-WordPress.org links are unchanged 
   for addons you have not installed yet.
 * Fix: Addons catalog and cross-domain footer links no longer 404 — marketing URLs
   now use UTM-safe landing pages, and **How cross-domain intelligence works ** 
   points to the live add-ons catalog at lolacore.com/add-ons/.
 * Fix: The **View all abilities** list on Settings now lists tools for free bridge
   addons (ACF, SEO, Statistics, Elementor, and others), not just premium addons
   and core domains.

#### 1.8.6

 * Fix: Resolved a race condition on sites where another active plugin bundles its
   own copy of the WordPress MCP adapter (recent versions of WooCommerce do this).
   The Abilities API init event fires only once per request; when WooCommerce or
   an addon triggered it before the adapter could register its meta-tools, the debug
   log filled with repeated “ability does not exist” notices on every wp-admin page
   load and Lola’s IDE/MCP connection could stop working. LolaCore now registers
   the MCP protocol meta-abilities at the earliest hook priority and skips tools
   that are not yet available.

#### 1.8.5

 * Feature: The Addons screen now shows the free LolaCore bridge addons (for ACF,
   SEO, and Statistics) even before you install them, each with a one-click install
   from WordPress.org. Until now only installed addons appeared, so there was no
   way to discover the free ones from inside Lola.
 * Docs: New conversation-led opening for the plugin description that shows how 
   Lola uses persistent memory, plus a clearer short description and search tags.
   No functional changes to the agent.

#### 1.8.4

 * Docs: Rewrote the readme to explain more clearly what LolaCore does and the problem
   it solves (admin fatigue). No functional changes to the plugin.

#### 1.8.3

 * Fix: Improved compatibility with hosting security plugins and firewalls. Chat
   messages are now sent as plain text, which prevents some security suites from
   blocking WordPress REST API requests on affected hosts — an issue that could 
   interfere with Application Password management and MCP connections.
 * Improvement: When a hosting firewall blocks a chat message, Lola now explains
   what happened and what to do, instead of showing a generic connection error.

#### 1.8.2

 * Fix: Free bridge addons (e.g. LolaCore for ACF, LolaCore for Elementor) now show
   a green **FREE ADDON** badge in the What Lola Can Do ability panel, matching 
   the premium addon label treatment.

#### 1.8.1

 * Fix: Chat now accepts HTML and JavaScript code snippets (e.g. WPCode tracking
   scripts with `<script>` tags). Messages are no longer stripped by over-aggressive
   sanitization, and code payloads are base64-encoded in transit so hosting WAF 
   rules do not block admin-ajax requests.

#### 1.8.0

 * Feature: **Guided onboarding**. First-time setup includes a site scan and initial
   report; returning users without an AI provider see a continuity state with clear
   next steps; connecting a provider triggers a one-time welcome grounded in scan
   data.
 * Feature: **Spanish (Spain) translation** for wp-admin settings, the chat widget,
   ability labels, and user-facing messages (`es_ES`; other locales fall back to
   English).
 * Improvement: **Settings UI** reorganized for a clearer overview of Lola’s capabilities
   and optional extensions.
 * Improvement: **Admin navigation** — dedicated Addons screen under the Lola menu
   and a shortcut from the Plugins list row. The screen lists available addons, 
   including the free **LolaCore for Elementor** (91 abilities), and explains how
   cross-domain memory works.
 * Improvement: Admin notice when WordPress is below the recommended version (7.0).
 * Security: Hardened the chat confirmation card against malicious markup in action
   parameters (output escaping).
 * Security: Chat sessions are now bound to the admin who created them, so a session
   cannot be read or continued by another user.
 * Security: Expanded the protected-options list so role, plugin/theme activation,
   mail server, and upload-path settings cannot be changed through the generic option
   editor.

#### 1.7.2

 * Improvement: Plugin Builder **additional pre-delivery safety checks**. Block 
   generated plugins missing direct-access guards (`ABSPATH`) or using forbidden
   functions (eval, shell_exec, and similar) before they reach your library.
 * Improvement: Runtime **load test** validates the same normalized PHP used for
   install and Playground, and bootstraps declared dependencies (e.g. WooCommerce
   admin bases) when possible.
 * Improvement: Delivery cards and the Built Plugins library show **Load test** (
   Passed / Skipped / Failed) separately from the **Code review** score, so the 
   percentage is not mistaken for activation safety.
 * Improvement: Safety findings and load-test status are stored on each built plugin
   entry for library diagnostics.

#### 1.7.1

 * Fix: Remove development-only CLI repro scripts from the WordPress.org distribution
   package (they remain in the source repo for local debugging). Packaging-only 
   release, no functional changes.

#### 1.7.0

 * Feature: **Plugin Builder**. Describe a custom plugin for your site in chat; 
   Lola reads site render context, co-designs an optional approved mini-plan with
   you, generates a standard three-file WordPress plugin (PHP, JS, CSS) in a **background
   worker** with progress in chat, and saves it to the **Built Plugins** library
   under Lola in wp-admin. Delivery cards explain the MVP iteration loop (you as
   architect, Lola as engineer).
 * Feature: **Nine Plugin Builder abilities**: `getSiteRenderContext`, `createPlugin`,`
   updatePluginCode`, `listBuiltPlugins`, `getBuiltPluginDetails`, `getInstalledPluginState`,`
   testPluginPlayground`, `installPluginLocal`, and `deleteBuiltPlugin`.
 * Feature: **Built Plugins** admin library: version, install status, Try in Playground,
   Install, review note and suggestions, and a read-only code viewer (PHP / JS /
   CSS tabs) on each entry.
 * Feature: **WordPress Playground** testing. One-click disposable WordPress instance
   with your generated plugin installed and activated; when the plugin needs WooCommerce,
   the blueprint installs WooCommerce, skips onboarding, creates shop pages, and
   seeds demo products so cart and storefront behavior can be tested safely.
 * Feature: **Playground gate**. Local install stays blocked until you attest Playground
   testing for the current library version.
 * Feature: **Local install**. Copy built plugins into `wp-content/plugins/` with
   PHP syntax validation and optional backup advisory on dry run; plugins stay **
   inactive** until you explicitly activate them (LolaCore modal with optional Activate
   now or open the Plugins screen).
 * Feature: Chat **artifact cards** for async build progress, delivery preview, 
   Playground links, and post-save success (no extra slow LLM round-trip for Playground
   URLs).
 * Feature: **Failed-build recovery**. When generation cannot pass internal safety
   checks, the chat card offers Try again and preserves the last artifact for fix-
   mode retries.
 * Feature: Automatic **post revisions** for each plugin update so you can roll 
   back from the library entry.
 * Feature: **Internal quality pipeline**. PHP syntax lint, deterministic fatal-
   safety rules (e.g. unknown parent classes at file scope), runtime load validation
   when possible, AI code review, and up to two automatic retries before delivery
   fails.
 * Feature: Four built-in **skills** for plugin craft, Playground blueprints, security
   baseline, and plugin review methodology when you build, test, or debug generated
   plugins.
 * Improvement: Plugin generation sends **site context** to the AI (active theme,
   plugins, block vs classic integration signals, and WooCommerce free-shipping 
   minimum when configured) so store-specific defaults are more realistic.
 * Improvement: Router debug logging is concise under `WP_DEBUG` (ability counts
   by category instead of dumping every tool name).
 * Fix: Daily WP-Cron maintenance hooks (`lolacore_daily_decay`, `lolacore_log_cleanup`)
   now execute their handlers. Memory facts decay and archive on schedule, and action
   log entries older than **Log Retention Days** in Settings are purged automatically.

#### 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. One agent, one 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 to 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.

## મેટા

 *  વર્ઝન **2.0.0**
 *  છેલ્લી અપડેટ: **1 દિવસ પહેલા**
 *  સક્રિય સ્થાપનો: **20+**
 *  વર્ડપ્રેસ વર્ઝન ** 7.0 અથવા ઉચ્ચતર **
 *  **7.0** સુધી પરીક્ષણ કર્યું
 *  PHP સંસ્કરણ ** 8.0 અથવા ઉચ્ચતર **
 *  ભાષા
 * [English (US)](https://wordpress.org/plugins/lolacore/)
 * ટૅગ્સ:
 * [ai assistant](https://gu.wordpress.org/plugins/tags/ai-assistant/)[site management](https://gu.wordpress.org/plugins/tags/site-management/)
   [woocommerce](https://gu.wordpress.org/plugins/tags/woocommerce/)
 *  [વિગતવાર દૃશ્ય](https://gu.wordpress.org/plugins/lolacore/advanced/)

## પૉઇન્ટ્સ

હજુ સુધી કોઈ સમીક્ષા સબમિટ કરવામાં આવી નથી.

[Your review](https://wordpress.org/support/plugin/lolacore/reviews/#new-post)

[બધા  સમીક્ષાઓ જુઓ](https://wordpress.org/support/plugin/lolacore/reviews/)

## ફાળો આપનારા

 *   [ Fran Barbero ](https://profiles.wordpress.org/vanguardhive/)

## સપોર્ટ

કંઈક કહેવું છે? મદદ જોઈએ છે?

 [આધાર ફોરમ જુઓ](https://wordpress.org/support/plugin/lolacore/)