@fpr1m3/opencode-pai-plugin 1.1.1 → 1.3.0

package/dist/index.js

@@ -91,8 +91,15 @@ 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();
+    // Track pending Task tool calls to capture subagent_type
+    // Key: callID, Value: subagent_type
+    const pendingTaskCalls = new Map();
     // Auto-initialize PAI infrastructure if needed
     ensurePAIStructure();
     // Load CORE skill content from $PAI_DIR/skill/core/SKILL.md
@@ -131,17 +138,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;
@@ -153,44 +176,95 @@ export const PAIPlugin = async ({ worktree }) => {
                     const file = props?.input?.file_path?.split('/').pop() || 'file';
                     process.stderr.write(`\x1b]0;Editing ${file}...\x07`);
                 }
-                else if (props?.tool === 'Task') {
+                else if (props?.tool === 'Task' || props?.tool === 'task') {
                     const type = props?.input?.subagent_type || 'agent';
                     process.stderr.write(`\x1b]0;Agent: ${type}...\x07`);
+                    // Cache the subagent_type for when tool.execute.after fires
+                    const callId = props?.id || props?.callId || props?.call_id;
+                    if (callId && props?.input?.subagent_type) {
+                        pendingTaskCalls.set(callId, props.input.subagent_type);
+                    }
                 }
             }
