@fpr1m3/opencode-pai-plugin 1.0.1 → 1.2.0

package/README.md

@@ -13,12 +13,13 @@ This project is an OpenCode-compatible clone of the hook system from **Dan Miess
 ## Features
 
 ### 1. Identity & Context Injection
-*   **Core Skill Loading**: Automatically injects your `skills/core/SKILL.md` (from `PAI_DIR`) into the system prompt.
+*   **Core Skill Loading**: Automatically injects your `skill/core/SKILL.md` (from `PAI_DIR`) into the system prompt.
 *   **Dynamic Substitution**: Supports placeholders like `{{DA}}`, `{{DA_COLOR}}`, and `{{ENGINEER_NAME}}` for personalized interactions.
 *   **Project Requirements**: Automatically detects and loads `.opencode/dynamic-requirements.md` from your current project, allowing for task-specific instructions.
 
-### 2. Intelligent History & Logging
+### 2. Intelligent History & Logging (UOCS)
 *   **Real-time Event Capture**: Logs all tool calls and SDK events to `PAI_DIR/history/raw-outputs` in an analytics-ready JSONL format.
+*   **Universal Output Capture System (UOCS)**: Automatically parses assistant responses for structured sections (SUMMARY, ANALYSIS, etc.) and generates artifacts in `decisions/`, `learnings/`, `research/`, or `execution/` based on context.
 *   **Session Summaries**: Generates human-readable Markdown summaries in `PAI_DIR/history/sessions` at the end of every session, tracking files modified, tools used, and commands executed.
 *   **Agent Mapping**: Tracks session-to-agent relationships (e.g., mapping a subagent session to its specialized type).
 
@@ -36,7 +37,7 @@ The plugin centers around the `PAI_DIR` environment variable.
 
 | Variable | Description | Default |
 | :--- | :--- | :--- |
-| `PAI_DIR` | Root directory for PAI skills and history | `$XDG_CONFIG_HOME/opencode` |
+| `PAI_DIR` | Root directory for PAI skill and history | `$XDG_CONFIG_HOME/opencode` |
 | `DA` | Name of your Digital Assistant | `PAI` |
 | `ENGINEER_NAME` | Your name/identity | `Operator` |
 | `DA_COLOR` | UI color theme for your DA | `blue` |
