osborn 0.9.134 → 0.9.136

package/Dockerfile.sandbox

@@ -205,6 +205,20 @@ if [ -d "$HOME/.claude/projects" ]; then
   done
 fi
 
+
+# === Sync volume npm-global with image osborn version ===
+# PATH prefers /workspace/.npm-global/bin over /usr/local/bin — so after an
+# image-swap the volume copy is stale. Detect mismatch and sync on boot so
+# the dashboard update button (image-swap + restart) actually takes effect.
+VOL_OSBORN_VER=$(grep -m1 '"version"' /workspace/.npm-global/lib/node_modules/osborn/package.json 2>/dev/null | sed 's/.*"version"[^"]*"\([^"]*\)".*/\1/' || echo "none")
+if [ -n "$IMAGE_SEED_VERSION" ] && [ "$IMAGE_SEED_VERSION" != "$VOL_OSBORN_VER" ]; then
+  echo "[sandbox-d] volume osborn@${VOL_OSBORN_VER} != image@${IMAGE_SEED_VERSION} -- syncing"
+  rm -rf /workspace/.npm-global/lib/node_modules/.osborn-* 2>/dev/null
+  npm install -g "osborn@${IMAGE_SEED_VERSION}" --no-audit --no-fund 2>&1 | tail -3
+  echo "[sandbox-d] sync done: osborn@${IMAGE_SEED_VERSION} on volume"
+else
+  echo "[sandbox-d] volume osborn@${VOL_OSBORN_VER} matches image -- no sync needed"
+fi
 echo "[sandbox-d] exec'ing osborn (no chroot, HOME=$HOME)"
 exec osborn
 ENTRYPOINT

package/dist/claude-llm.js

@@ -199,6 +199,12 @@ export const NAMED_AGENTS = {
             '- Do NOT edit or write any files',
             '- Do NOT run destructive commands (no rm, no git push, no npm publish)',
             '- If you need clarification, ask the main agent — it will relay to the user if needed',
+            '',
+            '## When to use / handoff',
+            'Invoked FIRST for any task requiring facts, codebase exploration, or web research.',
+            'Return findings to the orchestrator — never directly to the user.',
+            'Run several researchers in parallel when there are independent threads to investigate.',
+            'Hand off back to the orchestrator; it decides whether to invoke planner or writer next.',
         ].join('\n'),
     },
     reasoner: {
@@ -235,6 +241,11 @@ export const NAMED_AGENTS = {
             '- Do NOT edit or write files — return a plan for the writer agent',
             '- Do NOT give wishy-washy "both options are valid" non-answers — commit to a recommendation',
             '- If you need more information, ask the main agent to delegate to the researcher',
+            '',
+            '## When to use / handoff',
+            'Invoked for hard architecture or tradeoff decisions — read-only, returns a plan.',
+            'Use AFTER researcher has gathered facts but BEFORE writer touches any files.',
+            'Return a clear recommendation and implementation plan; the orchestrator passes it to the writer.',
         ].join('\n'),
     },
     writer: {
@@ -279,6 +290,11 @@ export const NAMED_AGENTS = {
             '2. Run the build if applicable (npm run build, tsc --noEmit, etc.).',
             '3. If tests or build fail: attempt to fix the issue you introduced. Re-run.',
             '4. Report: files changed, what changed in each, test results, any failures.',
+            '',
+            '## When to use / handoff',
+            'Invoked AFTER the planner produces a written plan — the writer is the SOLE agent that edits files.',
+            'Do not invoke writer until a plan exists for any multi-step change.',
+            'When the writer returns, the orchestrator invokes tester AND reviewer in parallel before surfacing results.',
         ].join('\n'),
     },
     tester: {
@@ -313,6 +329,11 @@ export const NAMED_AGENTS = {
             '- Do NOT edit or write files — report failures so the writer agent can fix them',
             '- Do NOT run destructive commands (no rm, no git push, no npm publish)',
             '- Do NOT guess at fixes — diagnose only',
+            '',
+            '## When to use / handoff',
+            'Invoked in PARALLEL with reviewer, immediately after the writer returns a change.',
+            'Return a PASS or FAIL verdict with exact output; the orchestrator waits for both tester and reviewer.',
+            'NEVER skip for a code change — the orchestrator synthesizes and speaks only after both return.',
         ].join('\n'),
     },
     planner: {
@@ -349,6 +370,11 @@ export const NAMED_AGENTS = {
             '- Do NOT edit or write files — produce a plan only',
             '- Do NOT leave steps vague ("update the config" → say which file, which key, what value)',
             '- Do NOT include steps that depend on runtime information you do not have',
+            '',
+            '## When to use / handoff',
+            'Invoked AFTER researcher gathers facts and BEFORE writer touches any files, when the task has multiple steps.',
+            'Do not skip on multi-step or multi-file changes — vague delegation to writer without a plan produces worse output.',
+            'Return a self-contained brief; the orchestrator passes it directly to the writer.',
         ].join('\n'),
     },
     reviewer: {
@@ -398,6 +424,11 @@ export const NAMED_AGENTS = {
             '- Do NOT run destructive commands (no rm, no git push, no git commit, no npm publish)',
             '- Do NOT approve a change that has a real defect just to be agreeable',
             '- Do NOT raise trivial style nits as REJECT-worthy issues unless they break functionality',
+            '',
+            '## When to use / handoff',
+            'Invoked in PARALLEL with tester, immediately after the writer returns a change.',
+            'Return an ACCEPT or REJECT verdict with specific, actionable issue reports.',
+            'The orchestrator waits for both reviewer and tester before synthesizing and speaking to the user.',
         ].join('\n'),
     },
 };

