osborn 0.9.16 → 0.9.18

package/Dockerfile.sandbox

@@ -53,6 +53,23 @@ if [ -f /workspace/.claude/.oauth-token ]; then
   echo "[sandbox] Restored CLAUDE_CODE_OAUTH_TOKEN from volume"
 fi
 
+# Seed default skills into ~/.claude/skills/ — single source of truth.
+# The agent only loads skills from this path; defaults shipped in the npm
+# package get copied here on first boot. Idempotent: existing skills
+# (learned via PostCompact or manually edited) are preserved across restarts.
+HOME_SKILLS_DIR=/root/.claude/skills
+PKG_SKILLS_DIR=/usr/local/lib/node_modules/osborn/.claude/skills
+mkdir -p "$HOME_SKILLS_DIR"
+if [ -d "$PKG_SKILLS_DIR" ]; then
+  for d in "$PKG_SKILLS_DIR"/*/; do
+    [ -d "$d" ] || continue
+    NAME=$(basename "$d")
+    [ -d "$HOME_SKILLS_DIR/$NAME" ] && continue
+    cp -r "$d" "$HOME_SKILLS_DIR/$NAME"
+    echo "[sandbox] seeded default skill: $NAME"
+  done
+fi
+
 exec osborn
 ENTRYPOINT
 

package/dist/claude-llm.d.ts

@@ -22,9 +22,17 @@ export interface ClaudeLLMOptions {
     voiceMode?: 'direct' | 'realtime';
     skipTTSQueue?: boolean;
     onCompactionEvent?: (event: {
-        type: 'compaction_started' | 'compaction_complete';
+        type: 'compaction_started';
         trigger?: string;
+    } | {
+        type: 'compaction_progress';
+        stage: string;
+        detail?: string;
+    } | {
+        type: 'compaction_complete';
         skillsWritten?: number;
+        skillNames?: string[];
+        trigger?: string;
     }) => void;
 }
 /**

package/dist/claude-llm.js

@@ -91,37 +91,33 @@ function loadSkillsFromDir(agentDir) {
  * Merges results, deduplicating by skill directory name — home dir wins on conflicts.
  * Returns a combined <available-skills> XML block, or '' if no skills found.
  */
