osborn 0.9.13 → 0.9.16

package/.claude/skills/markdown-to-pdf/SKILL.md

@@ -3,7 +3,7 @@
 Export Markdown documents as formatted PDF files.
 
 ## When to use
-When the user wants to create a PDF from a Markdown file, spec, or research findings.
+When the user  /wants to create a PDF from a Markdown file, spec, or research findings.
 
 ## How to execute
 

package/.claude/skills/playwright-browser/SKILL.md

@@ -3,7 +3,7 @@
 Automate web browser interactions — navigate pages, click buttons, fill forms, take screenshots, and extract content.
 
 ## When to use
-- Navigate to a URL and interact with it
+- Navigate to a - URL and interact with it
 - Click buttons or links by their text or role
 - Fill form fields and submit data
 - Take screenshots of web pages

package/.claude/skills/shadcn/SKILL.md

@@ -7,7 +7,7 @@ When the user wants to add UI components (buttons, dialogs, cards, forms, tables
 
 ## Setup (first time only)
 
-Initialize shadcn in the project root (where package.json lives):
+Initialize shadcn in the work/project root (where package.json lives):
 ```bash
 npx shadcn@latest init
 ```

package/dist/claude-llm.d.ts

@@ -78,6 +78,11 @@ export declare class ClaudeLLM extends llm.LLM {
      * Call this before sending the first message to resume from a previous session
      */
     setResumeSessionId(sessionId: string | null): void;
+    /**
+     * Set the working directory for the current session
+     * Call this when resuming a session from a different project slug
+     */
+    setWorkingDirectory(path: string): void;
     /**
      * Reset state for mid-conversation session switch
      * Clears pending permissions and resets conversation tracking

package/dist/claude-llm.js

@@ -14,6 +14,7 @@ import { getResearchSystemPrompt, getDirectModeResearchPrompt } from './prompts.
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { homedir } from 'node:os';
 // Directory of this module — used to locate co-located prompt files (e.g., turn-shape reminder).
 const __claudeLlmDir = dirname(fileURLToPath(import.meta.url));
 const TURN_SHAPE_REMINDER_PATH = join(__claudeLlmDir, 'prompts', 'turn-shape-reminder.md');
@@ -85,6 +86,44 @@ function loadSkillsFromDir(agentDir) {
     console.log(`📚 Loaded ${skills.length} skill(s) from ${skillsDir}`);
     return `<available-skills>\n${skills.join('\n\n---\n\n')}\n</available-skills>`;
 }
+/**
+ * Loads skills from both ~/.claude/skills/ (home dir) and {workingDir}/.claude/skills/ (project dir).
+ * 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) {
+    const homeSkillsDir = join(homedir(), '.claude', 'skills');
+    const projectSkillsDir = join(workingDir, '.claude', 'skills');
+    // skill name → content; home dir loaded first so it wins on conflicts
+    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());
+                }
+            }
+        }
+        catch (err) {
+            console.warn('⚠️ Failed to load skills from', dir, ':', err);
+        }
+    };
+    loadFromDir(homeSkillsDir);
+    loadFromDir(projectSkillsDir);
+    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}`);
+    return `<available-skills>\n${[...skillMap.values()].join('\n\n---\n\n')}\n</available-skills>`;
+}
 // Research mode tools — full research capabilities
 const RESEARCH_TOOLS = [
     'Read', 'Write', 'Edit', 'Glob', 'Grep',
@@ -301,6 +340,13 @@ export class ClaudeLLM extends llm.LLM {
             console.log(`🔄 Will resume session: ${sessionId}`);
         }
     }
+    /**
+     * Set the working directory for the current session
+     * Call this when resuming a session from a different project slug
+     */
+    setWorkingDirectory(path) {
+        this.#opts.workingDirectory = path;
+    }
     /**
      * Reset state for mid-conversation session switch
      * Clears pending permissions and resets conversation tracking
@@ -762,6 +808,7 @@ class ClaudeLLMStream extends llm.LLMStream {
                 // model: this.#opts.model || 'haiku', // haiku for speed with limited tools, sonnet for full research capabilities (including tool use trace in response)
                 model: this.#opts.model || 'claude-sonnet-4-6', // Sonnet orchestrator with named sub-agents (Haiku tested but ignored delegation rules)
                 enableFileCheckpointing: true,
+                settingSources: ['project', 'user'],
                 extraArgs: { 'replay-user-messages': null },
                 ...(this.#abortController && { abortController: this.#abortController }),
                 ...(resumeSessionId && { resume: resumeSessionId }),
@@ -773,7 +820,7 @@ class ClaudeLLMStream extends llm.LLMStream {
                     this.#opts.voiceMode === 'direct'
                         ? getDirectModeResearchPrompt(workspacePath)
                         : getResearchSystemPrompt(workspacePath),
-                    loadSkillsFromDir(this.#opts.sessionBaseDir || this.#opts.workingDirectory || process.cwd()),
+                    loadAllSkills(this.#opts.sessionBaseDir || this.#opts.workingDirectory || process.cwd()),
                 ].filter(Boolean).join('\n\n'),
                 canUseTool: async (toolName, input, _options) => {
                     // Auto-approve writes to session workspace (but block spec.md and library/ — fast brain manages those)
@@ -943,7 +990,7 @@ class ClaudeLLMStream extends llm.LLMStream {
                                     try {
                                         const summary = input?.compact_summary || '';
                                         const { mkdirSync, writeFileSync: writeSyncFs, readFileSync: readSyncFs, existsSync: existsSyncFs } = await import('node:fs');
-                                        const skillDir = this.#opts.sessionBaseDir || this.#opts.workingDirectory || process.cwd();
+                                        const skillDir = homedir();
                                         const today = new Date().toISOString().split('T')[0];
                                         const sessionId = this.#sessionId || 'unknown';
                                         let skillsWritten = 0;

package/dist/index.js

@@ -15,6 +15,8 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn } from 'node:child_process';
 import { homedir, tmpdir } from 'node:os';
+import { PassThrough } from 'node:stream';
+import { createGunzip } from 'node:zlib';
 // Resolve __dirname for this ESM module so we can find sibling files (e.g.
 // meeting-output.html) relative to the compiled JS location, NOT process.cwd().
 // In production cwd is the user's workspace; the static file lives next to dist/index.js.
@@ -376,8 +378,26 @@ function startApiServer(workingDir, port) {
             const targetWorkDir = url.searchParams.get('targetWorkDir');
             const tmpDir = mkdtempSync(join(tmpdir(), 'osborn-import-'));
             const tarProc = spawn('tar', ['-xf', '-', '-C', tmpDir]);
-            // Streaming: pipe request body directly to tar stdin — no buffering
-            req.pipe(tarProc.stdin);
+            // Stream-sniff the first chunk to detect gzip magic bytes (0x1f 0x8b).
+            // Then route through createGunzip() if gzip, otherwise pipe raw to tar.
+            // This avoids any reliance on Content-Type or Content-Encoding headers.
+            const passthrough = new PassThrough();
+            let sniffDone = false;
+            req.once('data', (firstChunk) => {
+                sniffDone = true;
+                const isGzip = firstChunk[0] === 0x1f && firstChunk[1] === 0x8b;
+                passthrough.write(firstChunk);
+                req.pipe(passthrough);
+                const source = isGzip ? passthrough.pipe(createGunzip()) : passthrough;
+                source.pipe(tarProc.stdin);
+            });
+            req.once('end', () => {
+                if (!sniffDone) {
+                    // Empty body — just end tar stdin
+                    passthrough.end();
+                    tarProc.stdin.end();
+                }
+            });
             tarProc.stdin.on('error', (err) => {
                 console.error('[import] tar stdin error', err);
                 tarProc.kill('SIGTERM');
@@ -437,6 +457,10 @@ function startApiServer(workingDir, port) {
                             }
                         }
                         filesWritten++;
+                        const recoveredPath = effectiveSlug.replace(/^-/, '/').replace(/--/g, '/.').replace(/-/g, '/');
+                        if (recoveredPath && recoveredPath !== '/') {
+                            mkdirSync(recoveredPath, { recursive: true });
+                        }
                     }
                     res.writeHead(200, { 'Content-Type': 'application/json' });
                     res.end(JSON.stringify({ ok: true, filesWritten, remapped }));
@@ -522,22 +546,24 @@ function startApiServer(workingDir, port) {
             }
             const tmpExtractDir = mkdtempSync(join(tmpdir(), 'osborn-import-'));
             try {
-                // Reassemble chunks into a single stream and pipe to tar
+                // Reassemble all chunks into a combined buffer, then sniff first 2 bytes
+                // to detect gzip magic (0x1f 0x8b). Route through createGunzip() if gzip,
+                // otherwise pass raw bytes — always using tar -xf (no -z flag).
+                const chunkBuffers = [];
+                for (const chunkFile of expectedChunks) {
+                    chunkBuffers.push(readFileSync(join(uploadDir, chunkFile)));
+                }
+                const combined = Buffer.concat(chunkBuffers);
+                const isGzip = combined[0] === 0x1f && combined[1] === 0x8b;
                 const tarProc = spawn('tar', ['-xf', '-', '-C', tmpExtractDir]);
-                // Stream chunks in order to tar stdin
+                // Feed combined buffer through gunzip (if needed) then into tar stdin
+                const feedStream = new PassThrough();
+                const tarInput = isGzip ? feedStream.pipe(createGunzip()) : feedStream;
+                tarInput.pipe(tarProc.stdin);
+                feedStream.end(combined);
                 const streamChunks = async () => {
-                    for (const chunkFile of expectedChunks) {
-                        const chunkData = readFileSync(join(uploadDir, chunkFile));
-                        await new Promise((resolve, reject) => {
-                            tarProc.stdin.write(chunkData, (err) => {
-                                if (err)
-                                    reject(err);
-                                else
-                                    resolve();
-                            });
-                        });
-                    }
-                    tarProc.stdin.end();
+                    // feeding is already initiated above; just return a resolved promise
+                    await Promise.resolve();
                 };
                 streamChunks().catch(err => {
                     console.error('[import-finalize] chunk stream error', err);
@@ -557,24 +583,11 @@ function startApiServer(workingDir, port) {
                         // The archive should contain a 'projects' subdirectory
                         const extractedProjects = join(tmpExtractDir, 'projects');
                         const sourceDir = existsSync(extractedProjects) ? extractedProjects : tmpExtractDir;
-                        // 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);
+                            const destSlug = join(projectsDir, slug);
                             mkdirSync(destSlug, { recursive: true });
                             try {
                                 renameSync(join(sourceDir, slug), destSlug);
@@ -588,10 +601,15 @@ function startApiServer(workingDir, port) {
                                     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++;
                         }
                         res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: true, filesWritten, remapped }));
+                        res.end(JSON.stringify({ ok: true, filesWritten }));
                     }
                     catch (err) {
                         console.error('[import-finalize] merge error:', err);
@@ -2971,13 +2989,59 @@ async function main() {
                     }
                 }
                 else {
-                    console.error(`❌ Session not found: ${sessionId}`);
-                    await sendToFrontend({
-                        type: 'session_resume_set',
-                        sessionId,
-                        success: false,
-                        error: 'Session not found',
-                    });
+                    // Try to find the session in any slug directory
+                    let found = false;
+                    const projectsDir = join(homedir(), '.claude', 'projects');
+                    if (existsSync(projectsDir)) {
+                        const slugDirs = readdirSync(projectsDir);
+                        for (const slug of slugDirs) {
+                            const candidate = join(projectsDir, slug, `${sessionId}.jsonl`);
+                            if (existsSync(candidate)) {
+                                // Recover the original path from the slug
+                                const recoveredPath = slug.replace(/^-/, '/').replace(/--/g, '/.').replace(/-/g, '/');
+                                if (recoveredPath && recoveredPath !== '/') {
+                                    mkdirSync(recoveredPath, { recursive: true });
+                                    workingDir = recoveredPath;
+                                    currentLLM.setWorkingDirectory(recoveredPath);
+                                    console.log(`🔄 Found session in slug ${slug}, using path: ${recoveredPath}`);
+                                    found = true;
+                                    // Proceed with the same success path
+                                    currentLLM.setResumeSessionId(sessionId);
+                                    currentResumeSessionId = sessionId;
+                                    console.log(`🔄 Will resume session: ${sessionId}`);
+                                    await sendToFrontend({
+                                        type: 'session_resume_set',
+                                        sessionId,
+                                        success: true,
+                                    });
+                                    const artifacts = listWorkspaceArtifacts(workingDir, sessionId);
+                                    if (artifacts.length > 0) {
+                                        console.log(`📁 Sending ${artifacts.length} session artifacts to frontend`);
+                                        await sendToFrontend({
+                                            type: 'session_artifacts',
+                                            sessionId,
+                                            artifacts: artifacts.map(a => ({
+                                                filePath: a.filePath,
+                                                fileName: a.fileName,
+                                                type: a.type,
+                                                updatedAt: a.updatedAt,
+                                            }))
+                                        });
+                                    }
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    if (!found) {
+                        console.error(`❌ Session not found: ${sessionId}`);
+                        await sendToFrontend({
+                            type: 'session_resume_set',
+                            sessionId,
+                            success: false,
+                            error: 'Session not found',
+                        });
+                    }
                 }
             }
             else if (data.type === 'continue_session' && currentLLM) {

package/package.json

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