osborn 0.9.9 → 0.9.13

package/dist/claude-llm.d.ts

@@ -21,6 +21,11 @@ export interface ClaudeLLMOptions {
     model?: string;
     voiceMode?: 'direct' | 'realtime';
     skipTTSQueue?: boolean;
+    onCompactionEvent?: (event: {
+        type: 'compaction_started' | 'compaction_complete';
+        trigger?: string;
+        skillsWritten?: number;
+    }) => void;
 }
 /**
  * Claude LLM - Wraps Claude Agent SDK for LiveKit

package/dist/claude-llm.js

@@ -548,7 +548,7 @@ export class ClaudeLLM extends llm.LLM {
      */
     pushMessage(userText, sdkOptions, callbacks) {
         // Lower compaction threshold to 65% so PreCompact fires earlier and context is preserved
-        process.env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE = '60';
+        process.env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE = '75';
         const userMessage = {
             type: 'user',
             message: { role: 'user', content: [{ type: 'text', text: userText }] },
@@ -914,136 +914,19 @@ class ClaudeLLMStream extends llm.LLMStream {
                                     }
                                 }]
                         }],
-                    // ── PreCompact: read full transcript, call Anthropic API directly to extract skills ──
-                    // Fires before the SDK compresses the conversation. Reads the FULL transcript JSONL,
-                    // calls claude-haiku-4-5-20251001 directly for structured extraction, and writes
-                    // skill files to disk immediately — no relying on PostCompact for persistence.
+                    // ── PreCompact: inject extraction instruction only ──
+                    // Fires before the SDK compresses the conversation. Injects the compact-learnings
+                    // instruction so the SDK compaction summary includes the four structured sections.
+                    // Skill extraction happens in PostCompact, which reads input.compact_summary directly.
                     PreCompact: [{
                             matcher: '.*',
                             hooks: [async (input) => {
                                     try {
-                                        const { readFileSync, existsSync, writeFileSync, mkdirSync, readdirSync } = await import('node:fs');
-                                        const { join } = await import('node:path');
-                                        // 1. Read the instruction file
+                                        this.#opts.onCompactionEvent?.({ type: 'compaction_started', trigger: input?.trigger });
                                         const instructionPath = join(__claudeLlmDir, 'prompts', 'compact-learnings-instruction.md');
                                         const instruction = existsSync(instructionPath) ? readFileSync(instructionPath, 'utf-8') : '';
-                                        // 2. Read FULL transcript (no line limit)
-                                        const transcriptPath = input?.transcript_path;
-                                        let transcriptContent = '';
-                                        if (transcriptPath && existsSync(transcriptPath)) {
-                                            try {
-                                                transcriptContent = readFileSync(transcriptPath, 'utf-8');
-                                            }
-                                            catch (readErr) {
-                                                console.warn('⚠️ PreCompact: could not read transcript:', readErr instanceof Error ? readErr.message : readErr);
-                                            }
-                                        }
-                                        const skillDir = this.#opts.sessionBaseDir || this.#opts.workingDirectory || process.cwd();
-                                        const skillsRoot = join(skillDir, '.claude', 'skills');
-                                        // 3. Load existing skills for context (cap each at 500 chars)
-                                        let existingSkillsBlock = '';
-                                        if (existsSync(skillsRoot)) {
-                                            try {
-                                                const names = readdirSync(skillsRoot).slice(0, 15);
-                                                const fragments = [];
-                                                for (const name of names) {
-                                                    const p = join(skillsRoot, name, 'SKILL.md');
-                                                    if (existsSync(p)) {
-                                                        const body = readFileSync(p, 'utf-8');
-                                                        const cleaned = body.replace(/^===.*===\s*$/gm, '').substring(0, 500);
-                                                        fragments.push(`### ${name}\n${cleaned}`);
-                                                    }
-                                                }
-                                                if (fragments.length) {
-                                                    existingSkillsBlock = `EXISTING SKILLS (do NOT re-emit unchanged):\n${fragments.join('\n\n')}`;
-                                                }
-                                            }
-                                            catch (skillErr) {
-                                                console.warn('⚠️ PreCompact: skills load failed:', skillErr instanceof Error ? skillErr.message : skillErr);
-                                            }
-                                        }
-                                        // 4. If transcript available, use direct Anthropic API call to extract everything
-                                        if (transcriptContent && process.env.ANTHROPIC_API_KEY) {
-                                            try {
-                                                const Anthropic = (await import('@anthropic-ai/sdk')).default;
-                                                const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
-                                                const extractionPrompt = [
-                                                    instruction,
-                                                    existingSkillsBlock,
-                                                    `FULL SESSION TRANSCRIPT (JSONL format — extract the four sections from this):`,
-                                                    transcriptContent,
-                                                ].filter(Boolean).join('\n\n---\n\n');
-                                                console.log(`🧠 PreCompact: calling extraction API (${extractionPrompt.length} chars, trigger=${input?.trigger || 'unknown'})`);
-                                                const response = await client.messages.create({
-                                                    model: 'claude-haiku-4-5-20251001',
-                                                    max_tokens: 4096,
-                                                    messages: [{ role: 'user', content: extractionPrompt }],
-                                                });
-                                                const extractedText = response.content[0]?.type === 'text' ? response.content[0].text : '';
-                                                if (extractedText) {
-                                                    // Write SKILL_CANDIDATES to disk directly
-                                                    const skillRegex = /--- SKILL: ([a-z][a-z0-9-]{1,39}) ---\n([\s\S]*?)\n--- END SKILL ---/g;
-                                                    let match;
-                                                    while ((match = skillRegex.exec(extractedText)) !== null) {
-                                                        const [, name, body] = match;
-                                                        if (/^[a-z][a-z0-9-]{1,39}$/.test(name)) {
-                                                            const today = new Date().toISOString().split('T')[0];
-                                                            const sessionId = this.#sessionId || 'unknown';
-                                                            const skillFolder = join(skillsRoot, name);
-                                                            mkdirSync(skillFolder, { recursive: true });
-                                                            writeFileSync(join(skillFolder, 'SKILL.md'), `# ${name}\nAuto-extracted: ${today} | Session: ${sessionId.substring(0, 8)}\n\n${body}`);
-                                                            console.log(`🧠 PreCompact: wrote skill '${name}' to ${skillFolder}`);
-                                                        }
-                                                    }
-                                                    // Write BEHAVIORAL_LEARNINGS to learned-behaviors skill
-                                                    const blMarker = '=== BEHAVIORAL_LEARNINGS ===';
-                                                    const blIdx = extractedText.indexOf(blMarker);
-                                                    if (blIdx !== -1) {
-                                                        const blContent = extractedText.substring(blIdx);
-                                                        if (blContent.length > 30) {
-                                                            const today = new Date().toISOString().split('T')[0];
-                                                            const sessionId = this.#sessionId || 'unknown';
-                                                            const learnedDir = join(skillsRoot, 'learned-behaviors');
-                                                            mkdirSync(learnedDir, { recursive: true });
-                                                            const header = `# Learned Behaviors\n\nAuto-extracted from voice sessions via PreCompact.\nLast updated: ${today} | Session: ${sessionId.substring(0, 8)}...\n\n`;
-                                                            writeFileSync(join(learnedDir, 'SKILL.md'), header + blContent);
-                                                            console.log(`🧠 PreCompact: wrote learned-behaviors (${blContent.length} chars)`);
-                                                        }
-                                                    }
-                                                    // Write project-scoped DECISIONS
-                                                    const decMarker = '=== DECISIONS ===';
-                                                    const decIdx = extractedText.indexOf(decMarker);
-                                                    if (decIdx !== -1) {
-                                                        const decEnd = extractedText.indexOf('===', decIdx + decMarker.length);
-                                                        const decContent = extractedText.substring(decIdx + decMarker.length, decEnd !== -1 ? decEnd : undefined);
-                                                        const projectDecisions = decContent.split('\n').filter((l) => l.includes('SCOPE: project')).join('\n');
-                                                        if (projectDecisions.trim()) {
-                                                            const decDir = join(skillsRoot, 'project-decisions');
-                                                            mkdirSync(decDir, { recursive: true });
-                                                            const decFile = join(decDir, 'SKILL.md');
-                                                            const existing = existsSync(decFile) ? readFileSync(decFile, 'utf-8') : '# Project Decisions\n\n';
-                                                            writeFileSync(decFile, existing + '\n' + projectDecisions);
-                                                            console.log(`🧠 PreCompact: appended project decisions`);
-                                                        }
-                                                    }
-                                                    // Return extracted content as systemMessage for compact summary
-                                                    const systemMessage = [
-                                                        '## Pre-Compaction Extraction Complete',
-                                                        'Skill files have been written to disk. Include the following in your compact summary verbatim:',
-                                                        extractedText.substring(0, 8000),
-                                                    ].join('\n\n').substring(0, 9500);
-                                                    console.log(`🧠 PreCompact: extraction complete, returning systemMessage (${systemMessage.length} chars)`);
-                                                    return { systemMessage };
-                                                }
-                                            }
-                                            catch (apiErr) {
-                                                console.error('⚠️ PreCompact: API extraction failed, falling back to basic mode:', apiErr instanceof Error ? apiErr.message : apiErr);
-                                                // Fall through to basic fallback
-                                            }
-                                        }
-                                        // 5. Fallback: basic mode — just inject the instruction
-                                        console.log(`🧠 PreCompact: basic mode (no transcript or API key unavailable)`);
-                                        return { systemMessage: instruction.substring(0, 9500) };
+                                        console.log(`🧠 PreCompact: injecting instruction (${instruction.length} chars, trigger=${input?.trigger || 'unknown'})`);
+                                        return { systemMessage: instruction };
                                     }
                                     catch (err) {
                                         console.error('⚠️ PreCompact hook error:', err instanceof Error ? err.message : err);
@@ -1051,16 +934,19 @@ class ClaudeLLMStream extends llm.LLMStream {
                                     }
                                 }]
                         }],
-                    // ── PostCompact: extract all four sections from summary and persist to disk ──
+                    // ── PostCompact: parse compact_summary from stdin payload and persist skill sections ──
+                    // input.compact_summary is the full summary text the SDK just wrote.
+                    // We read the four sections directly from it — no JSONL file access needed.
                     PostCompact: [{
                             matcher: '.*',
                             hooks: [async (input) => {
                                     try {
                                         const summary = input?.compact_summary || '';
-                                        const { mkdirSync, writeFileSync: writeSyncFs } = await import('fs');
+                                        const { mkdirSync, writeFileSync: writeSyncFs, readFileSync: readSyncFs, existsSync: existsSyncFs } = await import('node:fs');
                                         const skillDir = this.#opts.sessionBaseDir || this.#opts.workingDirectory || process.cwd();
                                         const today = new Date().toISOString().split('T')[0];
                                         const sessionId = this.#sessionId || 'unknown';
+                                        let skillsWritten = 0;
                                         // Helper: extract text between a marker and the next === marker (or end of string)
                                         const extractSection = (marker) => {
                                             const idx = summary.indexOf(marker);
@@ -1070,7 +956,7 @@ class ClaudeLLMStream extends llm.LLMStream {
                                             const nextMarker = summary.indexOf('=== ', start);
                                             return (nextMarker === -1 ? summary.substring(start) : summary.substring(start, nextMarker)).trim();
                                         };
-                                        // ── Section 1: HANDOFF_STATE — log only, not written to disk ──
+                                        // ── Section 1: HANDOFF_STATE — stays in compact summary only, not written to disk ──
                                         const handoff = extractSection('=== HANDOFF_STATE ===');
                                         if (handoff) {
                                             console.log(`🧠 PostCompact: HANDOFF_STATE present (${handoff.length} chars) — not written to disk`);
@@ -1083,26 +969,22 @@ class ClaudeLLMStream extends llm.LLMStream {
                                                     .split('\n')
                                                     .filter(l => /DECISION:.*SCOPE:\s*project/i.test(l));
                                                 if (projectLines.length) {
-                                                    const decFolder = join(skillDir, '.claude', 'skills', 'project-decisions');
+                                                    const decFolder = join(skillDir, '.claude', 'skills', 'decisions');
                                                     const decPath = join(decFolder, 'SKILL.md');
                                                     mkdirSync(decFolder, { recursive: true });
-                                                    const existing = (() => { try {
-                                                        return require('fs').readFileSync(decPath, 'utf-8');
-                                                    }
-                                                    catch {
-                                                        return '';
-                                                    } })();
+                                                    const existing = existsSyncFs(decPath) ? readSyncFs(decPath, 'utf-8') : '';
                                                     const header = existing ? '' : `# Project Decisions\n\nAuto-extracted from compact summaries.\n\n`;
                                                     const entry = `\n## ${today} (session ${sessionId.substring(0, 8)})\n${projectLines.join('\n')}\n`;
                                                     writeSyncFs(decPath, header + existing + entry, 'utf-8');
                                                     console.log(`🧠 PostCompact: appended ${projectLines.length} decision(s) to ${decPath}`);
+                                                    skillsWritten++;
                                                 }
                                             }
                                         }
                                         catch (decErr) {
                                             console.error('⚠️ PostCompact: DECISIONS write failed:', decErr instanceof Error ? decErr.message : decErr);
                                         }
-                                        // ── Section 3: SKILL_CANDIDATES — parse and write each skill ──
+                                        // ── Section 3: SKILL_CANDIDATES — parse individual blocks and write each ──
                                         try {
                                             const skillsSection = extractSection('=== SKILL_CANDIDATES ===');
                                             if (skillsSection) {
@@ -1122,37 +1004,34 @@ class ClaudeLLMStream extends llm.LLMStream {
                                                     const header = `# ${name}\nAuto-extracted: ${today} | Session: ${sessionId.substring(0, 8)}\n\n`;
                                                     writeSyncFs(skillPath, header + body + '\n', 'utf-8');
                                                     console.log(`🧠 PostCompact: wrote skill '${name}' to ${skillPath}`);
+                                                    skillsWritten++;
                                                 }
                                             }
                                         }
                                         catch (skillErr) {
                                             console.error('⚠️ PostCompact: SKILL_CANDIDATES write failed:', skillErr instanceof Error ? skillErr.message : skillErr);
                                         }
-                                        // ── Section 4: BEHAVIORAL_LEARNINGS — write to learned-behaviors skill file ──
+                                        // ── Section 4: BEHAVIORAL_LEARNINGS — write to learned-behaviors/SKILL.md ──
                                         try {
-                                            const marker = '=== BEHAVIORAL_LEARNINGS ===';
-                                            const idx = summary.indexOf(marker);
-                                            if (idx !== -1) {
-                                                const learnings = summary.substring(idx + marker.length).trim();
-                                                if (learnings.length >= 30) {
-                                                    const skillFolder = join(skillDir, '.claude', 'skills', 'learned-behaviors');
-                                                    const skillPath = join(skillFolder, 'SKILL.md');
-                                                    mkdirSync(skillFolder, { recursive: true });
-                                                    const header = `# Learned Behaviors\n\nAuto-extracted from voice sessions via PostCompact.\nLast updated: ${today} | Session: ${sessionId.substring(0, 8)}...\n\n`;
-                                                    writeSyncFs(skillPath, header + learnings + '\n', 'utf-8');
-                                                    console.log(`🧠 PostCompact: wrote learned behaviors to ${skillPath} (${learnings.length} chars)`);
-                                                }
-                                                else {
-                                                    console.log('🧠 PostCompact: BEHAVIORAL_LEARNINGS section too short — skipping');
-                                                }
+                                            const learnings = extractSection('=== BEHAVIORAL_LEARNINGS ===');
+                                            if (learnings.length >= 30) {
+                                                const skillFolder = join(skillDir, '.claude', 'skills', 'learned-behaviors');
+                                                const skillPath = join(skillFolder, 'SKILL.md');
+                                                mkdirSync(skillFolder, { recursive: true });
+                                                const header = `# Learned Behaviors\n\nAuto-extracted from voice sessions via PostCompact.\nLast updated: ${today} | Session: ${sessionId.substring(0, 8)}...\n\n`;
+                                                writeSyncFs(skillPath, header + learnings + '\n', 'utf-8');
+                                                console.log(`🧠 PostCompact: wrote learned behaviors to ${skillPath} (${learnings.length} chars)`);
+                                                skillsWritten++;
                                             }
                                             else {
-                                                console.log('🧠 PostCompact: no BEHAVIORAL_LEARNINGS section found in summary — skipping');
+                                                console.log('🧠 PostCompact: no BEHAVIORAL_LEARNINGS section found or too short — skipping');
                                             }
                                         }
                                         catch (blErr) {
                                             console.error('⚠️ PostCompact: BEHAVIORAL_LEARNINGS write failed:', blErr instanceof Error ? blErr.message : blErr);
                                         }
+                                        this.#opts.onCompactionEvent?.({ type: 'compaction_complete', skillsWritten });
+                                        console.log(`🧠 PostCompact: complete — ${skillsWritten} skill file(s) written`);
                                     }
                                     catch (err) {
                                         console.error('⚠️ PostCompact hook error:', err instanceof Error ? err.message : err);

package/dist/index.js

@@ -1288,6 +1288,12 @@ async function main() {
             resumeSessionId,
             voiceMode: 'direct',
             skipTTSQueue: true,
+            onCompactionEvent: (event) => {
+                try {
+                    sendToFrontend({ type: event.type, trigger: event.trigger, skillsWritten: event.skillsWritten });
+                }
+                catch { /* non-fatal */ }
+            },
         });
         currentLLM = directLLM;
         // Reset the session always-allow list for each new direct session
@@ -1615,6 +1621,12 @@ async function main() {
             sessionBaseDir,
             mcpServers,
             resumeSessionId,
+            onCompactionEvent: (event) => {
+                try {
+                    sendToFrontend({ type: event.type, trigger: event.trigger, skillsWritten: event.skillsWritten });
+                }
+                catch { /* non-fatal */ }
+            },
         });
         currentLLM = realtimeClaudeHandler;
         // For resumed sessions, eagerly create workspace (we know the real ID)

package/dist/prompts/compact-learnings-instruction.md

@@ -13,6 +13,8 @@ Include:
 - **Test results**: What was tried, what it showed, what it ruled out
 
 Keep this under 800 characters. This stays in the compact summary — it is NOT written to disk.
+- **ANNOUNCE**: End HANDOFF_STATE with one line formatted as:
+  `ANNOUNCE: <natural-language sentence for Osborn to speak aloud when resuming — mention that session memory was crystallized and how many skills/decisions were updated. Keep it to one sentence, conversational tone, like a colleague mentioning it in passing.>`
 
 ---
 

package/dist/prompts/direct-mode-research.md

@@ -10,6 +10,8 @@ Session workspace: ${workspacePath}
   · You CAN write other files to the workspace (detailed findings, diffs, notes, code samples) that the user sees in a files panel
 
 Working principle: SPEAK the thinking, WRITE the details.
+
+COMPACT RESUME BEHAVIOR: When this conversation has been compacted, the compact summary may contain a line beginning with "ANNOUNCE:". If it does, speak that line aloud as your first response before picking up any pending task. This is NOT recapping the summary — it is delivering a brief memory-crystallization update that the user is expecting. After speaking it, continue normally.
 </context>
 
 <objective>

package/dist/prompts.js

@@ -554,6 +554,8 @@ Quick lookups (1-2 calls) you can do directly. Everything else goes to an agent.
 You do NOT produce findings from training data alone. You use tools to confirm every specific fact — file names, version numbers, function signatures, configuration values, URLs. If a tool is not available to verify a claim, you say so.
 
 IF INTERRUPTED OR RESTARTED: Check ~/.claude/projects/ subagents folder for recent sub-agent JSONL files. Read the last entries to understand what was completed. Resume from that point.
+
+Exception: if the compact summary contains a line beginning with "ANNOUNCE:", speak that line to the user as your first response before picking up the task. This is NOT recapping the summary — it is delivering a brief memory-crystallization update that the user is expecting.
 </role>
 
 <write-rules>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osborn",
-  "version": "0.9.9",
+  "version": "0.9.13",
   "description": "Voice AI coding assistant - local agent that connects to Osborn frontend",
   "type": "module",
   "bin": {