-function loadAllSkills(workingDir) {
+function loadAllSkills(_workingDir) {
+    // Single source of truth: ~/.claude/skills/
+    // Defaults are seeded into this dir by the provisioning bootstrap (sprites.ts
+    // buildOsbornBootstrap + Dockerfile.sandbox entrypoint). PostCompact writes
+    // newly-learned skills here too. By unifying on one path we avoid the older
+    // confusion where defaults loaded from node_modules/osborn/.claude/skills/
+    // while PostCompact wrote to home — meaning learnings were second-class.
     const homeSkillsDir = join(homedir(), '.claude', 'skills');
-    const projectSkillsDir = join(workingDir, '.claude', 'skills');
-    // skill name → content; home dir loaded first so it wins on conflicts
+    if (!existsSync(homeSkillsDir)) {
+        console.log(`📚 No skills dir at ${homeSkillsDir} — bootstrap may not have run yet`);
+        return '';
+    }
     const skillMap = new Map();
-    const loadFromDir = (dir) => {
-        if (!existsSync(dir))
-            return;
-        try {
-            for (const skillName of readdirSync(dir)) {
-                if (skillMap.has(skillName))
-                    continue; // home dir already set this one
-                const skillFile = join(dir, skillName, 'SKILL.md');
-                if (existsSync(skillFile)) {
-                    skillMap.set(skillName, readFileSync(skillFile, 'utf-8').trim());
-                }
+    try {
+        for (const skillName of readdirSync(homeSkillsDir)) {
+            const skillFile = join(homeSkillsDir, skillName, 'SKILL.md');
+            if (existsSync(skillFile)) {
+                skillMap.set(skillName, readFileSync(skillFile, 'utf-8').trim());
             }
         }
-        catch (err) {
-            console.warn('⚠️ Failed to load skills from', dir, ':', err);
-        }
-    };
-    loadFromDir(homeSkillsDir);
-    loadFromDir(projectSkillsDir);
+    }
+    catch (err) {
+        console.warn('⚠️ Failed to load skills from', homeSkillsDir, ':', err);
+    }
     if (skillMap.size === 0)
         return '';
-    const sources = [
-        existsSync(homeSkillsDir) ? homeSkillsDir : null,
-        existsSync(projectSkillsDir) ? projectSkillsDir : null,
-    ].filter(Boolean).join(', ');
-    console.log(`📚 Loaded ${skillMap.size} skill(s) from ${sources}`);
+    console.log(`📚 Loaded ${skillMap.size} skill(s) from ${homeSkillsDir}`);
     return `<available-skills>\n${[...skillMap.values()].join('\n\n---\n\n')}\n</available-skills>`;
 }
 // Research mode tools — full research capabilities
@@ -593,8 +589,11 @@ export class ClaudeLLM extends llm.LLM {
      * @param callbacks - Event callbacks for the background consumer
      */
     pushMessage(userText, sdkOptions, callbacks) {
-        // Lower compaction threshold to 65% so PreCompact fires earlier and context is preserved
-        process.env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE = '75';
+        // Auto-compact threshold — fires PreCompact when context fills to this %.
+        // Higher = uses more of the window before compacting (more context retained
+        // per turn, but less headroom for the next reply). 85% is the sweet spot
+        // before Claude starts hard-capping replies near the limit.
+        process.env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE = '85';
         const userMessage = {
             type: 'user',
             message: { role: 'user', content: [{ type: 'text', text: userText }] },
@@ -994,6 +993,16 @@ class ClaudeLLMStream extends llm.LLMStream {
                                         const today = new Date().toISOString().split('T')[0];
                                         const sessionId = this.#sessionId || 'unknown';
                                         let skillsWritten = 0;
+                                        const skillNames = [];
+                                        // Emit fine-grained progress events so the UI can render a multi-step
+                                        // "crystallizing..." panel instead of a single 3-second flash. Each
+                                        // stage gets a human-readable label + optional detail (skill name,
+                                        // char counts) so the user sees something happening through the whole
+                                        // ~3 minute compaction window.
+                                        const progress = (stage, detail) => {
+                                            this.#opts.onCompactionEvent?.({ type: 'compaction_progress', stage, detail });
+                                        };
+                                        progress('Reading compact summary', `${summary.length} chars`);
                                         // Helper: extract text between a marker and the next === marker (or end of string)
                                         const extractSection = (marker) => {
                                             const idx = summary.indexOf(marker);
@@ -1007,6 +1016,7 @@ class ClaudeLLMStream extends llm.LLMStream {
                                         const handoff = extractSection('=== HANDOFF_STATE ===');
                                         if (handoff) {
                                             console.log(`🧠 PostCompact: HANDOFF_STATE present (${handoff.length} chars) — not written to disk`);
+                                            progress('Parsed handoff state', `${handoff.length} chars`);
                                         }
                                         // ── Section 2: DECISIONS — append project-scoped decisions ──
                                         try {
@@ -1016,6 +1026,7 @@ class ClaudeLLMStream extends llm.LLMStream {
                                                     .split('\n')
                                                     .filter(l => /DECISION:.*SCOPE:\s*project/i.test(l));
                                                 if (projectLines.length) {
+                                                    progress('Extracting decisions', `${projectLines.length} project-scoped`);
                                                     const decFolder = join(skillDir, '.claude', 'skills', 'decisions');
                                                     const decPath = join(decFolder, 'SKILL.md');
                                                     mkdirSync(decFolder, { recursive: true });
@@ -1025,6 +1036,8 @@ class ClaudeLLMStream extends llm.LLMStream {
                                                     writeSyncFs(decPath, header + existing + entry, 'utf-8');
                                                     console.log(`🧠 PostCompact: appended ${projectLines.length} decision(s) to ${decPath}`);
                                                     skillsWritten++;
+                                                    skillNames.push('decisions');
+                                                    progress('Wrote skill', 'decisions');
                                                 }
                                             }
                                         }
@@ -1052,6 +1065,8 @@ class ClaudeLLMStream extends llm.LLMStream {
                                                     writeSyncFs(skillPath, header + body + '\n', 'utf-8');
                                                     console.log(`🧠 PostCompact: wrote skill '${name}' to ${skillPath}`);
                                                     skillsWritten++;
+                                                    skillNames.push(name);
+                                                    progress('Wrote skill', name);
                                                 }
                                             }
                                         }
@@ -1062,6 +1077,7 @@ class ClaudeLLMStream extends llm.LLMStream {
                                         try {
                                             const learnings = extractSection('=== BEHAVIORAL_LEARNINGS ===');
                                             if (learnings.length >= 30) {
+                                                progress('Extracting learnings', `${learnings.length} chars`);
                                                 const skillFolder = join(skillDir, '.claude', 'skills', 'learned-behaviors');
                                                 const skillPath = join(skillFolder, 'SKILL.md');
                                                 mkdirSync(skillFolder, { recursive: true });
@@ -1069,6 +1085,8 @@ class ClaudeLLMStream extends llm.LLMStream {
                                                 writeSyncFs(skillPath, header + learnings + '\n', 'utf-8');
                                                 console.log(`🧠 PostCompact: wrote learned behaviors to ${skillPath} (${learnings.length} chars)`);
                                                 skillsWritten++;
+                                                skillNames.push('learned-behaviors');
+                                                progress('Wrote skill', 'learned-behaviors');
                                             }
                                             else {
                                                 console.log('🧠 PostCompact: no BEHAVIORAL_LEARNINGS section found or too short — skipping');
@@ -1077,8 +1095,8 @@ class ClaudeLLMStream extends llm.LLMStream {
                                         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`);
+                                        this.#opts.onCompactionEvent?.({ type: 'compaction_complete', skillsWritten, skillNames });
+                                        console.log(`🧠 PostCompact: complete — ${skillsWritten} skill file(s) written: [${skillNames.join(', ')}]`);
                                     }
                                     catch (err) {
                                         console.error('⚠️ PostCompact hook error:', err instanceof Error ? err.message : err);

package/dist/index.js

@@ -10,7 +10,7 @@ initializeLogger({ pretty: true, level: 'info' });
 import { setMaxListeners } from 'node:events';
 setMaxListeners(50);
 import { createServer } from 'http';
-import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, mkdtempSync, cpSync, rmSync, renameSync, statSync, createWriteStream } from 'node:fs';
+import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, mkdtempSync, cpSync, rmSync, statSync, createWriteStream } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn } from 'node:child_process';
@@ -334,28 +334,158 @@ function startApiServer(workingDir, port) {
             return;
         }
         // GET /sessions/manifest — return mtime+size for all .jsonl files per slug (public, no auth)
+        // Helper: merge an extracted tar directory into ~/.claude/projects/ with all 4 fixes:
+        //   1. Skip macOS AppleDouble entries (`._*`) that bsdtar emits
+        //   2. Apply slug remap when targetWorkDir is supplied (chunked path missed this)
+        //   3. Rewrite embedded `cwd` field inside .jsonl entries during remap so
+        //      Claude Code can resume the conversation in the destination workspace
+        //   4. Merge into existing dest dirs instead of failing on rename collision
+        const mergeExtractedIntoProjects = async (sourceDir, targetWorkDir) => {
+            const claudeDir = join(homedir(), '.claude');
+            const projectsDir = join(claudeDir, 'projects');
+            mkdirSync(projectsDir, { recursive: true });
+            // The archive sometimes wraps content in a 'projects' subdir, sometimes not.
+            const extractedProjects = join(sourceDir, 'projects');
+            const effectiveSource = existsSync(extractedProjects) ? extractedProjects : sourceDir;
+            // Filter out AppleDouble (`._*`) entries that macOS bsdtar emits for
+            // resource forks. These crash later steps if they collide with real dirs.
+            const sourceSlugs = readdirSync(effectiveSource)
+                .filter(s => !s.startsWith('._') && !s.startsWith('.DS_Store'));
+            // Build remap table: source-slug → target-slug.
+            // Only remaps slugs that differ from the target (no-op if already correct).
+            const remapped = {};
+            const targetSlug = targetWorkDir ? targetWorkDir.replace(/\//g, '-') : '';
+            if (targetSlug) {
+                for (const slug of sourceSlugs) {
+                    if (slug !== targetSlug)
+                        remapped[slug] = targetSlug;
+                }
+            }
+            // Slug → original cwd path (reverse of slug encoding):
+            //   '-Users-newupgrade-Desktop-Developer-osborn' → '/Users/newupgrade/Desktop/Developer/osborn'
+            // Claude Code's slug rule: replace all '/' with '-', so reverse is replace '-' with '/'.
+            // Leading '-' becomes '/'. We don't try to recover '.' (Claude uses '--' for it, but
+            // dot-prefixed dirs are uncommon and a best-effort rewrite is enough for resume).
+            const slugToCwd = (slug) => '/' + slug.replace(/^-/, '').replace(/-/g, '/');
+            let filesWritten = 0;
+            for (const sourceSlug of sourceSlugs) {
+                const effectiveSlug = remapped[sourceSlug] ?? sourceSlug;
+                const destSlug = join(projectsDir, effectiveSlug);
+                mkdirSync(destSlug, { recursive: true });
+                const sourceSlugPath = join(effectiveSource, sourceSlug);
+                const sourceCwd = slugToCwd(sourceSlug);
+                const destCwd = targetWorkDir ?? slugToCwd(effectiveSlug);
+                const needsCwdRewrite = sourceCwd !== destCwd;
+                // Walk the source slug directory and copy files individually so we can:
+                //   (a) skip AppleDouble per-file too (in case nested)
+                //   (b) rewrite cwd inside .jsonl files when remapping across workspaces
+                //   (c) merge into existing destination directories without renameSync collision
+                //   (d) keep newer-by-mtime when both sides have the same file (the user's
+                //       requested "overwrite based on timestamp" rule for bidirectional sync)
+                const walkAndCopy = (src, dst) => {
+                    const entries = readdirSync(src, { withFileTypes: true });
+                    for (const e of entries) {
+                        if (e.name.startsWith('._') || e.name === '.DS_Store')
+                            continue;
+                        const sp = join(src, e.name);
+                        const dp = join(dst, e.name);
+                        if (e.isDirectory()) {
+                            mkdirSync(dp, { recursive: true });
+                            walkAndCopy(sp, dp);
+                        }
+                        else if (e.isFile()) {
+                            // mtime conflict resolution — when destination already has this file,
+                            // only overwrite when the source is strictly newer. Preserves work
+                            // done on the destination side when re-syncing in either direction.
+                            let shouldWrite = true;
+                            try {
+                                const dstStat = statSync(dp);
+                                const srcStat = statSync(sp);
+                                if (dstStat.mtimeMs >= srcStat.mtimeMs)
+                                    shouldWrite = false;
+                            }
+                            catch { /* dst doesn't exist — write it */ }
+                            if (!shouldWrite)
+                                continue;
+                            if (needsCwdRewrite && e.name.endsWith('.jsonl')) {
+                                // Read, rewrite "cwd" field, write. JSONL is line-delimited;
+                                // string match on `"cwd":"<sourceCwd>"` is precise enough.
+                                const content = readFileSync(sp, 'utf8');
+                                const find = `"cwd":"${sourceCwd}"`;
+                                const replace = `"cwd":"${destCwd}"`;
+                                const rewritten = content.split(find).join(replace);
+                                writeFileSync(dp, rewritten);
+                            }
+                            else {
+                                cpSync(sp, dp, { force: true });
+                            }
+                            filesWritten++;
+                        }
+                        // skip symlinks, sockets, etc.
+                    }
+                };
+                walkAndCopy(sourceSlugPath, destSlug);
+                // Best-effort: ensure the resolved workspace directory exists so Claude
+                // can resume conversations whose JSONLs reference it.
+                const recoveredPath = effectiveSlug.replace(/^-/, '/').replace(/--/g, '/.').replace(/-/g, '/');
+                if (recoveredPath && recoveredPath !== '/') {
+                    try {
+                        mkdirSync(recoveredPath, { recursive: true });
+                    }
+                    catch { /* ignore */ }
+                }
+            }
+            return { filesWritten, remapped };
+        };
         if (req.method === 'GET' && url.pathname === '/sessions/manifest') {
+            // Walks the FULL tree per slug — including sub-agent transcripts
+            // (<slug>/<sessionId>/subagents/*.jsonl), tool-results (<slug>/<sessionId>/tool-results/*),
+            // osb workspace files (<slug>/osb/<sessionId>/*), and file-history. Files are
+            // keyed by their path RELATIVE to the slug dir so the client can preserve
+            // structure when computing diffs. mtime is in ms epoch so a simple `>`
+            // comparison is the "newer wins" merge rule.
+            //
+            // Previous version only listed top-level *.jsonl and missed ~270/290 files
+            // on a typical session — sub-agent transcripts invisible → resume failed
+            // silently because Claude couldn't find the referenced agent_id transcripts.
             const claudeDir = join(homedir(), '.claude', 'projects');
             const slugMap = {};
-            try {
-                const slugs = readdirSync(claudeDir, { withFileTypes: true })
-                    .filter(d => d.isDirectory())
-                    .map(d => d.name);
-                for (const slug of slugs) {
-                    const slugDir = join(claudeDir, slug);
+            const walkSlug = (slugDir) => {
+                const files = {};
+                const walk = (dir, relPrefix) => {
+                    let entries;
                     try {
-                        const jsonlFiles = readdirSync(slugDir)
-                            .filter(f => f.endsWith('.jsonl'));
-                        const fileStats = {};
-                        for (const file of jsonlFiles) {
-                            const st = statSync(join(slugDir, file));
-                            fileStats[file] = { mtime: st.mtimeMs, size: st.size };
-                        }
-                        slugMap[slug] = { files: fileStats };
+                        entries = readdirSync(dir, { withFileTypes: true });
                     }
                     catch {
-                        // skip unreadable dirs
+                        return;
+                    }
+                    for (const e of entries) {
+                        if (e.name.startsWith('._') || e.name === '.DS_Store')
+                            continue;
+                        const sub = join(dir, e.name);
+                        const rel = relPrefix ? `${relPrefix}/${e.name}` : e.name;
+                        if (e.isDirectory()) {
+                            walk(sub, rel);
+                        }
+                        else if (e.isFile()) {
+                            try {
+                                const st = statSync(sub);
+                                files[rel] = { mtime: st.mtimeMs, size: st.size };
+                            }
+                            catch { /* skip unreadable */ }
+                        }
                     }
+                };
+                walk(slugDir, '');
+                return files;
+            };
+            try {
+                const slugs = readdirSync(claudeDir, { withFileTypes: true })
+                    .filter(d => d.isDirectory() && !d.name.startsWith('._'))
+                    .map(d => d.name);
+                for (const slug of slugs) {
+                    slugMap[slug] = { files: walkSlug(join(claudeDir, slug)) };
                 }
             }
             catch {
@@ -419,49 +549,7 @@ function startApiServer(workingDir, port) {
                         res.end(JSON.stringify({ error: 'tar extraction failed', code }));
                         return;
                     }
-                    const claudeDir = join(homedir(), '.claude');
-                    const projectsDir = join(claudeDir, 'projects');
-                    mkdirSync(projectsDir, { recursive: true });
-                    // The archive should contain a 'projects' subdirectory
-                    const extractedProjects = join(tmpDir, 'projects');
-                    const sourceDir = existsSync(extractedProjects) ? extractedProjects : tmpDir;
-                    // Optionally remap slug: if targetWorkDir is provided, find slug(s)
-                    // that don't match the target and rename them
-                    const remapped = {};
-                    if (targetWorkDir) {
-                        const targetSlug = targetWorkDir.replace(/\//g, '-');
-                        const sourceSlugs = readdirSync(sourceDir);
-                        for (const slug of sourceSlugs) {
-                            if (slug !== targetSlug && !slug.startsWith('.')) {
-                                remapped[slug] = targetSlug;
-                            }
-                        }
-                    }
-                    // Copy subdirectories into ~/.claude/projects/, merging and updating existing files
-                    let filesWritten = 0;
-                    const slugsInSource = readdirSync(sourceDir);
-                    for (const slug of slugsInSource) {
-                        const effectiveSlug = remapped[slug] ?? slug;
-                        const destSlug = join(projectsDir, effectiveSlug);
-                        mkdirSync(destSlug, { recursive: true });
-                        try {
-                            renameSync(join(sourceDir, slug), destSlug);
-                        }
-                        catch (e) {
-                            if (e.code === 'EXDEV') {
-                                // Cross-filesystem fallback
-                                cpSync(join(sourceDir, slug), destSlug, { recursive: true, force: true, errorOnExist: false });
-                            }
-                            else {
-                                throw e;
-                            }
-                        }
-                        filesWritten++;
-                        const recoveredPath = effectiveSlug.replace(/^-/, '/').replace(/--/g, '/.').replace(/-/g, '/');
-                        if (recoveredPath && recoveredPath !== '/') {
-                            mkdirSync(recoveredPath, { recursive: true });
-                        }
-                    }
+                    const { filesWritten, remapped } = await mergeExtractedIntoProjects(tmpDir, targetWorkDir ?? undefined);
                     res.writeHead(200, { 'Content-Type': 'application/json' });
                     res.end(JSON.stringify({ ok: true, filesWritten, remapped }));
                 }
@@ -577,39 +665,9 @@ function startApiServer(workingDir, port) {
                             res.end(JSON.stringify({ error: 'tar extraction failed', code }));
                             return;
                         }
-                        const claudeDir = join(homedir(), '.claude');
-                        const projectsDir = join(claudeDir, 'projects');
-                        mkdirSync(projectsDir, { recursive: true });
-                        // The archive should contain a 'projects' subdirectory
-                        const extractedProjects = join(tmpExtractDir, 'projects');
-                        const sourceDir = existsSync(extractedProjects) ? extractedProjects : tmpExtractDir;
-                        // Copy subdirectories into ~/.claude/projects/, merging and updating existing files
-                        let filesWritten = 0;
-                        const slugsInSource = readdirSync(sourceDir);
-                        for (const slug of slugsInSource) {
-                            const destSlug = join(projectsDir, slug);
-                            mkdirSync(destSlug, { recursive: true });
-                            try {
-                                renameSync(join(sourceDir, slug), destSlug);
-                            }
-                            catch (e) {
-                                if (e.code === 'EXDEV') {
-                                    // Cross-filesystem fallback
-                                    cpSync(join(sourceDir, slug), destSlug, { recursive: true, force: true, errorOnExist: false });
-                                }
-                                else {
-                                    throw e;
-                                }
-                            }
-                            // Also create the corresponding workspace directory so Claude can resume
-                            const recoveredPath = slug.replace(/^-/, '/').replace(/--/g, '/.').replace(/-/g, '/');
-                            if (recoveredPath && recoveredPath !== '/') {
-                                mkdirSync(recoveredPath, { recursive: true });
-                            }
-                            filesWritten++;
-                        }
+                        const { filesWritten, remapped } = await mergeExtractedIntoProjects(tmpExtractDir, targetWorkDir);
                         res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: true, filesWritten }));
+                        res.end(JSON.stringify({ ok: true, filesWritten, remapped }));
                     }
                     catch (err) {
                         console.error('[import-finalize] merge error:', err);
@@ -1308,7 +1366,9 @@ async function main() {
             skipTTSQueue: true,
             onCompactionEvent: (event) => {
                 try {
-                    sendToFrontend({ type: event.type, trigger: event.trigger, skillsWritten: event.skillsWritten });
+                    // Forward every field — frontend renders stage + detail + skill list during compaction.
+                    // Spread covers compaction_started/progress/complete (different fields per type).
+                    sendToFrontend({ ...event });
                 }
                 catch { /* non-fatal */ }
             },
@@ -1641,7 +1701,9 @@ async function main() {
             resumeSessionId,
             onCompactionEvent: (event) => {
                 try {
-                    sendToFrontend({ type: event.type, trigger: event.trigger, skillsWritten: event.skillsWritten });
+                    // Forward every field — frontend renders stage + detail + skill list during compaction.
+                    // Spread covers compaction_started/progress/complete (different fields per type).
+                    sendToFrontend({ ...event });
                 }
                 catch { /* non-fatal */ }
             },

package/package.json

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