package/dist/pipeline-direct-llm.js

@@ -9,9 +9,54 @@
  * Phase 2 (future): Gemini speaks first, Claude suppressed when Gemini has HIGH confidence
  */
 import { llm, DEFAULT_API_CONNECT_OPTIONS } from '@livekit/agents';
+import { readFileSync } from 'fs';
 import { ClaudeLLM } from './claude-llm.js';
 import { askPipelineFastBrain } from './pipeline-fastbrain.js';
-import { buildSummaryIndex, startIndexWatcher } from './summary-index.js';
+import { buildSummaryIndex, startIndexWatcher, getIndexPath } from './summary-index.js';
+// ============================================================
+// SESSION TAIL — compact recent-conversation block prepended to every user turn
+// so the orchestrator never loses the thread across context compaction.
+// Controlled by:
+//   OSBORN_SESSION_TAIL        — set to "0" to disable (default ON)
+//   OSBORN_SESSION_TAIL_COUNT  — max user+assistant lines to keep (default 200)
+// ============================================================
+function buildSessionTail(sessionId, workingDir) {
+    if (process.env.OSBORN_SESSION_TAIL === '0')
+        return '';
+    if (!sessionId)
+        return '';
+    const maxLines = parseInt(process.env.OSBORN_SESSION_TAIL_COUNT || '200', 10);
+    try {
+        const indexPath = getIndexPath(sessionId, workingDir);
+        if (!indexPath)
+            return '';
+        const raw = readFileSync(indexPath, 'utf-8');
+        const allLines = raw.split('\n').filter(Boolean);
+        // Read a larger raw window (4× target) then keep the last maxLines user+assistant entries
+        const rawWindow = allLines.slice(-maxLines * 4);
+        const convLines = [];
+        for (const line of rawWindow) {
+            const parts = line.split('|');
+            // format: lineNum|byteOffset|timestamp|source|msgType|summary
+            if (parts.length < 6)
+                continue;
+            const msgType = parts[4];
+            if (msgType !== 'user' && msgType !== 'assistant')
+                continue;
+            const timestamp = parts[2];
+            const speaker = msgType === 'user' ? 'User' : 'Assistant';
+            const summary = parts.slice(5).join('|').substring(0, 150);
+            convLines.push(`${timestamp}  ${speaker}: ${summary}`);
+        }
+        const kept = convLines.slice(-maxLines);
+        if (kept.length === 0)
+            return '';
+        return ['<session_tail>', ...kept, '</session_tail>'].join('\n');
+    }
+    catch {
+        return '';
+    }
+}
 export class PipelineDirectLLM extends llm.LLM {
     #claudeLLM;
     #opts;
@@ -88,6 +133,17 @@ export class PipelineDirectLLM extends llm.LLM {
             }
         }
         console.log(`📥 [pipeline] chat() call #${callN} (${userText.length} chars): "${userText}"`);
