aiden-runtime 3.16.0

package/dist/core/planResponseRepair.js

@@ -0,0 +1,64 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repairPlanResponse = repairPlanResponse;
+/**
+ * Salvage a non-JSON planner response:
+ *   1. Direct JSON parse (already valid)
+ *   2. Extract from ```json ... ``` fences
+ *   3. Extract first {...} block
+ *   4. Treat plain-text as a direct-answer plan
+ */
+function repairPlanResponse(raw) {
+    if (!raw || raw.trim().length === 0) {
+        return { plan: null, repaired: false };
+    }
+    // Try 1: direct JSON parse
+    try {
+        const plan = JSON.parse(raw.trim());
+        return { plan, repaired: false };
+    }
+    catch { }
+    // Try 2: extract from ```json ... ``` fences (already done by caller's regex,
+    // but replicated here so this function is self-contained)
+    const fenceMatch = raw.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (fenceMatch) {
+        try {
+            const plan = JSON.parse(fenceMatch[1].trim());
+            return { plan, repaired: true };
+        }
+        catch { }
+    }
+    // Try 3: extract first {...} block
+    const firstBrace = raw.indexOf('{');
+    const lastBrace = raw.lastIndexOf('}');
+    if (firstBrace >= 0 && lastBrace > firstBrace) {
+        try {
+            const plan = JSON.parse(raw.slice(firstBrace, lastBrace + 1));
+            return { plan, repaired: true };
+        }
+        catch { }
+    }
+    // Try 4: if the model answered directly (no JSON at all),
+    // wrap as a direct-answer plan so the executor can return it immediately.
+    // Heuristic: >10 chars, not an error message, not too long.
+    const trimmed = raw.trim();
+    const looksLikeAnswer = trimmed.length > 10 &&
+        trimmed.length < 4000 &&
+        !/^(error|failed|cannot|unable)/i.test(trimmed);
+    if (looksLikeAnswer) {
+        const directPlan = {
+            goal: trimmed.slice(0, 80),
+            requires_execution: false,
+            plan: [],
+            phases: [],
+            direct_response: trimmed,
+            reasoning: 'Model provided direct answer without structured plan',
+        };
+        return { plan: directPlan, repaired: true, directAnswer: trimmed };
+    }
+    return { plan: null, repaired: false };
+}

package/dist/core/planTool.js

