fix(archival): streaming text cache and markdown header parsing

v1.2.0 - Major archival system fixes:

- Add messageTextCache Map to capture streaming text from message.part.updated
- Update regex to handle markdown-formatted headers (**SUMMARY:** etc.)
- Remove console.error calls that corrupted OpenCode TUI
- Add deduplication via processedMessageIds Set
- Route errors to file-based logging instead of stderr

Fixes issue where structured responses weren't being archived due to:
1. Race condition: message.updated fired before streaming content cached
2. Regex mismatch: headers wrapped in markdown bold weren't matched

Author: fpr1m3

dist/index.js

@@ -91,8 +91,12 @@ 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/skill/core/SKILL.md
@@ -131,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;
@@ -158,39 +178,67 @@ export const PAIPlugin = async ({ worktree }) => {
                     process.stderr.write(`\x1b]0;Agent: ${type}...\x07`);
                 }
             }
-            // 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.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) => {

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,7 +26,6 @@ export declare class Logger {
         metadata: any;
     }): void;
     generateSessionSummary(): Promise<string | null>;
-    processAssistantMessage(content: string): Promise<void>;
     private parseStructuredResponse;
     private isLearningCapture;
     private determineArtifactType;