osborn 0.9.213 → 0.9.215

package/dist/claude-llm.js

@@ -15,7 +15,7 @@ import { getResearchSystemPrompt, getDirectModeResearchPrompt, getGroundingBlock
 import { getIndexPath } from './summary-index.js';
 import { openStore, recall, storeExists, updateSessionStore, getStorePath } from './session-store.js';
 import { getEmbedder } from './embedder.js';
-import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync, statSync } from 'node:fs';
 import { join, dirname, resolve, basename } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
@@ -200,56 +200,105 @@ function loadAllSkills(_workingDir) {
     return `<available-skills>\n${[...skillMap.values()].join('\n\n---\n\n')}\n</available-skills>`;
 }
 /**
- * Enumerate the agent's CURRENT skills (name + one-line description) from
- * ~/.claude/skills, for injection into the PreCompact instruction. This is the
- * list the compaction model dedupes/merges against so it stops re-emitting
- * duplicate skills every session. Description is taken from YAML frontmatter
- * (`description:`) when present, else the WHEN: line, else the first non-heading
- * line. Returns one `- name: description` per line, or '' if none.
+ * Enumerate the agent's CURRENT skills from ~/.claude/skills for injection into
+ * the PreCompact instruction — the material the compaction model reads so it
+ * refines/merges existing skills instead of re-emitting duplicates.
+ *
+ * Containment principle (why this is cheap AND complete):
+ *  - SKILL.md is the canonical knowledge file and is small (~1–15KB each). We
+ *    inject it IN FULL so the model sees every minute implementation detail and
+ *    its UPDATE_SECTION edits are never blind. Bodies are emitted up to a total
+ *    char budget; any overflow skill degrades to headings-only (still enough to
+ *    dedup / target a section) so a pathological skill count can't blow the turn.
+ *  - Satellite files in the folder (scripts/tools/reference docs) can be huge and
+ *    unbounded, so we NEVER inject their contents — only a manifest line
+ *    (name + size). The model can flag one for update; editing it is deferred to
+ *    the user or a future tool-equipped merger that reads just that one file.
  */
