osborn 0.9.4 → 0.9.9

package/dist/index.js

@@ -10,11 +10,11 @@ initializeLogger({ pretty: true, level: 'info' });
 import { setMaxListeners } from 'node:events';
 setMaxListeners(50);
 import { createServer } from 'http';
-import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, mkdtempSync, cpSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, mkdtempSync, cpSync, rmSync, renameSync, statSync, createWriteStream } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn } from 'node:child_process';
-import { homedir } from 'node:os';
+import { homedir, tmpdir } from 'node:os';
 // 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.
@@ -331,6 +331,38 @@ function startApiServer(workingDir, port) {
                 res.destroy(); });
             return;
         }
+        // GET /sessions/manifest — return mtime+size for all .jsonl files per slug (public, no auth)
+        if (req.method === 'GET' && url.pathname === '/sessions/manifest') {
+            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);
+                    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 };
+                    }
+                    catch {
+                        // skip unreadable dirs
+                    }
+                }
+            }
+            catch {
+                // projects dir doesn't exist yet — return empty
+            }
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ slugs: slugMap }));
+            return;
+        }
         // POST /sessions/import — accept a gzipped tar and extract into ~/.claude/projects/
         if (req.method === 'POST' && url.pathname === '/sessions/import') {
             if (syncToken) {
@@ -342,83 +374,282 @@ function startApiServer(workingDir, port) {
                 }
             }
             const targetWorkDir = url.searchParams.get('targetWorkDir');
-            const chunks = [];
-            req.on('data', (chunk) => chunks.push(chunk));
-            req.on('end', () => {
-                const body = Buffer.concat(chunks);
-                const tmpDir = mkdtempSync('/tmp/osborn-import-');
+            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);
+            tarProc.stdin.on('error', (err) => {
+                console.error('[import] tar stdin error', err);
+                tarProc.kill('SIGTERM');
+                rmSync(tmpDir, { recursive: true, force: true });
+                if (!res.headersSent) {
+                    res.writeHead(500);
+                    res.end(JSON.stringify({ error: 'upload error' }));
+                }
+            });
+            req.on('aborted', () => {
+                tarProc.kill('SIGTERM');
+                rmSync(tmpDir, { recursive: true, force: true });
+            });
+            tarProc.stderr.on('data', (d) => console.error('[import]', d.toString()));
+            tarProc.on('close', async (code) => {
                 try {
-                    // Extract archive into temp dir
-                    const tarProc = spawn('tar', ['-xzf', '-', '-C', tmpDir]);
-                    tarProc.stdin.write(body);
+                    if (code !== 0) {
+                        res.writeHead(500);
+                        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++;
+                    }
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true, filesWritten, remapped }));
+                }
+                catch (err) {
+                    console.error('[import] merge error:', err);
+                    if (!res.headersSent) {
+                        res.writeHead(500);
+                        res.end(JSON.stringify({ error: 'Failed to merge sessions', detail: String(err) }));
+                    }
+                }
+                finally {
+                    rmSync(tmpDir, { recursive: true, force: true });
+                }
+            });
+            return;
+        }
+        // POST /sessions/import-chunk — accept a single chunk of a multi-part upload
+        if (req.method === 'POST' && url.pathname === '/sessions/import-chunk') {
+            if (syncToken) {
+                const authHeader = req.headers['authorization'] ?? '';
+                if (authHeader !== `Bearer ${syncToken}`) {
+                    res.writeHead(401, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Unauthorized' }));
+                    return;
+                }
+            }
+            const uploadId = url.searchParams.get('uploadId');
+            const chunkIndex = parseInt(url.searchParams.get('chunk') || '0');
+            if (!uploadId) {
+                res.writeHead(400);
+                res.end(JSON.stringify({ error: 'uploadId required' }));
+                return;
+            }
+            // Chunk storage dir: /tmp/osborn-upload-<uploadId>/
+            const uploadDir = join(tmpdir(), `osborn-upload-${uploadId}`);
+            mkdirSync(uploadDir, { recursive: true });
+            // Write chunk to padded filename for correct sort order
+            const chunkPath = join(uploadDir, `chunk-${String(chunkIndex).padStart(6, '0')}`);
+            const writeStream = createWriteStream(chunkPath);
+            req.pipe(writeStream);
+            writeStream.on('finish', () => {
+                res.writeHead(200);
+                res.end(JSON.stringify({ ok: true, chunk: chunkIndex }));
+            });
+            writeStream.on('error', (err) => {
+                console.error('[import-chunk] write error', err);
+                if (!res.headersSent) {
+                    res.writeHead(500);
+                    res.end(JSON.stringify({ error: 'write failed' }));
+                }
+            });
+            req.on('aborted', () => { writeStream.destroy(); });
+            return;
+        }
+        // POST /sessions/import-finalize — reassemble chunks, extract, apply slug merge
+        if (req.method === 'POST' && url.pathname === '/sessions/import-finalize') {
+            if (syncToken) {
+                const authHeader = req.headers['authorization'] ?? '';
+                if (authHeader !== `Bearer ${syncToken}`) {
+                    res.writeHead(401, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Unauthorized' }));
+                    return;
+                }
+            }
+            const uploadId = url.searchParams.get('uploadId');
+            const total = parseInt(url.searchParams.get('total') || '0');
+            const targetWorkDir = url.searchParams.get('targetWorkDir') ?? undefined;
+            if (!uploadId || total === 0) {
+                res.writeHead(400);
+                res.end(JSON.stringify({ error: 'uploadId and total required' }));
+                return;
+            }
+            const uploadDir = join(tmpdir(), `osborn-upload-${uploadId}`);
+            // Verify all chunks present
+            const expectedChunks = Array.from({ length: total }, (_, i) => `chunk-${String(i).padStart(6, '0')}`);
+            const presentChunks = existsSync(uploadDir) ? readdirSync(uploadDir).filter(f => f.startsWith('chunk-')).sort() : [];
+            const missing = expectedChunks.filter(c => !presentChunks.includes(c));
+            if (missing.length > 0) {
+                res.writeHead(400);
+                res.end(JSON.stringify({ error: 'missing chunks', missing }));
+                return;
+            }
+            const tmpExtractDir = mkdtempSync(join(tmpdir(), 'osborn-import-'));
+            try {
+                // Reassemble chunks into a single stream and pipe to tar
+                const tarProc = spawn('tar', ['-xf', '-', '-C', tmpExtractDir]);
+                // Stream chunks in order to tar stdin
+                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();
-                    tarProc.stderr.on('data', (d) => console.error('[import]', d.toString()));
-                    tarProc.on('close', (code) => {
+                };
+                streamChunks().catch(err => {
+                    console.error('[import-finalize] chunk stream error', err);
+                    tarProc.kill('SIGTERM');
+                });
+                tarProc.stderr.on('data', (d) => console.error('[import-finalize]', d.toString()));
+                tarProc.on('close', async (code) => {
+                    try {
                         if (code !== 0) {
-                            res.writeHead(500, { 'Content-Type': 'application/json' });
+                            res.writeHead(500);
                             res.end(JSON.stringify({ error: 'tar extraction failed', code }));
                             return;
                         }
-                        try {
-                            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
-                            let remapped = {};
-                            if (targetWorkDir) {
-                                const targetSlug = targetWorkDir.replace(/\//g, '-');
-                                const sourceSlugs = readdirSync(sourceDir);
-                                for (const slug of sourceSlugs) {
-                                    if (slug !== targetSlug && !slug.startsWith('.')) {
-                                        const newSlug = targetSlug;
-                                        remapped[slug] = newSlug;
-                                    }
+                        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;
+                        // 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 without overwriting
-                            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 });
-                                cpSync(join(sourceDir, slug), destSlug, {
-                                    recursive: true,
-                                    force: false, // don't overwrite existing files
-                                    errorOnExist: false,
-                                });
-                                filesWritten++;
+                        }
+                        // 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);
                             }
-                            res.writeHead(200, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ ok: true, filesWritten, remapped }));
+                            catch (e) {
+                                if (e.code === 'EXDEV') {
+                                    // Cross-filesystem fallback
+                                    cpSync(join(sourceDir, slug), destSlug, { recursive: true, force: true, errorOnExist: false });
+                                }
+                                else {
+                                    throw e;
+                                }
+                            }
+                            filesWritten++;
                         }
-                        catch (err) {
-                            console.error('[import] merge error:', err);
-                            res.writeHead(500, { 'Content-Type': 'application/json' });
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ ok: true, filesWritten, remapped }));
+                    }
+                    catch (err) {
+                        console.error('[import-finalize] merge error:', err);
+                        if (!res.headersSent) {
+                            res.writeHead(500);
                             res.end(JSON.stringify({ error: 'Failed to merge sessions', detail: String(err) }));
                         }
-                    });
-                }
-                catch (err) {
-                    console.error('[import] spawn error:', err);
-                    res.writeHead(500, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'Failed to start extraction', detail: String(err) }));
-                }
-            });
+                    }
+                    finally {
+                        rmSync(uploadDir, { recursive: true, force: true });
+                        rmSync(tmpExtractDir, { recursive: true, force: true });
+                    }
+                });
+            }
+            catch (err) {
+                rmSync(uploadDir, { recursive: true, force: true });
+                rmSync(tmpExtractDir, { recursive: true, force: true });
+                throw err;
+            }
             return;
         }
         res.writeHead(404, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ error: 'Not found' }));
     });
     const host = process.env.HOST || '0.0.0.0';