@@ -0,0 +1,111 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planTool = void 0;
+// core/planTool.ts — Manus-style phased task planner.
+// Tracks multi-phase task execution with workspace persistence.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// ── PlanTool singleton ────────────────────────────────────────
+class PlanTool {
+    constructor() {
+        this.activePlans = new Map();
+    }
+    create(goal, phases) {
+        const id = `task_${Date.now()}`;
+        const workspaceDir = path_1.default.join(process.cwd(), 'workspace', 'tasks', id);
+        fs_1.default.mkdirSync(workspaceDir, { recursive: true });
+        const plan = {
+            id,
+            goal,
+            phases: phases.map((p, i) => ({
+                ...p,
+                status: i === 0 ? 'running' : 'pending',
+                startedAt: i === 0 ? Date.now() : undefined,
+            })),
+            currentPhaseIndex: 0,
+            status: 'running',
+            createdAt: Date.now(),
+            workspaceDir,
+        };
+        this.activePlans.set(id, plan);
+        this.savePlan(plan);
+        return plan;
+    }
+    advancePhase(planId, result) {
+        const plan = this.activePlans.get(planId);
+        if (!plan)
+            return null;
+        const current = plan.phases[plan.currentPhaseIndex];
+        if (current) {
+            current.status = 'done';
+            current.result = result;
+            current.completedAt = Date.now();
+        }
+        plan.currentPhaseIndex++;
+        if (plan.currentPhaseIndex >= plan.phases.length) {
+            plan.status = 'done';
+            plan.completedAt = Date.now();
+            this.savePlan(plan);
+            return null;
+        }
+        const next = plan.phases[plan.currentPhaseIndex];
+        next.status = 'running';
+        next.startedAt = Date.now();
+        this.savePlan(plan);
+        return next;
+    }
+    failPhase(planId, error) {
+        const plan = this.activePlans.get(planId);
+        if (!plan)
+            return;
+        const current = plan.phases[plan.currentPhaseIndex];
+        if (current) {
+            current.status = 'failed';
+            current.result = error;
+        }
+        plan.status = 'failed';
+        this.savePlan(plan);
+    }
+    getCurrentPhase(planId) {
+        const plan = this.activePlans.get(planId);
+        if (!plan)
+            return null;
+        return plan.phases[plan.currentPhaseIndex] || null;
+    }
+    getPlan(planId) {
+        return this.activePlans.get(planId) || this.loadPlan(planId);
+    }
+    formatSummary(plan) {
+        return plan.phases.map((p, i) => {
+            const icon = p.status === 'done' ? '✓' : p.status === 'running' ? '▶' : p.status === 'failed' ? '✗' : '○';
+            return `${icon} Phase ${i + 1}: ${p.title}`;
+        }).join(' → ');
+    }
+    savePlan(plan) {
+        try {
+            fs_1.default.writeFileSync(path_1.default.join(plan.workspaceDir, 'plan.json'), JSON.stringify(plan, null, 2));
+        }
+        catch { }
+    }
+    loadPlan(planId) {
+        try {
+            const planPath = path_1.default.join(process.cwd(), 'workspace', 'tasks', planId, 'plan.json');
+            if (!fs_1.default.existsSync(planPath))
+                return null;
+            const loaded = JSON.parse(fs_1.default.readFileSync(planPath, 'utf-8'));
+            this.activePlans.set(planId, loaded);
+            return loaded;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.planTool = new PlanTool();

package/dist/core/playwrightBridge.js

@@ -0,0 +1,356 @@
+"use strict";
+// ============================================================
+// core/playwrightBridge.ts — Centralised Playwright session
+// ============================================================
+// Single persistent browser context shared across all tool calls
+// within a server session.  All browser tools route through here
+// instead of duplicating context/page management in toolRegistry.
+//
+// Environment variables:
+//   AIDEN_BROWSER_HEADLESS=true   run headless (default: false / headed)
+//   AIDEN_BROWSER_TIMEOUT=15000   default navigation timeout in ms
+// ============================================================
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pwNavigate = pwNavigate;
+exports.pwScreenshot = pwScreenshot;
+exports.pwClick = pwClick;
+exports.pwClickFirstResult = pwClickFirstResult;
+exports.pwType = pwType;
+exports.pwScroll = pwScroll;
+exports.pwSnapshot = pwSnapshot;
+exports.pwGetUrl = pwGetUrl;
+exports.pwClose = pwClose;
+exports.getActiveBrowserPage = getActiveBrowserPage;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const paths_1 = require("./paths");
+// ── Lazy-import Playwright so the server boots even if playwright
+//    is not installed (tools will return a clear error message).
+let _chromium = null;
+async function getChromium() {
+    if (!_chromium) {
+        const pw = await Promise.resolve().then(() => __importStar(require('playwright')));
+        _chromium = pw.chromium;
+    }
+    return _chromium;
+}
+// ── Singleton state ──────────────────────────────────────────
+let _browserContext = null;
+let _activePage = null;
+let _idleTimer = null;
+const IDLE_MS = 5 * 60 * 1000; // 5 min
+const NAV_TIMEOUT = parseInt(process.env.AIDEN_BROWSER_TIMEOUT ?? '15000', 10);
+const HEADLESS = process.env.AIDEN_BROWSER_HEADLESS === 'true';
+function getBrowserProfileDir() {
+    const base = (0, paths_1.getUserDataDir)();
+    const dir = path_1.default.join(base, 'browser-profile');
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function resetIdleTimer() {
+    if (_idleTimer)
+        clearTimeout(_idleTimer);
+    _idleTimer = setTimeout(async () => {
+        if (_browserContext) {
+            console.log('[Browser] Closing idle browser after 5 min inactivity');
+            try {
+                await _browserContext.close();
+            }
+            catch { }
+            _browserContext = null;
+            _activePage = null;
+        }
+    }, IDLE_MS);
+}
+async function ensureContext() {
+    if (!_browserContext) {
+        const chromium = await getChromium();
+        const profile = getBrowserProfileDir();
+        console.log(`[Browser] Launching — profile: ${profile}  headless: ${HEADLESS}`);
+        _browserContext = await chromium.launchPersistentContext(profile, {
+            headless: HEADLESS,
+            viewport: { width: 1280, height: 720 },
+        });
+    }
+    resetIdleTimer();
+    return _browserContext;
+}
+async function ensurePage() {
+    const ctx = await ensureContext();
+    const pages = ctx.pages();
+    if (!_activePage || _activePage.isClosed()) {
+        const blank = pages.find((p) => p.url() === 'about:blank');
+        _activePage = blank ?? await ctx.newPage();
+    }
+    return _activePage;
+}
+// ── Exported helpers ─────────────────────────────────────────
+// ── Playwright availability check ────────────────────────────────────────────
+let _pwAvailable = null;
+async function checkPwAvailable() {
+    if (_pwAvailable !== null)
+        return _pwAvailable;
+    try {
+        await Promise.resolve().then(() => __importStar(require('playwright')));
+        _pwAvailable = true;
+        console.log('[Browser] playwright available');
+    }
+    catch {
+        _pwAvailable = false;
+        console.warn('[Browser] playwright not installed — browser tools unavailable. Run: npm install playwright');
+    }
+    return _pwAvailable;
+}
+/** Navigate to a URL, reusing the active page (opens blank tab if needed). */
+async function pwNavigate(url) {
+    const available = await checkPwAvailable();
+    if (!available) {
+        return { ok: false, url, error: 'playwright not installed. Run: npm install playwright && npx playwright install chromium' };
+    }
+    try {
+        const ctx = await ensureContext();
+        const pages = ctx.pages();
+        const blank = pages.find((p) => p.url() === 'about:blank');
+        _activePage = blank ?? await ctx.newPage();
+        await _activePage.goto(url, { waitUntil: 'domcontentloaded', timeout: NAV_TIMEOUT });
+        return { ok: true, url: _activePage.url() };
+    }
+    catch (e) {
+        return { ok: false, url, error: e.message };
+    }
+}
+/** Take a full-page screenshot, saved to workspace/screenshots/. Returns the file path. */
+async function pwScreenshot() {
+    try {
+        const page = await ensurePage();
+        const dir = path_1.default.join(process.cwd(), 'workspace', 'screenshots');
+        fs_1.default.mkdirSync(dir, { recursive: true });
+        const file = path_1.default.join(dir, `screenshot_${Date.now()}.png`);
+        await page.screenshot({ path: file, fullPage: false });
+        return { ok: true, path: file };
+    }
+    catch (e) {
+        return { ok: false, error: e.message };
+    }
+}
+/** Click an element by CSS selector or text.  Pass 'first_result' for search-result shortcuts. */
+async function pwClick(target) {
+    try {
+        const page = await ensurePage();
+        const tryClick = async (sel) => {
+            try {
+                await page.waitForSelector(sel, { state: 'visible', timeout: 5000 });
+                await page.locator(sel).first().click({ timeout: 5000 });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        };
+        const clicked = (await tryClick(target)) || (await tryClick(`text=${target}`));
+        if (!clicked)
+            return { ok: false, error: `Element not found or not visible: "${target}"` };
+        await page.waitForLoadState('domcontentloaded', { timeout: 5000 }).catch(() => { });
+        return { ok: true };
+    }
+    catch (e) {
+        return { ok: false, error: e.message };
+    }
+}
+/** Click the first organic search result on Google / YouTube / DuckDuckGo / Bing. */
+async function pwClickFirstResult() {
+    try {
+        const page = await ensurePage();
+        const currentUrl = page.url();
+        const SITES = [
+            {
+                pattern: /youtube\.com\/results/,
+                cfg: { selectors: ['a#video-title', 'ytd-video-renderer a[href*="/watch"]', 'ytd-rich-item-renderer a#thumbnail'], navPattern: /youtube\.com\/watch/ },
+            },
+            {
+                pattern: /google\.com\/search/,
+                cfg: { selectors: ['div.g h3 a', 'div#search a[href]:not([href*="google.com/search"])', 'h3.LC20lb'] },
+            },
+            {
+                pattern: /duckduckgo\.com/,
+                cfg: { selectors: ['article[data-testid="result"] h2 a', 'a.result__a', 'ol.react-results--main li a[data-testid="result-title-a"]'] },
+            },
+            {
+                pattern: /bing\.com\/search/,
+                cfg: { selectors: ['li.b_algo h2 a', '#b_results .b_algo a'] },
+            },
+        ];
+        const match = SITES.find(s => s.pattern.test(currentUrl));
+        if (!match)
+            return { ok: false, error: `first_result not supported for ${currentUrl}` };
+        let locator = null;
+        for (const sel of match.cfg.selectors) {
+            try {
+                await page.waitForSelector(sel, { state: 'visible', timeout: 8000 });
+                locator = page.locator(sel).first();
+                break;
+            }
+            catch { /* try next */ }
+        }
+        if (!locator)
+            return { ok: false, error: `No result selector appeared on ${currentUrl}` };
+        if (match.cfg.navPattern) {
+            await Promise.all([
+                page.waitForURL(match.cfg.navPattern, { timeout: 12000 }),
+                locator.click({ timeout: 5000 }),
+            ]);
+        }
+        else {
+            await locator.click({ timeout: 5000 });
+            await page.waitForLoadState('domcontentloaded', { timeout: 8000 }).catch(() => { });
+        }
+        return { ok: true, url: page.url() };
+    }
+    catch (e) {
+        return { ok: false, error: e.message };
+    }
+}
+/** Type text into the specified selector (defaults to first input). */
+async function pwType(selector, text) {
+    try {
+        const page = await ensurePage();
+        await page.waitForSelector(selector, { state: 'visible', timeout: 5000 }).catch(() => { });
+        await page.fill(selector, text);
+        return { ok: true };
+    }
+    catch (e) {
+        return { ok: false, error: e.message };
+    }
+}
+/** Scroll the page or a specific element. */
+async function pwScroll(direction, amount, selector) {
+    try {
+        const page = await ensurePage();
+        if (selector) {
+            await page.waitForSelector(selector, { state: 'visible', timeout: 5000 }).catch(() => { });
+            if (direction === 'top') {
+                await page.evaluate((sel) => {
+                    // eslint-disable-next-line no-undef
+                    const el = globalThis.document.querySelector(sel);
+                    if (el)
+                        el.scrollTop = 0;
+                }, selector);
+            }
+            else if (direction === 'bottom') {
+                await page.evaluate((sel) => {
+                    // eslint-disable-next-line no-undef
+                    const el = globalThis.document.querySelector(sel);
+                    if (el)
+                        el.scrollTop = el.scrollHeight;
+                }, selector);
+            }
+            else {
+                const delta = direction === 'up' ? -amount : amount;
+                await page.evaluate(({ sel, dy }) => {
+                    // eslint-disable-next-line no-undef
+                    const el = globalThis.document.querySelector(sel);
+                    if (el)
+                        el.scrollBy(0, dy);
+                }, { sel: selector, dy: delta });
+            }
+        }
+        else {
+            if (direction === 'top') {
+                await page.evaluate(() => globalThis.window.scrollTo(0, 0));
+            }
+            else if (direction === 'bottom') {
+                await page.evaluate(() => globalThis.window.scrollTo(0, globalThis.document.body.scrollHeight));
+            }
+            else {
+                const delta = direction === 'up' ? -amount : amount;
+                await page.evaluate((dy) => globalThis.window.scrollBy(0, dy), delta);
+            }
+        }
+        return { ok: true };
+    }
+    catch (e) {
+        return { ok: false, error: e.message };
+    }
+}
+/** Extract visible text from the current page body (first 3 000 chars). */
+async function pwSnapshot() {
+    try {
+        const page = await ensurePage();
+        // eslint-disable-next-line no-undef
+        const text = await page.evaluate(() => globalThis.document.body.innerText);
+        return { ok: true, text: text.slice(0, 3000) };
+    }
+    catch (e) {
+        return { ok: false, error: e.message };
+    }
+}
+/** Return the URL currently loaded in the active browser page. */
+async function pwGetUrl() {
+    try {
+        if (!_activePage || _activePage.isClosed()) {
+            const ctx = await ensureContext();
+            const pages = ctx.pages();
+            if (pages.length === 0)
+                return { ok: false, error: 'No browser page open. Use open_browser first.' };
+            _activePage = pages[pages.length - 1];
+        }
+        return { ok: true, url: _activePage.url() };
+    }
+    catch (e) {
+        return { ok: false, error: e.message };
+    }
+}
+/** Close the browser context and release all resources (call on server shutdown). */
+async function pwClose() {
+    if (_idleTimer) {
+        clearTimeout(_idleTimer);
+        _idleTimer = null;
+    }
+    if (_browserContext) {
+        try {
+            await _browserContext.close();
+        }
+        catch { }
+        _browserContext = null;
+        _activePage = null;
+        console.log('[Browser] Closed on shutdown');
+    }
+}
+/** Expose active page for legacy callers that still need it. */
+function getActiveBrowserPage() { return _activePage; }

package/dist/core/pluginSystem.js

@@ -0,0 +1,121 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluginManager = void 0;
+// core/pluginSystem.ts — Plugin system foundation.
+// Allows community extensions without modifying core code.
+// Scans workspace/plugins/*/plugin.json, loads entry files,
+// and calls onLoad(ctx) with a sandboxed PluginContext.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const toolRegistry_1 = require("./toolRegistry");
+const hooks_1 = require("./hooks");
+const PLUGINS_DIR = path_1.default.join(process.cwd(), 'workspace', 'plugins');
+// ── PluginManager ──────────────────────────────────────────────
+class PluginManager {
+    constructor() {
+        this.loaded = [];
+    }
+    // ── Load all plugins from workspace/plugins/ ───────────────
+    async loadAll() {
+        if (!fs_1.default.existsSync(PLUGINS_DIR)) {
+            console.log('[Plugins] No plugins directory found — skipping');
+            return;
+        }
+        const dirs = fs_1.default.readdirSync(PLUGINS_DIR, { withFileTypes: true })
+            .filter(d => d.isDirectory())
+            .map(d => path_1.default.join(PLUGINS_DIR, d.name));
+        for (const dir of dirs) {
+            try {
+                await this.loadPlugin(dir);
+            }
+            catch (e) {
+                console.error(`[Plugins] Failed to load plugin at ${path_1.default.basename(dir)}:`, e.message);
+            }
+        }
+        console.log(`[Plugins] ${this.loaded.length} plugin(s) active`);
+    }
+    // ── Load a single plugin directory ────────────────────────
+    async loadPlugin(dir) {
+        const manifestPath = path_1.default.join(dir, 'plugin.json');
+        if (!fs_1.default.existsSync(manifestPath)) {
+            console.warn(`[Plugins] No plugin.json in ${path_1.default.basename(dir)} — skipping`);
+            return;
+        }
+        let manifest;
+        try {
+            manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf-8'));
+        }
+        catch (e) {
+            throw new Error(`Invalid plugin.json: ${e.message}`);
+        }
+        if (!manifest.name || !manifest.version || !manifest.entry) {
+            throw new Error('plugin.json missing required fields: name, version, entry');
+        }
+        // ── Security: entry must not escape plugin directory ───────
+        const entryPath = path_1.default.resolve(dir, manifest.entry);
+        const resolvedBase = path_1.default.resolve(dir);
+        if (!entryPath.startsWith(resolvedBase + path_1.default.sep) && entryPath !== resolvedBase) {
+            throw new Error(`Security: entry path escapes plugin directory: ${manifest.entry}`);
+        }
+        if (!fs_1.default.existsSync(entryPath)) {
+            throw new Error(`Entry file not found: ${manifest.entry}`);
+        }
+        // ── Load the plugin module ─────────────────────────────────
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const mod = require(entryPath);
+        const plugin = mod.default ?? mod;
+        if (typeof plugin?.onLoad !== 'function') {
+            throw new Error(`Plugin "${manifest.name}" must export an object with an onLoad() function`);
+        }
+        // ── Build sandboxed context ────────────────────────────────
+        const ctx = {
+            registerTool: (def) => {
+                (0, toolRegistry_1.registerExternalTool)(def.name, def.execute, manifest.name);
+            },
+            registerHook: (event, handler) => {
+                (0, hooks_1.registerExternalHook)(event, handler, manifest.name);
+            },
+            log: (msg) => {
+                console.log(`[Plugin:${manifest.name}] ${msg}`);
+            },
+        };
+        await plugin.onLoad(ctx);
+        this.loaded.push({ manifest, dir, active: true, plugin });
+        console.log(`[Plugins] Loaded "${manifest.name}" v${manifest.version}${manifest.author ? ` by ${manifest.author}` : ''}`);
+    }
+    // ── List loaded plugins ────────────────────────────────────
+    list() {
+        return this.loaded.map(r => ({
+            name: r.manifest.name,
+            version: r.manifest.version,
+            description: r.manifest.description,
+            author: r.manifest.author,
+            active: r.active,
+        }));
+    }
+    // ── Unload all plugins ─────────────────────────────────────
+    async unloadAll() {
+        for (const record of this.loaded) {
+            try {
+                if (record.plugin?.onUnload) {
+                    await record.plugin.onUnload();
+                }
+                record.active = false;
+            }
+            catch (e) {
+                console.error(`[Plugins] onUnload error for "${record.manifest.name}":`, e.message);
+            }
+        }
+        console.log(`[Plugins] Unloaded ${this.loaded.length} plugin(s)`);
+        this.loaded = [];
+    }
+}
+// ── Singleton ──────────────────────────────────────────────────
+exports.pluginManager = new PluginManager();