maskweaver 0.7.0

package/dist/plugin/index.js

@@ -0,0 +1,811 @@
+/**
+* Maskweaver Plugin for opencode
+*
+* v0.6.0 - Memory, Context, and Retrospect tools integration
+*
+* Key features:
+* - Configuration-driven tool activation/deactivation
+* - Auto-activation of default masks
+* - Agent configuration overrides
+* - Event-based lifecycle hooks
+* - Memory and context management tools
+* - Clean plugin architecture
+*
+* Based on oh-my-opencode plugin development patterns.
+*/
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { z } from 'zod';
+import { loadPluginConfig, isMaskEnabled, isToolEnabled, getDefaultMask, isAutoActivateEnabled, getAgentOverride, isVerboseLoggingEnabled, validateConfig, } from './config';
+// New tool imports
+import { createMemorySearchTool } from './tools/memorySearch.js';
+import { createMemoryWriteTool } from './tools/memoryWrite.js';
+import { createMemoryGetTool } from './tools/memoryGet.js';
+import { createMemoryIndexerTool } from './tools/memoryIndexer.js';
+import { createContextTool } from './tools/context.js';
+import { createRetrospectTool } from './tools/retrospect.js';
+import { createMaskSaveTool } from './tools/maskSave.js';
+function getAssetsDir() {
+    // In ESM, use import.meta.url to find the assets directory
+    // When installed via npm: node_modules/@maskweaver/plugin/dist/index.js -> ../assets
+    // When local file: plugins/maskweaver.js -> ./assets (same directory)
+    try {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+        // First try: assets as sibling (npm package structure: dist/../assets)
+        const npmAssets = path.join(__dirname, '..', 'assets');
+        if (fs.existsSync(npmAssets)) {
+            return npmAssets;
+        }
+        // Second try: assets as subdirectory (local file: plugins/assets)
+        const localAssets = path.join(__dirname, 'assets');
+        if (fs.existsSync(localAssets)) {
+            return localAssets;
+        }
+        // Fallback to npm structure
+        return npmAssets;
+    }
+    catch {
+        // Fallback for CommonJS or other environments
+        return path.join(__dirname, '..', 'assets');
+    }
+}
+function copyDirRecursive(src, dest, result) {
+    if (!fs.existsSync(src))
+        return;
+    if (!fs.existsSync(dest)) {
+        fs.mkdirSync(dest, { recursive: true });
+    }
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirRecursive(srcPath, destPath, result);
+        }
+        else {
+            // Only copy if destination doesn't exist (don't overwrite user customizations)
+            if (!fs.existsSync(destPath)) {
+                try {
+                    fs.copyFileSync(srcPath, destPath);
+                    result.installed.push(destPath);
+                }
+                catch (e) {
+                    result.errors.push(`Failed to copy ${entry.name}: ${e}`);
+                }
+            }
+            else {
+                result.skipped.push(destPath);
+            }
+        }
+    }
+}
+function installAssets(projectDir) {
+    const result = {
+        installed: [],
+        skipped: [],
+        errors: [],
+    };
+    const assetsDir = getAssetsDir();
+    const opencodeDir = path.join(projectDir, '.opencode');
+    // Ensure .opencode directory exists
+    if (!fs.existsSync(opencodeDir)) {
+        fs.mkdirSync(opencodeDir, { recursive: true });
+    }
+    // Install agents
+    const agentsSrc = path.join(assetsDir, 'agents');
+    const agentsDest = path.join(opencodeDir, 'agents');
+    copyDirRecursive(agentsSrc, agentsDest, result);
+    // Install masks
+    const masksSrc = path.join(assetsDir, 'masks');
+    const masksDest = path.join(opencodeDir, 'masks');
+    copyDirRecursive(masksSrc, masksDest, result);
+    // Install commands (if any)
+    const commandsSrc = path.join(assetsDir, 'commands');
+    const commandsDest = path.join(opencodeDir, 'commands');
+    if (fs.existsSync(commandsSrc)) {
+        copyDirRecursive(commandsSrc, commandsDest, result);
+    }
+    return result;
+}
+// ============================================================================
+// Simple YAML Parser
+// ============================================================================
+function parseSimpleYaml(content) {
+    const lines = content.split('\n');
+    const result = {};
+    const stack = [
+        { indent: -2, obj: result },
+    ];
+    let currentArrayKey = undefined;
+    let currentArray = [];
+    let multilineKey = null;
+    let multilineValue = [];
+    let multilineIndent = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trimStart();
+        if (!trimmed || trimmed.startsWith('#')) {
+            if (multilineKey)
+                multilineValue.push('');
+            continue;
+        }
+        const indent = line.length - trimmed.length;
+        if (multilineKey) {
+            if (indent > multilineIndent || (indent === multilineIndent && !trimmed.includes(':'))) {
+                multilineValue.push(trimmed);
+                continue;
+            }
+            else {
+                const parent = stack[stack.length - 1];
+                parent.obj[multilineKey] = multilineValue.join('\n').trim();
+                multilineKey = null;
+                multilineValue = [];
+            }
+        }
+        if (trimmed.startsWith('- ')) {
+            const value = trimmed.slice(2).trim();
+            while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
+                const popped = stack.pop();
+                if (popped.key && currentArrayKey === popped.key) {
+                    const parent = stack[stack.length - 1];
+                    parent.obj[popped.key] = currentArray;
+                    currentArrayKey = undefined;
+                    currentArray = [];
+                }
+            }
+            if (value.includes(':')) {
+                const colonIdx = value.indexOf(':');
+                const objKey = value.slice(0, colonIdx).trim();
+                const objVal = value.slice(colonIdx + 1).trim();
+                const arrayItem = {};
+                if (objVal)
+                    arrayItem[objKey] = parseValue(objVal);
+                let j = i + 1;
+                const itemIndent = indent + 2;
+                while (j < lines.length) {
+                    const nextLine = lines[j];
+                    const nextTrimmed = nextLine.trimStart();
+                    const nextIndent = nextLine.length - nextTrimmed.length;
+                    if (!nextTrimmed || nextTrimmed.startsWith('#')) {
+                        j++;
+                        continue;
+                    }
+                    if (nextIndent < itemIndent || nextTrimmed.startsWith('- '))
+                        break;
+                    if (nextTrimmed.includes(':')) {
+                        const nColonIdx = nextTrimmed.indexOf(':');
+                        const nKey = nextTrimmed.slice(0, nColonIdx).trim();
+                        const nVal = nextTrimmed.slice(nColonIdx + 1).trim();
+                        if (nVal)
+                            arrayItem[nKey] = parseValue(nVal);
+                    }
+                    j++;
+                }
+                i = j - 1;
+                currentArray.push(arrayItem);
+            }
+            else {
+                currentArray.push(parseValue(value));
+            }
+            if (!currentArrayKey) {
+                for (let s = stack.length - 1; s >= 0; s--) {
+                    if (stack[s].key) {
+                        currentArrayKey = stack[s].key;
+                        break;
+                    }
+                }
+            }
+            continue;
+        }
+        if (trimmed.includes(':')) {
+            while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
+                const popped = stack.pop();
+                if (popped.key && currentArrayKey === popped.key) {
+                    const parent = stack[stack.length - 1];
+                    parent.obj[popped.key] = currentArray;
+                    currentArrayKey = undefined;
+                    currentArray = [];
+                }
+            }
+            if (currentArrayKey) {
+                const parent = stack[stack.length - 1];
+                parent.obj[currentArrayKey] = currentArray;
+                currentArrayKey = undefined;
+                currentArray = [];
+            }
+            const colonIdx = trimmed.indexOf(':');
+            const key = trimmed.slice(0, colonIdx).trim();
+            const value = trimmed.slice(colonIdx + 1).trim();
+            const parent = stack[stack.length - 1];
+            if (!value) {
+                const nextLine = lines[i + 1];
+                if (nextLine && nextLine.trimStart().startsWith('|')) {
+                    multilineKey = key;
+                    multilineIndent = indent;
+                    i++;
+                    continue;
+                }
+                const newObj = {};
+                parent.obj[key] = newObj;
+                stack.push({ indent, obj: newObj, key });
+            }
+            else if (value === '|' || value === '>') {
+                multilineKey = key;
+                multilineIndent = indent;
+            }
+            else {
+                parent.obj[key] = parseValue(value);
+            }
+        }
+    }
+    if (multilineKey) {
+        const parent = stack[stack.length - 1];
+        parent.obj[multilineKey] = multilineValue.join('\n').trim();
+    }
+    if (currentArrayKey) {
+        const parent = stack[stack.length - 1];
+        parent.obj[currentArrayKey] = currentArray;
+    }
+    return result;
+}
+function parseValue(value) {
+    if (!value)
+        return '';
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    if (value === 'null' || value === '~')
+        return null;
+    const num = Number(value);
+    if (!isNaN(num) && value !== '')
+        return num;
+    return value;
+}
+// ============================================================================
+// Mask Loader
+// ============================================================================
+class MaskLoader {
+    masksDir;
+    catalog = null;
+    cache = new Map();
+    config;
+    constructor(masksDir, config) {
+        this.masksDir = masksDir;
+        this.config = config;
+    }
+    async loadCatalog() {
+        if (this.catalog)
+            return this.catalog;
+        const indexPath = path.join(this.masksDir, 'index.json');
+        if (!fs.existsSync(indexPath))
+            throw new Error(`Catalog not found: ${indexPath}`);
+        const content = fs.readFileSync(indexPath, 'utf-8');
+        this.catalog = JSON.parse(content);
+        return this.catalog;
+    }
+    async load(maskId) {
+        // Check if mask is disabled in configuration
+        if (!isMaskEnabled(this.config, maskId)) {
+            return null;
+        }
+        if (this.cache.has(maskId))
+            return this.cache.get(maskId);
+        const catalog = await this.loadCatalog();
+        let entry = null;
+        let categoryId = null;
+        for (const [catId, category] of Object.entries(catalog.categories)) {
+            const found = category.masks.find(m => m.id === maskId);
+            if (found) {
+                entry = found;
+                categoryId = catId;
+                break;
+            }
+        }
+        if (!entry || !categoryId)
+            return null;
+        const filePath = path.join(this.masksDir, entry.file);
+        if (!fs.existsSync(filePath))
+            throw new Error(`File not found: ${filePath}`);
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const parsed = filePath.endsWith('.yaml') || filePath.endsWith('.yml')
+            ? parseSimpleYaml(content) : JSON.parse(content);
+        const loadedMask = { ...parsed, category: categoryId, filePath };
+        this.cache.set(maskId, loadedMask);
+        return loadedMask;
+    }
+    async listAll() {
+        const catalog = await this.loadCatalog();
+        const result = [];
+        for (const [categoryId, category] of Object.entries(catalog.categories)) {
+            for (const mask of category.masks) {
+                // Filter out disabled masks
+                if (isMaskEnabled(this.config, mask.id)) {
+                    result.push({ ...mask, category: categoryId });
+                }
+            }
+        }
+        return result;
+    }
+    async listCategories() {
+        const catalog = await this.loadCatalog();
+        return Object.entries(catalog.categories).map(([id, cat]) => {
+            // Count only enabled masks
+            const enabledMasks = cat.masks.filter(m => isMaskEnabled(this.config, m.id));
+            return {
+                id,
+                name: cat.name,
+                description: cat.description,
+                count: enabledMasks.length,
+            };
+        });
+    }
+}
+// ============================================================================
+// Prompt Builder
+// ============================================================================
+function buildRichPrompt(mask) {
+    const parts = [];
+    parts.push(`You are ${mask.profile.name}.`);
+    parts.push(`${mask.profile.tagline}`);
+    parts.push('');
+    parts.push('BACKGROUND:');
+    parts.push(mask.profile.background.trim());
+    parts.push('');
+    parts.push('YOUR EXPERTISE:');
+    for (const exp of mask.profile.expertise)
+        parts.push(`- ${exp}`);
+    parts.push('');
+    parts.push('YOUR THINKING STYLE:');
+    parts.push(mask.profile.thinkingStyle.trim());
+    parts.push('');
+    parts.push('INSTRUCTIONS:');
+    parts.push(mask.behavior.systemPrompt.trim());
+    parts.push('');
+    const style = mask.behavior.communicationStyle;
+    parts.push('COMMUNICATION STYLE:');
+    parts.push(`- Tone: ${style.tone}`);
+    parts.push(`- Verbosity: ${style.verbosity}`);
+    parts.push(`- Technical depth: ${style.technicalDepth}`);
+    parts.push('');
+    parts.push('YOUR STRENGTHS:');
+    for (const strength of mask.profile.strengths)
+        parts.push(`- ${strength}`);
+    if (mask.profile.limitations?.length) {
+        parts.push('');
+        parts.push('ACKNOWLEDGE YOUR LIMITATIONS:');
+        for (const limitation of mask.profile.limitations)
+            parts.push(`- ${limitation}`);
+    }
+    if (mask.behavior.signaturePhrases?.length) {
+        parts.push('');
+        parts.push('PHRASES YOU MIGHT USE:');
+        for (const phrase of mask.behavior.signaturePhrases)
+            parts.push(`- "${phrase}"`);
+    }
+    return parts.join('\n');
+}
+// ============================================================================
+// Tool Factory Functions (oh-my-opencode pattern)
+// ============================================================================
+function createListMasksTool(maskLoader, activeMask) {
+    return {
+        description: 'List all available expert persona masks.',
+        args: z.object({
+            category: z.string().optional().describe('Filter by category'),
+        }),
+        async execute(args) {
+            try {
+                const masks = await maskLoader.listAll();
+                const categories = await maskLoader.listCategories();
+                let filtered = masks;
+                if (args.category) {
+                    filtered = masks.filter(m => m.category === args.category);
+                }
+                const lines = [];
+                lines.push(`Maskweaver v0.6.0 - ${filtered.length} masks available`);
+                const active = activeMask();
+                lines.push(`Active mask: ${active?.metadata.id || 'none'}`);
+                lines.push('');
+                lines.push('Categories:');
+                for (const cat of categories) {
+                    lines.push(`  - ${cat.id}: ${cat.name} (${cat.count} masks)`);
+                }
+                lines.push('');
+                lines.push('Masks:');
+                for (const mask of filtered) {
+                    lines.push(`  - ${mask.id}: ${mask.name} [${mask.category}]`);
+                }
+                return lines.join('\n');
+            }
+            catch (e) {
+                return `Error: ${e}`;
+            }
+        },
+    };
+}
+function createSelectMaskTool(maskLoader, activeMask, setActiveMask) {
+    return {
+        description: 'Select and apply an expert persona mask.',
+        args: z.object({
+            maskId: z.string().describe('Mask ID (e.g., "kent-beck")'),
+        }),
+        async execute(args) {
+            try {
+                const mask = await maskLoader.load(args.maskId);
+                if (!mask) {
+                    const available = await maskLoader.listAll();
+                    return `Error: Mask "${args.maskId}" not found.\nAvailable: ${available.map(m => m.id).join(', ')}`;
+                }
+                setActiveMask(mask);
+                return `✓ Mask activated: ${mask.profile.name}
+
+"${mask.profile.tagline}"
+
+Expertise: ${mask.profile.expertise.join(', ')}
+
+The mask prompt will be injected into all future messages.`;
+            }
+            catch (e) {
+                return `Error: ${e}`;
+            }
+        },
+    };
+}
+function createDeselectMaskTool(activeMask, setActiveMask) {
+    return {
+        description: 'Remove the current mask and return to default behavior.',
+        args: z.object({}),
+        async execute() {
+            const prev = activeMask();
+            setActiveMask(null);
+            if (prev) {
+                return `✓ Mask removed: ${prev.profile.name}\nReturned to default behavior.`;
+            }
+            return 'No mask was active.';
+        },
+    };
+}
+function createGetMaskPromptTool(maskLoader, activeMask) {
+    return {
+        description: 'View the full system prompt for a mask.',
+        args: z.object({
+            maskId: z.string().optional().describe('Mask ID (uses active mask if not specified)'),
+        }),
+        async execute(args) {
+            const maskId = args.maskId || activeMask()?.metadata.id;
+            if (!maskId)
+                return 'Error: No mask specified and no active mask.';
+            try {
+                const mask = await maskLoader.load(maskId);
+                if (!mask)
+                    return `Error: Mask "${maskId}" not found.`;
+                return `# ${mask.profile.name}\n\n${buildRichPrompt(mask)}`;
+            }
+            catch (e) {
+                return `Error: ${e}`;
+            }
+        },
+    };
+}
+function createMaskweaverStatusTool(maskLoader, masksDir, activeMask) {
+    return {
+        description: 'Check Maskweaver status.',
+        args: z.object({}),
+        async execute() {
+            let masksCount = 0;
+            let categoriesCount = 0;
+            if (maskLoader) {
+                try {
+                    const masks = await maskLoader.listAll();
+                    const categories = await maskLoader.listCategories();
+                    masksCount = masks.length;
+                    categoriesCount = categories.length;
+                }
+                catch (_e) { /* ignore */ }
+            }
+            const active = activeMask();
+            return `Maskweaver v0.6.0
+Masks directory: ${masksDir}
+Available: ${maskLoader ? 'yes' : 'no'}
+Total masks: ${masksCount}
+Categories: ${categoriesCount}
+Active mask: ${active ? `${active.profile.name} (${active.metadata.id})` : 'none'}`;
+        },
+    };
+}
+let state = null;
+// ============================================================================
+// Plugin (oh-my-opencode pattern)
+// ============================================================================
+export const MaskweaverPlugin = async ({ client, directory }) => {
+    // ==========================================================================
+    // 1. Load Configuration (oh-my-opencode pattern)
+    // ==========================================================================
+    const pluginConfig = loadPluginConfig(directory, { client, verbose: false });
+    // Validate configuration
+    const configErrors = validateConfig(pluginConfig);
+    if (configErrors.length > 0) {
+        client.app.log({
+            service: 'maskweaver',
+            level: 'warn',
+            message: `Configuration validation errors: ${configErrors.join(', ')}`,
+        });
+    }
+    const verbose = isVerboseLoggingEnabled(pluginConfig);
+    // ==========================================================================
+    // 2. Auto-install assets on first run
+    // ==========================================================================
+    const installResult = installAssets(directory);
+    if (installResult.installed.length > 0) {
+        client.app.log({
+            service: 'maskweaver',
+            level: 'info',
+            message: `Installed ${installResult.installed.length} files to .opencode/ (agents, masks)`,
+        });
+    }
+    if (installResult.errors.length > 0) {
+        client.app.log({
+            service: 'maskweaver',
+            level: 'warn',
+            message: `Asset errors: ${installResult.errors.join(', ')}`,
+        });
+    }
+    // ==========================================================================
+    // 3. Initialize masks
+    // ==========================================================================
+    const homeDir = os.homedir();
+    const globalMasksDir = path.join(homeDir, '.config', 'opencode', 'masks');
+    const projectMasksDir = path.join(directory, '.opencode', 'masks');
+    // Priority: project masks > global masks
+    const masksDir = fs.existsSync(projectMasksDir) ? projectMasksDir : globalMasksDir;
+    state = {
+        maskLoader: null,
+        activeMask: null,
+        masksDir,
+        config: pluginConfig,
+    };
+    // Log plugin loaded
+    client.app.log({
+        service: 'maskweaver',
+        level: 'info',
+        message: `Maskweaver plugin loaded v0.6.0 (oh-my-opencode pattern)`,
+    });
+    if (fs.existsSync(masksDir)) {
+        state.maskLoader = new MaskLoader(masksDir, pluginConfig);
+        try {
+            await state.maskLoader.loadCatalog();
+            if (verbose) {
+                client.app.log({
+                    service: 'maskweaver',
+                    level: 'info',
+                    message: `Masks found at: ${masksDir}`,
+                });
+            }
+        }
+        catch (e) {
+            client.app.log({
+                service: 'maskweaver',
+                level: 'warn',
+                message: `Failed to load masks: ${e}`,
+            });
+            state.maskLoader = null;
+        }
+    }
+    // ==========================================================================
+    // 4. Auto-activate default mask (oh-my-opencode pattern)
+    // ==========================================================================
+    const defaultMaskId = getDefaultMask(pluginConfig);
+    const autoActivate = isAutoActivateEnabled(pluginConfig);
+    if (defaultMaskId && autoActivate && state.maskLoader) {
+        try {
+            const defaultMask = await state.maskLoader.load(defaultMaskId);
+            if (defaultMask) {
+                state.activeMask = defaultMask;
+                client.app.log({
+                    service: 'maskweaver',
+                    level: 'info',
+                    message: `Auto-activated default mask: ${defaultMaskId} (${defaultMask.profile.name})`,
+                });
+            }
+            else {
+                client.app.log({
+                    service: 'maskweaver',
+                    level: 'warn',
+                    message: `Default mask "${defaultMaskId}" not found or disabled`,
+                });
+            }
+        }
+        catch (e) {
+            client.app.log({
+                service: 'maskweaver',
+                level: 'warn',
+                message: `Failed to auto-activate default mask: ${e}`,
+            });
+        }
+    }
+    // ==========================================================================
+    // 5. Helper functions for tool factories
+    // ==========================================================================
+    const getActiveMask = () => state?.activeMask || null;
+    const setActiveMask = (mask) => {
+        if (state)
+            state.activeMask = mask;
+    };
+    // ==========================================================================
+    // 6. Conditional tool registration (oh-my-opencode pattern)
+    // ==========================================================================
+    const isToolActive = (toolName) => isToolEnabled(pluginConfig, toolName);
+    const tools = {};
+    if (state.maskLoader) {
+        if (isToolActive('list_masks')) {
+            tools.list_masks = createListMasksTool(state.maskLoader, getActiveMask);
+        }
+        if (isToolActive('select_mask')) {
+            tools.select_mask = createSelectMaskTool(state.maskLoader, getActiveMask, setActiveMask);
+        }
+        if (isToolActive('deselect_mask')) {
+            tools.deselect_mask = createDeselectMaskTool(getActiveMask, setActiveMask);
+        }
+        if (isToolActive('get_mask_prompt')) {
+            tools.get_mask_prompt = createGetMaskPromptTool(state.maskLoader, getActiveMask);
+        }
+    }
+    if (isToolActive('maskweaver_status')) {
+        tools.maskweaver_status = createMaskweaverStatusTool(state.maskLoader, masksDir, getActiveMask);
+    }
+    // Memory tools
+    if (isToolActive('memory_search')) {
+        const memorySearchTool = createMemorySearchTool();
+        tools.memory_search = {
+            description: memorySearchTool.description,
+            args: memorySearchTool.args,
+            execute: (args) => memorySearchTool.execute(args, { worktree: directory }),
+        };
+    }
+    if (isToolActive('memory_write')) {
+        const memoryWriteTool = createMemoryWriteTool();
+        tools.memory_write = {
+            description: memoryWriteTool.description,
+            args: memoryWriteTool.args,
+            execute: (args) => memoryWriteTool.execute(args, { worktree: directory }),
+        };
+    }
+    if (isToolActive('memory_get')) {
+        const memoryGetTool = createMemoryGetTool();
+        tools.memory_get = {
+            description: memoryGetTool.description,
+            args: memoryGetTool.args,
+            execute: (args) => memoryGetTool.execute(args, { worktree: directory }),
+        };
+    }
+    if (isToolActive('memory_indexer')) {
+        const memoryIndexerTool = createMemoryIndexerTool();
+        tools.memory_indexer = {
+            description: memoryIndexerTool.description,
+            args: memoryIndexerTool.args,
+            execute: (args) => memoryIndexerTool.execute(args, { worktree: directory }),
+        };
+    }
+    // Context tool
+    if (isToolActive('context')) {
+        const contextTool = createContextTool();
+        tools.context = {
+            description: contextTool.description,
+            args: contextTool.args,
+            execute: (args) => contextTool.execute(args, { worktree: directory }),
+        };
+    }
+    // Retrospect tool
+    if (isToolActive('retrospect')) {
+        const retrospectTool = createRetrospectTool();
+        tools.retrospect = {
+            description: retrospectTool.description,
+            args: retrospectTool.args,
+            execute: (args) => retrospectTool.execute(args, { worktree: directory }),
+        };
+    }
+    // Mask save tool
+    if (isToolActive('mask_save')) {
+        const maskSaveTool = createMaskSaveTool();
+        tools.mask_save = {
+            description: maskSaveTool.description,
+            args: maskSaveTool.args,
+            execute: (args) => maskSaveTool.execute(args, { worktree: directory }),
+        };
+    }
+    // ==========================================================================
+    // 7. Return plugin hooks
+    // ==========================================================================
+    return {
+        // System prompt transform - inject active mask
+        'experimental.chat.system.transform': async (_input, output) => {
+            if (state?.activeMask) {
+                const maskPrompt = `<ACTIVE_PERSONA>
+You are currently embodying the "${state.activeMask.profile.name}" persona.
+
+${buildRichPrompt(state.activeMask)}
+</ACTIVE_PERSONA>`;
+                (output.system ||= []).push(maskPrompt);
+            }
+        },
+        // Conditional tools
+        tool: tools,
+        // Event hooks (oh-my-opencode pattern)
+        event: async ({ event }) => {
+            // Session created - log available masks
+            if (event.type === 'session.created') {
+                if (state?.maskLoader && verbose) {
+                    try {
+                        const masks = await state.maskLoader.listAll();
+                        const categories = await state.maskLoader.listCategories();
+                        client.app.log({
+                            service: 'maskweaver',
+                            level: 'info',
+                            message: `Session started - ${masks.length} masks available across ${categories.length} categories`,
+                        });
+                    }
+                    catch (_e) {
+                        // Ignore errors
+                    }
+                }
+            }
+            // Session deleted - cleanup
+            if (event.type === 'session.deleted') {
+                if (state && verbose) {
+                    const wasActive = state.activeMask !== null;
+                    state.activeMask = null;
+                    if (wasActive) {
+                        client.app.log({
+                            service: 'maskweaver',
+                            level: 'info',
+                            message: 'Session ended - active mask cleared',
+                        });
+                    }
+                }
+            }
+        },
+        // Config hook - agent overrides (oh-my-opencode pattern)
+        config: {
+            agent: async (agentConfig, context) => {
+                // Apply agent overrides from configuration
+                const agentName = context?.name;
+                if (!agentName)
+                    return agentConfig;
+                const override = getAgentOverride(pluginConfig, agentName);
+                if (!override)
+                    return agentConfig;
+                const modified = { ...agentConfig };
+                if (override.model) {
+                    modified.model = override.model;
+                    if (verbose) {
+                        client.app.log({
+                            service: 'maskweaver',
+                            level: 'info',
+                            message: `Agent "${agentName}" model overridden: ${override.model}`,
+                        });
+                    }
+                }
+                if (override.systemPrompt) {
+                    modified.systemPrompt = override.systemPrompt;
+                    if (verbose) {
+                        client.app.log({
+                            service: 'maskweaver',
+                            level: 'info',
+                            message: `Agent "${agentName}" system prompt overridden`,
+                        });
+                    }
+                }
+                return modified;
+            },
+        },
+    };
+};
+export default MaskweaverPlugin;
+//# sourceMappingURL=index.js.map