-            // Handle assistant completion (Tab Titles & UOCS)
+            // Handle assistant message completion (Tab Titles & Artifact Archival)
             if (event.type === 'message.updated') {
                 const info = anyEvent.properties?.info;
                 const role = info?.role || info?.author;
-                if (role === 'assistant') {
-                    // Robust content extraction
-                    const content = info?.content || info?.text || '';
-                    const contentStr = typeof content === 'string' ? content : '';
-                    // Look for COMPLETED: line (can be prefaced by 🎯 or just text)
-                    const completedMatch = contentStr.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`);
-                        // UOCS: Process response for artifact generation
-                        if (logger && contentStr) {
-                            await logger.processAssistantMessage(contentStr);
+                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.before": async (input, output) => {
+            // Cache subagent_type from Task tool args for later use in tool.execute.after
+            if ((input.tool === 'Task' || input.tool === 'task') && input.callID) {
+                const args = output.args;
+                if (args?.subagent_type) {
+                    pendingTaskCalls.set(input.callID, args.subagent_type);
                 }
             }
         },
         "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));
+                }
+                // For Task tools, inject the cached subagent_type into metadata
+                if ((input.tool === 'Task' || input.tool === 'task') && input.callID) {
+                    const cachedAgentType = pendingTaskCalls.get(input.callID);
+                    if (cachedAgentType) {
+                        output.metadata = output.metadata || {};
+                        output.metadata.subagent_type = cachedAgentType;
+                        pendingTaskCalls.delete(input.callID);
+                    }
+                }
+                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,9 +26,17 @@ export declare class Logger {
         metadata: any;
     }): void;
     generateSessionSummary(): Promise<string | null>;
-    processAssistantMessage(content: string): Promise<void>;
     private parseStructuredResponse;
     private isLearningCapture;
+    /**
+     * Normalize agent role from subagent_type patterns to base role.
+     * Handles patterns like:
+     *   - "subagents/researcher-claude" → "researcher"
+     *   - "subagents/sparc-architect" → "architect"
+     *   - "subagents/sparc-dev" → "engineer"
+     *   - "researcher" → "researcher" (passthrough)
+     */
+    private normalizeAgentRole;
     private determineArtifactType;
     private createArtifact;
     logError(context: string, error: any): 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
-        }
+        catch (error) { }
     }
-    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);
-    }
-    // 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,20 +121,12 @@ 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) {
+        if ((toolName === 'Task' || toolName === 'task') && metadata?.subagent_type) {
             this.setAgentForSession(sessionId, metadata.subagent_type);
         }
         else if (toolName === 'subagent_stop' || toolName === 'stop') {
@@ -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,35 +216,19 @@ This session summary was automatically generated by the PAI OpenCode Plugin.
             return filePath;
         }
         catch (error) {
-            this.logError('SessionSummary', error);
             return null;
         }
     }
-    async processAssistantMessage(content) {
-        try {
-            const sections = this.parseStructuredResponse(content);
-            if (Object.keys(sections).length === 0)
-                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);
-        }
-    }
     parseStructuredResponse(content) {
         const sections = {};
-        const sectionHeaders = [
-            'SUMMARY', 'ANALYSIS', 'ACTIONS', 'RESULTS', 'STATUS', 'CAPTURE', 'NEXT', 'STORY EXPLANATION', 'COMPLETED'
-        ];
+        const sectionHeaders = ['SUMMARY', 'ANALYSIS', 'ACTIONS', 'RESULTS', 'STATUS', 'CAPTURE', 'NEXT', 'STORY EXPLANATION', 'COMPLETED'];
         for (const header of sectionHeaders) {
-            const regex = new RegExp(`${header}:\\s*([\\s\\S]*?)(?=\\n(?:${sectionHeaders.join('|')}):|$)`, 'i');
+            // 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]) {
+            if (match && match[1])
                 sections[header] = match[1].trim();
-            }
         }
         return sections;
     }
@@ -240,20 +236,61 @@ This session summary was automatically generated by the PAI OpenCode Plugin.
         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)) {
+        for (const indicator of indicators)
+            if (textToSearch.includes(indicator))
                 count++;
+        return count >= 2;
+    }
+    /**
+     * Normalize agent role from subagent_type patterns to base role.
+     * Handles patterns like:
+     *   - "subagents/researcher-claude" → "researcher"
+     *   - "subagents/sparc-architect" → "architect"
+     *   - "subagents/sparc-dev" → "engineer"
+     *   - "researcher" → "researcher" (passthrough)
+     */
+    normalizeAgentRole(agentRole) {
+        if (!agentRole)
+            return 'pai';
+        // Remove "subagents/" prefix if present (case-insensitive)
+        let role = agentRole.replace(/^subagents\//i, '').toLowerCase();
+        // Role keywords to look for anywhere in the string
+        // Order matters: more specific patterns first
+        const roleKeywords = [
+            // Researcher patterns (prefix or contains)
+            [/researcher/i, 'researcher'],
+            [/research/i, 'researcher'],
+            // Architect patterns
+            [/architect/i, 'architect'],
+            // Engineer patterns (includes "dev" for sparc-dev)
+            [/engineer/i, 'engineer'],
+            [/\bdev\b/i, 'engineer'], // "sparc-dev" → engineer
+            // Designer patterns
+            [/designer/i, 'designer'],
+            // Security patterns
+            [/pentester/i, 'pentester'],
+            // These map to researcher
+            [/analyst/i, 'researcher'],
+            [/explorer/i, 'researcher'],
+            [/^explore$/i, 'researcher'],
+            [/^intern$/i, 'researcher'],
+        ];
+        for (const [pattern, normalized] of roleKeywords) {
+            if (pattern.test(role)) {
+                return normalized;
             }
         }
-        return count >= 2;
+        // Return lowercase role if no pattern matched
+        return role;
     }
     determineArtifactType(agentRole, isLearning, sections) {
         const summary = (sections['SUMMARY'] || '').toLowerCase();
-        if (agentRole === 'architect')
+        const normalizedRole = this.normalizeAgentRole(agentRole);
+        if (normalizedRole === 'architect')
             return 'DECISION';
-        if (agentRole === 'researcher' || agentRole === 'pentester')
+        if (normalizedRole === 'researcher' || normalizedRole === 'pentester')
             return 'RESEARCH';
-        if (agentRole === 'engineer' || agentRole === 'designer') {
+        if (normalizedRole === 'engineer' || normalizedRole === 'designer') {
             if (summary.includes('fix') || summary.includes('bug') || summary.includes('issue'))
                 return 'BUG';
             if (summary.includes('refactor') || summary.includes('improve') || summary.includes('cleanup'))
@@ -263,43 +300,37 @@ This session summary was automatically generated by the PAI OpenCode Plugin.
         return isLearning ? 'LEARNING' : 'WORK';
     }
     async createArtifact(type, content, sections) {
-        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 {
-            // For BUG, REFACTOR, FEATURE
-            if (type === 'BUG')
-                subdir = join('execution', 'bugs');
-            else if (type === 'REFACTOR')
-                subdir = join('execution', 'refactors');
-            else
-                subdir = join('execution', 'features');
-        }
-        const targetDir = join(HISTORY_DIR, subdir, yearMonth);
-        if (!existsSync(targetDir)) {
-            mkdirSync(targetDir, { recursive: true });
-        }
-        const filePath = join(targetDir, filename);
-        const agentRole = this.getAgentForSession(this.sessionId);
-        const frontmatter = `---
+        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}
@@ -309,7 +340,11 @@ ${sections['SUMMARY'] ? `summary: ${sections['SUMMARY'].replace(/"/g, '\\"')}` :
 
 ${content}
 `;
-        writeFileSync(filePath, redactString(frontmatter), 'utf-8');
+            writeFileSync(filePath, redactString(frontmatter), 'utf-8');
+        }
+        catch (e) {
+            this.logError('CreateArtifact', e);
+        }
     }
     logError(context, error) {
         try {
@@ -319,26 +354,22 @@ ${content}
             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,
@@ -347,10 +378,8 @@ ${content}
             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();
@@ -361,7 +390,5 @@ ${content}
             this.logError('EventCapture', error);
         }
     }
-    flush() {
-        // No-op for now as we append synchronously
-    }
+    flush() { }
 }

package/package.json

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