+// ~50K tokens of full SKILL.md text — ~5% of the 1M-context summarizer window, so
+// completeness (the user's priority) wins over frugality. 16 defaults already use
+// ~59KB, so a real user's defaults + learned + UI skills need real headroom here.
+// NOTE: skills are walked alphabetically, so once the budget is hit the *late-alphabet*
+// skills degrade to headings-only. A future refinement is to order by session-relevance
+// (skills touched this session first) rather than name, so the overflow is the least
+// relevant skills rather than an alphabetical accident.
+const SKILL_BODY_BUDGET = 200_000;
+function extractSkillDescription(raw) {
+    let desc = '';
+    const fm = raw.match(/^---\n([\s\S]*?)\n---/);
+    if (fm) {
+        const m = fm[1].match(/^description:\s*(.+)$/m);
+        if (m)
+            desc = m[1].trim();
+    }
+    const body = raw.replace(/^---\n[\s\S]*?\n---\n?/, '');
+    if (!desc) {
+        const when = body.match(/^\s*WHEN:\s*(.+)$/mi);
+        if (when)
+            desc = when[1].trim();
+    }
+    if (!desc) {
+        const first = body.split('\n').map(l => l.trim()).find(l => l && !l.startsWith('#'));
+        desc = first || '(no description)';
+    }
+    return desc.length > 200 ? desc.slice(0, 197) + '…' : desc;
+}
 function enumerateSkillsForCompaction() {
     const dir = join(homedir(), '.claude', 'skills');
     if (!existsSync(dir))
         return '';
-    const lines = [];
+    const blocks = [];
+    let budgetLeft = SKILL_BODY_BUDGET;
     try {
         for (const name of readdirSync(dir).sort()) {
-            const file = join(dir, name, 'SKILL.md');
+            const folder = join(dir, name);
+            const file = join(folder, 'SKILL.md');
             if (!existsSync(file))
                 continue;
-            let desc = '';
             try {
-                const raw = readFileSync(file, 'utf-8');
-                const fm = raw.match(/^---\n([\s\S]*?)\n---/);
-                if (fm) {
-                    const m = fm[1].match(/^description:\s*(.+)$/m);
-                    if (m)
-                        desc = m[1].trim();
+                const raw = readFileSync(file, 'utf-8').trim();
+                const desc = extractSkillDescription(raw);
+                // Manifest of satellite files (name + size), contents NEVER injected.
+                let manifest = '';
+                try {
+                    const others = readdirSync(folder)
+                        .filter(f => f !== 'SKILL.md')
+                        .map(f => {
+                        try {
+                            const st = statSync(join(folder, f));
+                            const kb = st.isDirectory() ? '(dir)' : `${Math.max(1, Math.round(st.size / 1024))}KB`;
+                            return `${f} ${kb}`;
+                        }
+                        catch {
+                            return f;
+                        }
+                    });
+                    if (others.length)
+                        manifest = `files (contents NOT shown — flag for update if needed): ${others.join(', ')}\n`;
                 }
-                if (!desc) {
-                    const body = raw.replace(/^---\n[\s\S]*?\n---\n?/, '');
-                    const when = body.match(/^\s*WHEN:\s*(.+)$/mi);
-                    if (when)
-                        desc = when[1].trim();
+                catch { /* folder read race — skip manifest */ }
+                const header = `########## SKILL: ${name} ##########\ndescription: ${desc}\n${manifest}`;
+                if (raw.length <= budgetLeft) {
+                    budgetLeft -= raw.length;
+                    blocks.push(`${header}${raw}`);
                 }
-                if (!desc) {
+                else {
+                    // Over budget → headings-only fallback (still enough to dedup + target a section).
                     const body = raw.replace(/^---\n[\s\S]*?\n---\n?/, '');
-                    const first = body.split('\n').map(l => l.trim()).find(l => l && !l.startsWith('#'));
-                    desc = first || '(no description)';
+                    const headings = (body.match(/^#{2,6}\s+.+$/gm) || [])
+                        .map(h => h.replace(/^#+\s+/, '').trim());
+                    blocks.push(`${header}(full body omitted — over injection budget)\nsections: ${headings.join(' | ') || '(none)'}`);
                 }
             }
             catch {
-                desc = '(unreadable)';
+                blocks.push(`########## SKILL: ${name} ##########\n(unreadable)`);
             }
-            if (desc.length > 180)
-                desc = desc.slice(0, 177) + '…';
-            lines.push(`- ${name}: ${desc}`);
         }
     }
     catch (err) {
         console.warn('⚠️ enumerateSkillsForCompaction failed:', err instanceof Error ? err.message : err);
     }
-    return lines.join('\n');
+    return blocks.join('\n\n');
 }
 // Compaction threshold: Fable 5 runs a 1M context window, so let sessions use
 // all of it before auto-compacting. autoCompactWindow max is 1_000_000; the SDK
@@ -2164,16 +2213,27 @@ class ClaudeLLMStream extends llm.LLMStream {
                                         // proliferated duplicates. We hand it the current skill set + an adversarial,
                                         // self-critical directive to merge/refine rather than create anew.
                                         const existingSkills = enumerateSkillsForCompaction();
-                                        const skillCount = existingSkills ? existingSkills.split('\n').length : 0;
+                                        // Each skill is delimited by a `########## SKILL: <name> ##########` header.
+                                        const skillCount = existingSkills
+                                            ? (existingSkills.match(/^########## SKILL: /gm) || []).length
+                                            : 0;
                                         const criticBlock = existingSkills
-                                            ? `\n\n---\n\n=== EXISTING SKILLS (${skillCount}) ===\n`
-                                                + `These skills ALREADY EXIST for this user (name: description). Before you emit `
-                                                + `SKILL_CANDIDATES or BEHAVIORAL_LEARNINGS, act as an ADVERSARIAL reviewer of your own output:\n`
-                                                + `1. If a candidate duplicates or substantially overlaps one below, DO NOT create a new skill — `
+                                            ? `\n\n---\n\n=== EXISTING SKILLS (${skillCount}) — FULL TEXT ===\n`
+                                                + `Below is the COMPLETE current text of each skill the user already has (delimited by `
+                                                + `\`########## SKILL: <name> ##########\`). A \`files:\` line lists any satellite files in the `
+                                                + `skill folder (scripts/tools/docs) whose CONTENTS are not shown — flag one only if it clearly needs updating.\n`
+                                                + `Read these before emitting SKILL_CANDIDATES or BEHAVIORAL_LEARNINGS, and act as an ADVERSARIAL reviewer of your own output:\n`
+                                                + `1. If what you learned refines ONE part of an existing skill, do NOT re-emit the whole skill. Emit a `
+                                                + `surgical section update inside SKILL_CANDIDATES using this exact block form (the heading must match a `
+                                                + `\`## \`/\`### \` heading that appears verbatim in that skill's text above):\n`
+                                                + `   --- UPDATE_SECTION: <skill-name> > <exact section heading> ---\n`
+                                                + `   <the new markdown that should REPLACE that section's body — preserve detail already present that is still correct>\n`
+                                                + `   --- END UPDATE_SECTION ---\n`
+                                                + `2. If a candidate duplicates or substantially overlaps one above but isn't a single-section tweak, `
                                                 + `re-emit it under the EXACT SAME kebab-case name, and only if it needs a substantive update; otherwise omit it.\n`
-                                                + `2. Propose a brand-new skill ONLY if nothing below covers it, it was CONFIRMED working this session, `
+                                                + `3. Propose a brand-new skill ONLY if nothing above covers it, it was CONFIRMED working this session, `
                                                 + `and it generalizes to future sessions on different tasks.\n`
-                                                + `3. Prefer merging/refining over proliferating. A small set of sharp, non-overlapping skills is the goal — `
+                                                + `4. Prefer refining/section-updating over proliferating. A small set of sharp, non-overlapping skills is the goal — `
                                                 + `reject your own low-signal or one-off candidates.\n\n`
                                                 + `${existingSkills}\n`
                                             : '';
@@ -2286,6 +2346,64 @@ class ClaudeLLMStream extends llm.LLMStream {
                                         catch (skillErr) {
                                             console.error('⚠️ PostCompact: SKILL_CANDIDATES write failed:', skillErr instanceof Error ? skillErr.message : skillErr);
                                         }
+                                        // ── Section 3b: UPDATE_SECTION — surgical, section-level edits to EXISTING skills ──
+                                        // The model (via the PreCompact preamble) emits blocks of the form:
+                                        //   --- UPDATE_SECTION: <skill-name> > <exact heading> ---
+                                        //   <replacement markdown for that section body>
+                                        //   --- END UPDATE_SECTION ---
+                                        // We splice the new body under the matching `## `/`### ` heading, replacing
+                                        // everything down to the next heading of the same-or-higher level. We NEVER
+                                        // create a file here — an unknown skill/heading is logged and skipped, so the
+                                        // model can't silently mint a new skill through this path.
+                                        try {
+                                            const updateRe = /---\s*UPDATE_SECTION:\s*([a-z][a-z0-9-]{1,39})\s*>\s*([^\n]+?)\s*---\n([\s\S]*?)---\s*END UPDATE_SECTION\s*---/g;
+                                            let um;
+                                            while ((um = updateRe.exec(summary)) !== null) {
+                                                const targetSkill = um[1].trim();
+                                                const targetHeading = um[2].trim();
+                                                const newBody = um[3].trim();
+                                                const skillPath = join(skillDir, '.claude', 'skills', targetSkill, 'SKILL.md');
+                                                if (!existsSyncFs(skillPath)) {
+                                                    console.warn(`⚠️ PostCompact: UPDATE_SECTION skipped — no such skill '${targetSkill}'`);
+                                                    continue;
+                                                }
+                                                const content = readSyncFs(skillPath, 'utf-8');
+                                                const lines2 = content.split('\n');
+                                                // Find the heading line (## or ###) whose text matches targetHeading (case-insensitive).
+                                                const norm = (s) => s.replace(/^#{2,3}\s+/, '').trim().toLowerCase();
+                                                const hIdx = lines2.findIndex(l => /^#{2,3}\s+/.test(l) && norm(l) === targetHeading.toLowerCase());
+                                                if (hIdx === -1) {
+                                                    console.warn(`⚠️ PostCompact: UPDATE_SECTION skipped — heading '${targetHeading}' not found in '${targetSkill}'`);
+                                                    continue;
+                                                }
+                                                const level = (lines2[hIdx].match(/^#+/) || ['##'])[0].length;
+                                                // Section ends at the next heading of the same-or-higher level (fewer/equal #s).
+                                                let end = lines2.length;
+                                                for (let i = hIdx + 1; i < lines2.length; i++) {
+                                                    const m2 = lines2[i].match(/^(#{1,6})\s+/);
+                                                    if (m2 && m2[1].length <= level) {
+                                                        end = i;
+                                                        break;
+                                                    }
+                                                }
+                                                const rebuilt = [
+                                                    ...lines2.slice(0, hIdx + 1),
+                                                    '',
+                                                    newBody,
+                                                    '',
+                                                    ...lines2.slice(end),
+                                                ].join('\n');
+                                                writeSyncFs(skillPath, rebuilt, 'utf-8');
+                                                console.log(`🧠 PostCompact: UPDATE_SECTION applied — '${targetSkill}' › '${targetHeading}' (${newBody.length} chars)`);
+                                                skillsWritten++;
+                                                if (!skillNames.includes(targetSkill))
+                                                    skillNames.push(targetSkill);
+                                                progress('Updated section', `${targetSkill} › ${targetHeading}`);
+                                            }
+                                        }
+                                        catch (updErr) {
+                                            console.error('⚠️ PostCompact: UPDATE_SECTION apply failed:', updErr instanceof Error ? updErr.message : updErr);
+                                        }
                                         // ── Section 4: BEHAVIORAL_LEARNINGS — write to learned-behaviors/SKILL.md ──
                                         try {
                                             const learnings = extractSection('=== BEHAVIORAL_LEARNINGS ===');

package/dist/index.js

@@ -559,10 +559,12 @@ function startApiServer(workingDir, port) {
         if (req.method === 'GET' && url.pathname === '/skills') {
             // Installed skills — same list the chat's get_skills data-channel message
             // returns, exposed over HTTP so the DASHBOARD (no LiveKit connection) can
-            // render the skills manager too. process.cwd() === sessionBaseDir (the
-            // osborn install dir where .claude/skills lives — see main()).
+            // render the skills manager too. Reads ~/.claude/skills (homedir) — the SINGLE
+            // location the agent ingests from (loadAllSkills) and PostCompact writes to.
+            // Previously used process.cwd()/.claude/skills, which the agent never read —
+            // so UI-created skills were invisible to the agent (the "divergence").
             res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ skills: loadSkillsList(process.cwd()) }));
+            res.end(JSON.stringify({ skills: loadSkillsList(homedir()) }));
             return;
         }
         if (req.method === 'GET' && url.pathname === '/agents') {
@@ -4630,7 +4632,7 @@ async function main() {
                     mcpServers: getMcpServerStatusList(config),
                     enabledMcpServers: enabledMcpNames,
                     workingDirectory: workingDir,
-                    skills: loadSkillsList(sessionBaseDir),
+                    skills: loadSkillsList(homedir()),
                     namedAgents: Object.entries(NAMED_AGENTS).map(([name, a]) => ({
                         name, description: a.description, model: a.model, tools: a.tools,
                     })),
@@ -5330,7 +5332,7 @@ async function main() {
             else if (data.type === 'get_skills') {
                 await sendToFrontend({
                     type: 'skills_status',
-                    skills: loadSkillsList(sessionBaseDir),
+                    skills: loadSkillsList(homedir()),
                 });
             }
             else if (data.type === 'get_agents') {
@@ -5404,11 +5406,11 @@ async function main() {
                 }
                 else {
                     try {
-                        const skillDir = join(sessionBaseDir, '.claude', 'skills', skillName);
+                        const skillDir = join(homedir(), '.claude', 'skills', skillName);
                         mkdirSync(skillDir, { recursive: true });
                         writeFileSync(join(skillDir, 'SKILL.md'), skillContent, 'utf-8');
                         console.log(`📚 Skill added: ${skillName}`);
-                        const skills = loadSkillsList(sessionBaseDir);
+                        const skills = loadSkillsList(homedir());
                         await sendToFrontend({ type: 'skill_add_result', success: true, skills });
                     }
                     catch (err) {
@@ -5419,7 +5421,7 @@ async function main() {
             }
             else if (data.type === 'skill_get') {
                 const folder = (data.name || '').trim().toLowerCase().replace(/[^a-z0-9-]/g, '-');
-                const p = join(sessionBaseDir, '.claude', 'skills', folder, 'SKILL.md');
+                const p = join(homedir(), '.claude', 'skills', folder, 'SKILL.md');
                 if (folder && existsSync(p)) {
                     await sendToFrontend({ type: 'skill_content', name: folder, content: readFileSync(p, 'utf-8') });
                 }
@@ -5429,7 +5431,7 @@ async function main() {
             }
             else if (data.type === 'skill_remove') {
                 const folder = (data.name || '').trim().toLowerCase().replace(/[^a-z0-9-]/g, '-');
-                const dir = join(sessionBaseDir, '.claude', 'skills', folder);
+                const dir = join(homedir(), '.claude', 'skills', folder);
                 if (!folder || !existsSync(dir)) {
                     await sendToFrontend({ type: 'skill_remove_result', success: false, error: 'skill not found' });
                 }
@@ -5437,7 +5439,7 @@ async function main() {
                     try {
                         rmSync(dir, { recursive: true, force: true });
                         console.log(`🗑️ Skill removed: ${folder}`);
-                        await sendToFrontend({ type: 'skill_remove_result', success: true, skills: loadSkillsList(sessionBaseDir) });
+                        await sendToFrontend({ type: 'skill_remove_result', success: true, skills: loadSkillsList(homedir()) });
                     }
                     catch (err) {
                         await sendToFrontend({ type: 'skill_remove_result', success: false, error: String(err) });

package/package.json

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