@@ -55,7 +56,7 @@ Add the plugin to your global `opencode.json` configuration file (typically loca
 
 Upon first run, the plugin will automatically:
 1. Detect or create your `PAI_DIR` (default: `$XDG_CONFIG_HOME/opencode`).
-2. Initialize the required directory structure for skills and history.
+2. Initialize the required directory structure for skill and history.
 3. Create a default `SKILL.md` core identity if one does not exist.
 
 ## Development & Testing
@@ -72,7 +73,7 @@ We provide scripts to verify the plugin in a pristine environment:
 
 ---
 
-**Note**: This plugin is designed to work with the PAI ecosystem. While it auto-initializes a basic structure, you can customize your identity by editing `$PAI_DIR/skills/core/SKILL.md`.
+**Note**: This plugin is designed to work with the PAI ecosystem. While it auto-initializes a basic structure, you can customize your identity by editing `$PAI_DIR/skill/core/SKILL.md`.
 
 ---
 

package/dist/index.js

@@ -1,5 +1,5 @@
 import { Logger } from './lib/logger';
-import { PAI_DIR } from './lib/paths';
+import { PAI_DIR, HISTORY_DIR } from './lib/paths';
 import { validateCommand } from './lib/security';
 import { join } from 'path';
 import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
@@ -8,10 +8,16 @@ import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
  */
 function ensurePAIStructure() {
     const dirs = [
-        join(PAI_DIR, 'skills', 'core'),
-        join(PAI_DIR, 'history', 'raw-outputs'),
-        join(PAI_DIR, 'history', 'sessions'),
-        join(PAI_DIR, 'history', 'system-logs'),
+        join(PAI_DIR, 'skill', 'core'),
+        join(HISTORY_DIR, 'raw-outputs'),
+        join(HISTORY_DIR, 'sessions'),
+        join(HISTORY_DIR, 'learnings'),
+        join(HISTORY_DIR, 'decisions'),
+        join(HISTORY_DIR, 'research'),
+        join(HISTORY_DIR, 'execution', 'features'),
+        join(HISTORY_DIR, 'execution', 'bugs'),
+        join(HISTORY_DIR, 'execution', 'refactors'),
+        join(HISTORY_DIR, 'system-logs'),
     ];
     for (const dir of dirs) {
         if (!existsSync(dir)) {
@@ -24,7 +30,7 @@ function ensurePAIStructure() {
             }
         }
     }
-    const coreSkillPath = join(PAI_DIR, 'skills', 'core', 'SKILL.md');
+    const coreSkillPath = join(PAI_DIR, 'skill', 'core', 'SKILL.md');
     if (!existsSync(coreSkillPath)) {
         const defaultSkill = `# PAI Core Identity
 You are {{DA}}, a Personal AI Infrastructure. 
@@ -85,13 +91,17 @@ function generateTabTitle(completedLine) {
     return 'PAI Task Done';
 }
 export const PAIPlugin = async ({ worktree }) => {
-    let logger = null;
-    let currentSessionId = null;
+    const loggers = new Map();
+    // Track the latest text content for each message (from streaming parts)
+    // Key: messageID, Value: latest full text from part.text
+    const messageTextCache = new Map();
+    // Track which messages we've already processed for archival (deduplication)
+    const processedMessageIds = new Set();
     // Auto-initialize PAI infrastructure if needed
     ensurePAIStructure();
-    // Load CORE skill content from $PAI_DIR/skills/core/SKILL.md
+    // Load CORE skill content from $PAI_DIR/skill/core/SKILL.md
     let coreSkillContent = '';
-    const coreSkillPath = join(PAI_DIR, 'skills', 'core', 'SKILL.md');
+    const coreSkillPath = join(PAI_DIR, 'skill', 'core', 'SKILL.md');
     if (existsSync(coreSkillPath)) {
         try {
             coreSkillContent = readFileSync(coreSkillPath, 'utf-8');
@@ -125,17 +135,33 @@ export const PAIPlugin = async ({ worktree }) => {
     const hooks = {
         event: async ({ event }) => {
             const anyEvent = event;
-            // Initialize Logger on session creation
-            if (event.type === 'session.created') {
-                currentSessionId = anyEvent.properties.info.id;
-                logger = new Logger(currentSessionId);
+            // Get Session ID from event (try multiple locations)
+            const sessionId = anyEvent.properties?.part?.sessionID ||
+                anyEvent.properties?.info?.sessionID ||
+                anyEvent.properties?.sessionID ||
+                anyEvent.sessionID;
+            if (!sessionId)
+                return;
+            // Initialize Logger if needed
+            if (!loggers.has(sessionId)) {
+                loggers.set(sessionId, new Logger(sessionId, worktree));
             }
-            // Handle generic event logging
-            if (logger &&
-                event.type !== 'message.part.updated' &&
-                !shouldSkipEvent(event, currentSessionId)) {
+            const logger = loggers.get(sessionId);
+            // Handle generic event logging (skip streaming parts to reduce noise)
+            if (!shouldSkipEvent(event, sessionId) && event.type !== 'message.part.updated') {
                 logger.logOpenCodeEvent(event);
             }
+            // STREAMING CAPTURE: Cache the latest text from message.part.updated
+            // The part.text field contains the FULL accumulated text, not a delta
+            if (event.type === 'message.part.updated') {
+                const part = anyEvent.properties?.part;
+                const messageId = part?.messageID;
+                const partType = part?.type;
+                // Only cache text parts (not tool parts)
+                if (messageId && partType === 'text' && part?.text) {
+                    messageTextCache.set(messageId, part.text);
+                }
+            }
             // Handle real-time tab title updates (Pre-Tool Use)
             if (anyEvent.type === 'tool.call') {
                 const props = anyEvent.properties;
@@ -152,32 +178,67 @@ export const PAIPlugin = async ({ worktree }) => {
                     process.stderr.write(`\x1b]0;Agent: ${type}...\x07`);
                 }
             }
-            // Handle assistant completion (Tab Titles)
+            // Handle assistant message completion (Tab Titles & Artifact Archival)
             if (event.type === 'message.updated') {
                 const info = anyEvent.properties?.info;
-                if (info?.author === 'assistant' && info?.content) {
-                    const content = typeof info.content === 'string' ? info.content : '';
-                    // Look for COMPLETED: line (can be prefaced by 🎯 or just text)
-                    const completedMatch = content.match(/(?:🎯\s*)?COMPLETED:\s*(.+?)(?:\n|$)/i);
-                    if (completedMatch) {
-                        const completedLine = completedMatch[1].trim();
-                        // Set Tab Title
-                        const tabTitle = generateTabTitle(completedLine);
-                        process.stderr.write(`\x1b]0;${tabTitle}\x07`);
+                const role = info?.role || info?.author;
+                const messageId = info?.id;
+                if (role === 'assistant' && messageId) {
+                    // Get content from our streaming cache first, fallback to info.content
+                    let contentStr = messageTextCache.get(messageId) || '';
+                    // Fallback: try to get content from the event itself
+                    if (!contentStr) {
+                        const content = info?.content || info?.text || '';
+                        if (typeof content === 'string') {
+                            contentStr = content;
+                        }
+                        else if (Array.isArray(content)) {
+                            contentStr = content
+                                .map((p) => {
+                                if (typeof p === 'string')
+                                    return p;
+                                if (p?.text)
+                                    return p.text;
+                                if (p?.content)
+                                    return p.content;
+                                return '';
+                            })
+                                .join('');
+                        }
+                    }
+                    // Process if we have content and haven't processed this message yet
+                    if (contentStr && !processedMessageIds.has(messageId)) {
+                        processedMessageIds.add(messageId);
+                        // Look for COMPLETED: line for tab title
+                        const completedMatch = contentStr.match(/(?:🎯\s*)?COMPLETED:\s*(.+?)(?:\n|$)/i);
+                        if (completedMatch) {
+                            const completedLine = completedMatch[1].trim();
+                            const tabTitle = generateTabTitle(completedLine);
+                            process.stderr.write(`\x1b]0;${tabTitle}\x07`);
+                        }
+                        // Archive structured response
+                        await logger.processAssistantMessage(contentStr, messageId);
+                        // Clean up cache for this message
+                        messageTextCache.delete(messageId);
                     }
                 }
             }
             // Handle session deletion / end or idle (for one-shot commands)
             if (event.type === 'session.deleted' || event.type === 'session.idle') {
-                if (logger) {
-                    await logger.generateSessionSummary();
-                    logger.flush();
-                }
+                await logger.generateSessionSummary();
+                logger.flush();
+                loggers.delete(sessionId);
+                // Clean up any stale cache entries for this session
+                // (In practice, messages are cleaned up after processing)
             }
         },
         "tool.execute.after": async (input, output) => {
-            if (logger) {
-                logger.logToolExecution(input, output);
+            const sessionId = input.sessionID;
+            if (sessionId) {
+                if (!loggers.has(sessionId)) {
+                    loggers.set(sessionId, new Logger(sessionId, worktree));
+                }
+                loggers.get(sessionId).logToolExecution(input, output);
             }
         },
         "permission.ask": async (permission) => {

package/dist/lib/logger.d.ts

@@ -1,24 +1,21 @@
 import type { Event } from '@opencode-ai/sdk';
 export declare class Logger {
     private sessionId;
+    private worktree;
     private toolsUsed;
     private filesChanged;
     private commandsExecuted;
+    private processedMessageIds;
     private startTime;
-    constructor(sessionId: string);
+    constructor(sessionId: string, worktree?: string);
+    private getHistoryDir;
+    processAssistantMessage(content: string, messageId?: string): Promise<void>;
     private getPSTTimestamp;
     private getEventsFilePath;
     private getSessionMappingFile;
     private getAgentForSession;
     private setAgentForSession;
-    logEvent(event: Event): void;
     logOpenCodeEvent(event: Event): void;
-    /**
-     * Log tool execution from tool.execute.after hook
-     *
-     * Input structure: { tool: string; sessionID: string; callID: string }
-     * Output structure: { title: string; output: string; metadata: any }
-     */
     logToolExecution(input: {
         tool: string;
         sessionID: string;
@@ -29,6 +26,10 @@ export declare class Logger {
         metadata: any;
     }): void;
     generateSessionSummary(): Promise<string | null>;
+    private parseStructuredResponse;
+    private isLearningCapture;
+    private determineArtifactType;
+    private createArtifact;
     logError(context: string, error: any): void;
     private writeEvent;
     flush(): void;

package/dist/lib/logger.js

@@ -1,18 +1,52 @@
 import { existsSync, mkdirSync, appendFileSync, readFileSync, writeFileSync } from 'fs';
 import { dirname, join } from 'path';
-import { PAI_DIR, getHistoryFilePath, HISTORY_DIR } from './paths';
-import { enrichEventWithAgentMetadata, isAgentSpawningCall } from './metadata-extraction';
+import { PAI_DIR, HISTORY_DIR } from './paths';
+import { isAgentSpawningCall, enrichEventWithAgentMetadata } from './metadata-extraction';
 import { redactString, redactObject } from './redaction';
 export class Logger {
     sessionId;
+    worktree;
     toolsUsed = new Set();
     filesChanged = new Set();
     commandsExecuted = [];
+    processedMessageIds = new Set();
     startTime = Date.now();
-    constructor(sessionId) {
+    constructor(sessionId, worktree = '/') {
         this.sessionId = sessionId;
+        this.worktree = worktree;
+    }
+    getHistoryDir() {
+        if (process.env.HISTORY_DIR)
+            return process.env.HISTORY_DIR;
+        if (existsSync(PAI_DIR))
+            return HISTORY_DIR;
+        return join(this.worktree, '.opencode', 'history');
+    }
+    async processAssistantMessage(content, messageId) {
+        try {
+            // Deduplication: skip if we've already processed this message
+            if (messageId) {
+                if (this.processedMessageIds.has(messageId))
+                    return;
+                this.processedMessageIds.add(messageId);
+            }
+            // Parse structured response sections
+            const sections = this.parseStructuredResponse(content);
+            // Require at least SUMMARY or COMPLETED to be a valid structured response
+            // This prevents archiving every random message
+            const hasRequiredSection = sections['SUMMARY'] || sections['COMPLETED'];
+            if (!hasRequiredSection || Object.keys(sections).length < 2) {
+                return;
+            }
+            const agentRole = this.getAgentForSession(this.sessionId);
+            const isLearning = this.isLearningCapture(sections);
+            const type = this.determineArtifactType(agentRole, isLearning, sections);
+            await this.createArtifact(type, content, sections);
+        }
+        catch (error) {
+            this.logError('ProcessAssistantMessage', error);
+        }
     }
-    // Get PST timestamp
     getPSTTimestamp() {
         const date = new Date();
         const pstDate = new Date(date.toLocaleString('en-US', { timeZone: process.env.TIME_ZONE || 'America/Los_Angeles' }));
@@ -31,11 +65,11 @@ export class Logger {
         const month = String(pstDate.getMonth() + 1).padStart(2, '0');
         const day = String(pstDate.getDate()).padStart(2, '0');
         const filename = `${year}-${month}-${day}_all-events.jsonl`;
-        const filePath = getHistoryFilePath('raw-outputs', filename);
+        const historyDir = this.getHistoryDir();
+        const filePath = join(historyDir, 'raw-outputs', filename);
         const dir = dirname(filePath);
-        if (!existsSync(dir)) {
+        if (!existsSync(dir))
             mkdirSync(dir, { recursive: true });
-        }
         return filePath;
     }
     getSessionMappingFile() {
@@ -49,39 +83,24 @@ export class Logger {
                 return mappings[sessionId] || 'pai';
             }
         }
-        catch (error) {
-            // Ignore errors, default to pai
-        }
+        catch (error) { }
         return 'pai';
     }
     setAgentForSession(sessionId, agentName) {
         try {
             const mappingFile = this.getSessionMappingFile();
             let mappings = {};
-            if (existsSync(mappingFile)) {
+            if (existsSync(mappingFile))
                 mappings = JSON.parse(readFileSync(mappingFile, 'utf-8'));
-            }
             mappings[sessionId] = agentName;
             writeFileSync(mappingFile, JSON.stringify(mappings, null, 2), 'utf-8');
         }
-        catch (error) {
-            // Silently fail - don't block
-        }
-    }
-    logEvent(event) {
-        // Legacy method, not used much as we use logOpenCodeEvent
-        // But might be called from index.ts if I didn't update all calls
-        this.logOpenCodeEvent(event);
+        catch (error) { }
     }
-    // Method to log generic OpenCode event
     logOpenCodeEvent(event) {
         const anyEvent = event;
         const timestamp = anyEvent.timestamp || Date.now();
-        const payload = {
-            ...anyEvent.properties,
-            timestamp: timestamp
-        };
-        // Track stats for summary
+        const payload = { ...anyEvent.properties, timestamp };
         if (anyEvent.type === 'tool.call' || anyEvent.type === 'tool.execute.before') {
             const props = anyEvent.properties;
             const tool = props?.tool || props?.tool_name;
@@ -93,8 +112,8 @@ export class Logger {
                         this.commandsExecuted.push(redactString(command));
                 }
                 if (['Edit', 'Write', 'edit', 'write'].includes(tool)) {
-                    const path = props?.input?.file_path || props?.input?.path ||
-                        props?.tool_input?.file_path || props?.tool_input?.path;
+                    const path = props?.input?.file_path || props?.input?.path || props?.input?.filePath ||
+                        props?.tool_input?.file_path || props?.tool_input?.path || props?.tool_input?.filePath;
                     if (path)
                         this.filesChanged.add(path);
                 }
@@ -102,19 +121,11 @@ export class Logger {
         }
         this.writeEvent(anyEvent.type, redactObject(payload));
     }
-    /**
-     * Log tool execution from tool.execute.after hook
-     *
-     * Input structure: { tool: string; sessionID: string; callID: string }
-     * Output structure: { title: string; output: string; metadata: any }
-     */
     logToolExecution(input, output) {
         const toolName = input.tool;
         const sessionId = this.sessionId;
         this.toolsUsed.add(toolName);
-        // Extract metadata - may contain additional tool info
         const metadata = output.metadata || {};
-        // Logic to update agent mapping based on Task tool spawning subagents
         if (toolName === 'Task' && metadata?.subagent_type) {
             this.setAgentForSession(sessionId, metadata.subagent_type);
         }
@@ -129,22 +140,23 @@ export class Logger {
             call_id: input.callID,
         };
         this.writeEvent('ToolUse', redactObject(payload), toolName, metadata);
+        if (toolName === 'task' || toolName === 'Task') {
+            if (output.output)
+                this.processAssistantMessage(output.output);
+        }
     }
     async generateSessionSummary() {
         try {
             const now = new Date();
-            const timestamp = now.toISOString()
-                .replace(/:/g, '')
-                .replace(/\..+/, '')
-                .replace('T', '-'); // YYYY-MM-DD-HHMMSS
+            const timestamp = now.toISOString().replace(/:/g, '').replace(/\..+/, '').replace('T', '-');
             const yearMonth = timestamp.substring(0, 7);
             const date = timestamp.substring(0, 10);
             const time = timestamp.substring(11).replace(/-/g, ':');
             const duration = Math.round((Date.now() - this.startTime) / 60000);
-            const sessionDir = join(HISTORY_DIR, 'sessions', yearMonth);
-            if (!existsSync(sessionDir)) {
+            const historyDir = this.getHistoryDir();
+            const sessionDir = join(historyDir, 'sessions', yearMonth);
+            if (!existsSync(sessionDir))
                 mkdirSync(sessionDir, { recursive: true });
-            }
             const focus = this.filesChanged.size > 0 ? 'development' : 'research';
             const filename = `${timestamp}_SESSION_${focus}.md`;
             const filePath = join(sessionDir, filename);
@@ -204,10 +216,93 @@ This session summary was automatically generated by the PAI OpenCode Plugin.
             return filePath;
         }
         catch (error) {
-            this.logError('SessionSummary', error);
             return null;
         }
     }
+    parseStructuredResponse(content) {
+        const sections = {};
+        const sectionHeaders = ['SUMMARY', 'ANALYSIS', 'ACTIONS', 'RESULTS', 'STATUS', 'CAPTURE', 'NEXT', 'STORY EXPLANATION', 'COMPLETED'];
+        for (const header of sectionHeaders) {
+            // Match header with optional markdown bold (**) or other formatting
+            // Handles: "SUMMARY:", "**SUMMARY:**", "**SUMMARY**:", "* SUMMARY:", etc.
+            const regex = new RegExp(`(?:^|\\n)\\*{0,2}\\s*${header}\\s*\\*{0,2}:\\s*([\\s\\S]*?)(?=\\n\\*{0,2}\\s*(?:${sectionHeaders.join('|')})\\s*\\*{0,2}:|$)`, 'i');
+            const match = content.match(regex);
+            if (match && match[1])
+                sections[header] = match[1].trim();
+        }
+        return sections;
+    }
+    isLearningCapture(sections) {
+        const indicators = ['fixed', 'solved', 'discovered', 'lesson', 'troubleshoot', 'debug', 'root cause', 'learning', 'bug', 'issue', 'resolved'];
+        const textToSearch = ((sections['ANALYSIS'] || '') + ' ' + (sections['RESULTS'] || '')).toLowerCase();
+        let count = 0;
+        for (const indicator of indicators)
+            if (textToSearch.includes(indicator))
+                count++;
+        return count >= 2;
+    }
+    determineArtifactType(agentRole, isLearning, sections) {
+        const summary = (sections['SUMMARY'] || '').toLowerCase();
+        if (agentRole === 'architect')
+            return 'DECISION';
+        if (agentRole === 'researcher' || agentRole === 'pentester')
+            return 'RESEARCH';
+        if (agentRole === 'engineer' || agentRole === 'designer') {
+            if (summary.includes('fix') || summary.includes('bug') || summary.includes('issue'))
+                return 'BUG';
+            if (summary.includes('refactor') || summary.includes('improve') || summary.includes('cleanup'))
+                return 'REFACTOR';
+            return 'FEATURE';
+        }
+        return isLearning ? 'LEARNING' : 'WORK';
+    }
+    async createArtifact(type, content, sections) {
+        try {
+            const now = new Date();
+            const timestamp = now.toISOString().replace(/:/g, '').replace(/\..+/, '').replace('T', '-');
+            const yearMonth = timestamp.substring(0, 7);
+            const summary = sections['SUMMARY'] || 'no-summary';
+            const slug = summary.toLowerCase().replace(/[^\w\s-]/g, '').replace(/\s+/g, '-').substring(0, 50);
+            const filename = `${timestamp}_${type}_${slug}.md`;
+            let subdir = 'execution';
+            if (type === 'LEARNING')
+                subdir = 'learnings';
+            else if (type === 'DECISION')
+                subdir = 'decisions';
+            else if (type === 'RESEARCH')
+                subdir = 'research';
+            else if (type === 'WORK')
+                subdir = 'sessions';
+            else {
+                if (type === 'BUG')
+                    subdir = join('execution', 'bugs');
+                else if (type === 'REFACTOR')
+                    subdir = join('execution', 'refactors');
+                else
+                    subdir = join('execution', 'features');
+            }
+            const historyDir = this.getHistoryDir();
+            const targetDir = join(historyDir, subdir, yearMonth);
+            if (!existsSync(targetDir))
+                mkdirSync(targetDir, { recursive: true });
+            const filePath = join(targetDir, filename);
+            const agentRole = this.getAgentForSession(this.sessionId);
+            const frontmatter = `---
+capture_type: ${type}
+timestamp: ${new Date().toISOString()}
+session_id: ${this.sessionId}
+executor: ${agentRole}
+${sections['SUMMARY'] ? `summary: ${sections['SUMMARY'].replace(/"/g, '\\"')}` : ''}
+---
+
+${content}
+`;
+            writeFileSync(filePath, redactString(frontmatter), 'utf-8');
+        }
+        catch (e) {
+            this.logError('CreateArtifact', e);
+        }
+    }
     logError(context, error) {
         try {
             const now = new Date();
@@ -216,26 +311,22 @@ This session summary was automatically generated by the PAI OpenCode Plugin.
             const month = String(pstDate.getMonth() + 1).padStart(2, '0');
             const day = String(pstDate.getDate()).padStart(2, '0');
             const filename = `${year}-${month}-${day}_errors.log`;
-            const filePath = getHistoryFilePath('system-logs', filename);
+            const historyDir = this.getHistoryDir();
+            const filePath = join(historyDir, 'system-logs', filename);
             const dir = dirname(filePath);
-            if (!existsSync(dir)) {
+            if (!existsSync(dir))
                 mkdirSync(dir, { recursive: true });
-            }
             const timestamp = this.getPSTTimestamp();
             const errorMessage = error instanceof Error ? error.message : String(error);
             const stack = error instanceof Error ? error.stack : '';
             const logEntry = `[${timestamp}] [${context}] ${errorMessage}\n${stack}\n-------------------\n`;
             appendFileSync(filePath, logEntry, 'utf-8');
         }
-        catch (e) {
-            // Intentionally silent - TUI protection
-        }
+        catch (e) { }
     }
-    // Core write method
     writeEvent(eventType, payload, toolName, toolInput) {
         const sessionId = this.sessionId;
         let agentName = this.getAgentForSession(sessionId);
-        // Create base event object
         let hookEvent = {
             source_app: agentName,
             session_id: sessionId,
@@ -244,10 +335,8 @@ This session summary was automatically generated by the PAI OpenCode Plugin.
             timestamp: Date.now(),
             timestamp_pst: this.getPSTTimestamp()
         };
-        // Enrich with agent instance metadata if this is a Task tool call
         if (toolName && toolInput && isAgentSpawningCall(toolName, toolInput)) {
-            hookEvent = enrichEventWithAgentMetadata(hookEvent, toolInput, payload.description // Assuming description is available in payload if passed
-            );
+            hookEvent = enrichEventWithAgentMetadata(hookEvent, toolInput, payload.description);
         }
         try {
             const eventsFile = this.getEventsFilePath();
@@ -258,7 +347,5 @@ This session summary was automatically generated by the PAI OpenCode Plugin.
             this.logError('EventCapture', error);
         }
     }
-    flush() {
-        // No-op for now as we append synchronously
-    }
+    flush() { }
 }

package/dist/lib/paths.js

@@ -25,7 +25,7 @@ export const PAI_DIR = process.env.PAI_DIR
  * Common PAI directories
  */
 export const HOOKS_DIR = join(PAI_DIR, 'hooks');
-export const SKILLS_DIR = join(PAI_DIR, 'skills');
+export const SKILLS_DIR = join(PAI_DIR, 'skill');
 export const AGENTS_DIR = join(PAI_DIR, 'agents');
 export const HISTORY_DIR = join(PAI_DIR, 'history');
 export const COMMANDS_DIR = join(PAI_DIR, 'commands');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fpr1m3/opencode-pai-plugin",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "type": "module",
   "description": "Personal AI Infrastructure (PAI) plugin for OpenCode",
   "main": "dist/index.js",

package/dist/lib/context-loader.d.ts

@@ -1 +0,0 @@
-export declare function getCoreContext(baseDir: string, env: NodeJS.ProcessEnv): string;

package/dist/lib/context-loader.js

@@ -1,21 +0,0 @@
-import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
-import { getSkillsDir } from './paths';
-export function getCoreContext(baseDir, env) {
-    const skillsDir = getSkillsDir(baseDir);
-    const coreSkillPath = join(skillsDir, 'core', 'SKILL.md');
-    if (!existsSync(coreSkillPath)) {
-        console.warn(`Core skill file not found at ${coreSkillPath}`);
-        return '';
-    }
-    let content = readFileSync(coreSkillPath, 'utf-8');
-    // Variable replacement
-    const replacements = {
-        '{{DA}}': env.DA_NAME || 'PAI',
-        '{{ENGINEER_NAME}}': env.USER_NAME || env.USER || 'Engineer',
-    };
-    for (const [key, value] of Object.entries(replacements)) {
-        content = content.replaceAll(key, value);
-    }
-    return content;
-}

package/dist/lib/notifier.d.ts

@@ -1 +0,0 @@
-export declare function notifyVoiceServer(message: string): Promise<void>;

package/dist/lib/notifier.js

@@ -1,12 +0,0 @@
-export async function notifyVoiceServer(message) {
-    try {
-        await fetch('http://localhost:8888/notify', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ message }),
-        });
-    }
-    catch (error) {
-        // Ignore errors if server is not running
-    }
-}