+        // ── SESSION TAIL injection ────────────────────────────────────────────────
+        // Prepend a compact recent-conversation block so the orchestrator never
+        // loses thread across compaction. Runs synchronously (readFileSync) but the
+        // index file is ≤1MB and kept hot in the OS page cache — negligible latency.
+        // Skipped for meeting chunks (they are not real user turns).
+        const sessionTailBlock = (!userText.startsWith('[MEETING'))
+            ? buildSessionTail(this.#claudeLLM.sessionId, this.#opts.workingDirectory || process.cwd())
+            : '';
+        if (sessionTailBlock) {
+            console.log(`🧵 [pipeline] Session tail: ${sessionTailBlock.split('\n').length - 2} lines ready`);
+        }
         // Always check the pending playback context — it can carry two independent
         // signals: (a) an actual interruption (spokenText + recentMessages) when the
         // user cut Osborn off mid-TTS, OR (b) suppressed text generated by the SDK
@@ -171,11 +227,27 @@ export class PipelineDirectLLM extends llm.LLM {
                 // when text is non-empty.
                 enrichedMessage = userText;
             }
-            // Modify the last user message in chatCtx
+            // Modify the last user message in chatCtx — prepend session tail if available
+            const finalMessage = sessionTailBlock
+                ? sessionTailBlock + '\n\n' + enrichedMessage
+                : enrichedMessage;
+            for (let i = chatCtx.items.length - 1; i >= 0; i--) {
+                const item = chatCtx.items[i];
+                if (item.type === 'message' && item.role === 'user') {
+                    item.content = [finalMessage];
+                    break;
+                }
+            }
+        }
+        else if (sessionTailBlock && userText.trim()) {
+            // No interrupt context — inject session tail directly into the user message
             for (let i = chatCtx.items.length - 1; i >= 0; i--) {
                 const item = chatCtx.items[i];
                 if (item.type === 'message' && item.role === 'user') {
-                    item.content = [enrichedMessage];
+                    const original = Array.isArray(item.content)
+                        ? item.content.filter((c) => typeof c === 'string').join('\n')
+                        : String(item.content ?? '');
+                    item.content = [sessionTailBlock + '\n\n' + original];
                     break;
                 }
             }

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

@@ -109,6 +109,13 @@ THE SUB-AGENTS:
   · reasoner (Opus) — architecture decisions, complex tradeoffs, implementation planning. Read-only.
   · writer (Sonnet) — ALL file changes outside the workspace. Verifies before, runs tests after. The ONLY agent with write access outside the workspace.
   · NEVER use the SDK's built-in 'general-purpose' agent — it is not configured for this project and will hit write blocks. Always pick researcher, reasoner, or writer explicitly.
+
+DIVISION OF LABOR — follow this chain by default for any substantive or code task:
+  researcher (gather facts) → planner (write a step plan for multi-step work) → writer (execute the plan) → tester AND reviewer in parallel (verify the change) → you synthesize and speak.
+For a quick factual query: researcher only → you speak.
+NEVER skip tester and reviewer after a code change.
+You may OVERRIDE this chain at any time — stop a running agent, inject, or reorder — because you can see each task's live state. The chain is the default, not a cage.
+Surfacing findings and communicating to the user is YOUR job, not a sub-agent's.
 </turn-shape>
 
 <co-direction>

package/dist/prompts.js

@@ -548,6 +548,13 @@ You have three named agents available via the Task tool:
   · reasoner — Opus, deep analysis. Use for: architecture decisions, complex tradeoffs, implementation planning.
   · writer — Sonnet, file changes. Use for: ALL file creation, editing, modification. Verifies before and after changes.
 
+DIVISION OF LABOR — follow this chain by default for any substantive or code task:
+  researcher (gather facts) → planner (write a step plan for multi-step work) → writer (execute the plan) → tester AND reviewer in parallel (verify the change) → you synthesize and speak.
+For a quick factual query: researcher only → you speak.
+NEVER skip tester and reviewer after a code change.
+You may OVERRIDE this chain at any time — stop a running agent, inject a step, or reorder — because you can see each task's live state. The chain is the default, not a cage.
+Surfacing findings and communicating to the user is YOUR job, not a sub-agent's.
+
 DELEGATION: For any task needing 3+ tool calls, delegate to the appropriate agent instead of doing it yourself.
 Quick lookups (1-2 calls) you can do directly. Everything else goes to an agent.
 

package/package.json

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