+    server.requestTimeout = 0; // no timeout — large uploads can take minutes
     server.listen(port, host, () => {
         console.log(`🌐 API server listening on http://${host}:${port}`);
         console.log(`   Sessions: http://${host}:${port}/sessions`);
     });
+    // Stale upload-chunk cleanup: remove osborn-upload-* dirs older than 30 minutes
+    const cleanStaleUploadDirs = () => {
+        const tmp = tmpdir();
+        const cutoff = Date.now() - 30 * 60 * 1000;
+        try {
+            const entries = readdirSync(tmp);
+            for (const entry of entries) {
+                if (!entry.startsWith('osborn-upload-'))
+                    continue;
+                const full = `${tmp}/${entry}`;
+                try {
+                    const st = statSync(full);
+                    if (st.isDirectory() && st.mtimeMs < cutoff) {
+                        rmSync(full, { recursive: true, force: true });
+                        console.log(`🧹 Removed stale upload dir: ${full}`);
+                    }
+                }
+                catch {
+                    // ignore per-entry errors
+                }
+            }
+        }
+        catch {
+            // ignore if /tmp is unreadable
+        }
+    };
+    cleanStaleUploadDirs();
+    setInterval(cleanStaleUploadDirs, 10 * 60 * 1000);
     server.on('error', (err) => {
         if (err.code === 'EADDRINUSE') {
             console.warn(`⚠️ API port ${port} in use, trying ${port + 1}...`);

package/dist/pipeline-direct-llm.js

@@ -106,7 +106,7 @@ export class PipelineDirectLLM extends llm.LLM {
                 `- If it's a quick side question, answer it then continue where you left off`,
                 `- If they want to change direction, acknowledge and follow their lead`,
                 `- Clarify when asked to or the question requires going over what you just said`,
-                `- Reference unspoken content naturally if relevant`,
+                `- If relevant details were cut off — whether they answer the current question or an earlier one — weave them back in naturally so the user stays in context without having to ask again.`,
             ].join('\n');
             // Modify the last user message in chatCtx
             for (let i = chatCtx.items.length - 1; i >= 0; i--) {

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

@@ -1,14 +1,57 @@
-IMPORTANT — BEFORE COMPACTING: Include a section at the END of your compact summary titled exactly:
+# Pre-Compaction Instructions
 
-=== BEHAVIORAL_LEARNINGS ===
+Before Claude Code compacts this conversation, you MUST preserve critical context by including the following four sections at the very END of your compact summary. Be selective and specific — vague summaries are useless.
 
-In this section, extract and list:
-1. USER CORRECTIONS — things the user explicitly told you to stop/start doing (e.g., "stop patching scripts", "use step-by-step not autonomous", "don't name sub-agents")
-2. USER PREFERENCES — recurring patterns in how the user works (e.g., "prefers yahoo email for new accounts", "wants visible browser not headless", "expects score-based salary calculation")
-3. DOMAIN KNOWLEDGE — specific technical facts verified during this session (e.g., "Workday sign-in is inline switch not modal", "CareSource hibernation is 30s confirmed")
-4. EFFECTIVE PATTERNS — approaches that worked and the user confirmed (e.g., "co-direction questions during steerable work", "grounding with 2 reads before speaking")
-5. ANTI-PATTERNS — approaches that failed or frustrated the user (e.g., "reporting exit code 0 as success without verification", "multiple browser windows from competing automation approaches")
+---
 
-Be SELECTIVE — only include items that are generalizable, actionable, and non-obvious. Skip task-specific details. Each item should be one line.
+## Section 1: HANDOFF_STATE
+Format: === HANDOFF_STATE ===
+Include:
+- **Current goal**: What are we building/fixing and WHY (the big-picture reason, not just the immediate task)
+- **Progress**: What is done, what is in-progress, what is the very next step
+- **Active facts**: Environment details mentioned in this session (API keys referenced, service URLs, version numbers confirmed, file paths that matter)
+- **Test results**: What was tried, what it showed, what it ruled out
 
-This section will be extracted after compaction and saved as a persistent skill for future sessions.
+Keep this under 800 characters. This stays in the compact summary — it is NOT written to disk.
+
+---
+
+## Section 2: DECISIONS
+Format: === DECISIONS ===
+List each architectural or project decision made in this session, one per line:
+- DECISION: <choice made> | RATIONALE: <why> | SCOPE: project
+
+Only include decisions that would matter in a future session on the same project. Skip trivial choices.
+
+---
+
+## Section 3: SKILL_CANDIDATES
+Format: === SKILL_CANDIDATES ===
+For each reusable how-to procedure confirmed working in this session, emit:
+
+--- SKILL: <kebab-case-name> ---
+WHEN: <one line: when this skill applies>
+STEPS:
+1. ...
+2. ...
+VERIFIED: <exact command or observation that confirmed it works>
+--- END SKILL ---
+
+A skill is worth extracting only if: (1) it was confirmed working in this session AND (2) it would apply to future sessions on different tasks. Do NOT re-emit skills already shown in the EXISTING SKILLS section unless they need substantive updates.
+
+---
+
+## Section 4: BEHAVIORAL_LEARNINGS
+Format: === BEHAVIORAL_LEARNINGS ===
+Capture user corrections, preferences, and anti-patterns in these subsections:
+USER CORRECTIONS:
+USER PREFERENCES:
+DOMAIN KNOWLEDGE:
+EFFECTIVE PATTERNS:
+ANTI-PATTERNS:
+
+If the EXISTING LEARNED SKILLS section is shown below, merge — update outdated items, add new ones, keep confirmed ones.
+
+---
+
+IMPORTANT: All four sections MUST appear at the end of the compact summary even if some are empty. Empty sections should have a single line: (none this session)

package/package.json

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