osborn 0.9.36 → 0.9.38

package/Dockerfile.sandbox

@@ -31,10 +31,23 @@ RUN npm install -g "osborn@${OSBORN_VERSION}" @anthropic-ai/claude-code
 # Persistent workspace + claude config dirs
 RUN mkdir -p /workspace /root/.claude
 
+# Marker so orchestration (machines.ts isManifestAware) can detect this image
+# supports the manifest-driven update flow. Pre-marker machines fall back to
+# the image-swap update path, which brings them onto a marker-aware image;
+# from then on, all updates use the manifest flow defined in the entrypoint.
+RUN touch /etc/osborn-manifest-aware
+
 ENV OSBORN_CWD=/workspace
 ENV OSBORN_API_PORT=8741
 ENV NODE_ENV=production
 
+# HOME points at the volume so user-space config from any tool that respects
+# HOME (gh, git, ssh, aws, etc.) automatically writes to the persistent
+# volume instead of the ephemeral container overlay. The existing /root/.claude
+# symlink machinery below stays in place — it's redundant with HOME=/workspace
+# but harmless.
+ENV HOME=/workspace
+
 WORKDIR /workspace
 
 EXPOSE 8741
@@ -52,6 +65,10 @@ ln -sf /workspace/.claude /root/.claude
 # Suppress Claude Code interactive onboarding prompts
 ONBOARDING_JSON='{"numStartups":10,"installMethod":"npm","autoUpdates":false,"hasCompletedOnboarding":true,"hasTrustDialogAccepted":true,"hasTrustDialogHooksAccepted":true,"hasCompletedProjectOnboarding":true,"hasAcknowledgedCostThreshold":true,"effortCalloutV2Dismissed":true,"theme":"dark","projects":{"/workspace":{"hasTrustDialogAccepted":true,"hasTrustDialogHooksAccepted":true,"hasCompletedProjectOnboarding":true}}}'
 echo "$ONBOARDING_JSON" > /root/.claude.json
+# Additional write at $HOME/.claude.json. With HOME=/workspace this is where
+# Claude Code actually reads its top-level config from; the /root/.claude.json
+# write above becomes dead but is left in place (harmless).
+echo "$ONBOARDING_JSON" > /workspace/.claude.json
 mkdir -p /workspace/.claude
 echo "$ONBOARDING_JSON" > /workspace/.claude/.config.json
 echo "$ONBOARDING_JSON" > /workspace/.claude/claude.json
@@ -79,6 +96,23 @@ if [ -d "$PKG_SKILLS_DIR" ]; then
   done
 fi
 
+# Manifest-driven version check.
+# Orchestration writes /workspace/.osborn-want-version on update (machines.ts
+# updateViaManifest). On every boot we compare to the currently-installed
+# osborn and run `npm install -g osborn@<want>` if they differ. The install
+# lands in the container overlay (default npm prefix) — Fly wipes overlay on
+# stop/start so the install re-runs on every boot until the base image is
+# rebuilt with that version baked in. Update is fast between Fly restarts;
+# only the first boot after a restart pays the npm install cost.
+WANT=$(cat /workspace/.osborn-want-version 2>/dev/null | tr -d '[:space:]')
+if [ -n "$WANT" ]; then
+  CURRENT=$(osborn --version 2>/dev/null | head -1 | tr -d '[:space:]')
+  if [ "$WANT" != "$CURRENT" ]; then
+    echo "[sandbox] osborn ${CURRENT:-none} → ${WANT} (manifest install)"
+    npm install -g "osborn@${WANT}" || echo "[sandbox] install failed — running ${CURRENT:-image-baked} version"
+  fi
+fi
+
 exec osborn
 ENTRYPOINT
 

package/dist/index.js

@@ -1294,9 +1294,34 @@ async function main() {
                 console.warn('⚠️ Failed to read JSONL for interruption context:', err);
             }
         }
-        // Store — consumed when user's next message arrives via chat()
-        lastInterruption = { spokenText: fullText, recentMessages, timestamp: Date.now() };
-        console.log(`📋 Interruption context stored (text: ${fullText.length} chars, JSONL: ${recentMessages.length} chars)`);
+        // Store — consumed when user's next message arrives via chat().
+        // Preserve any already-buffered suppressedText (the user may have started speaking
+        // BEFORE the previous TTS completed, and we may have already suppressed in-flight
+        // tts_say events that arrived during that overlap).
+        const carriedSuppressed = lastInterruption?.suppressedText ?? '';
+        lastInterruption = { spokenText: fullText, recentMessages, suppressedText: carriedSuppressed, timestamp: Date.now() };
+        console.log(`📋 Interruption context stored (text: ${fullText.length} chars, JSONL: ${recentMessages.length} chars, suppressed carried: ${carriedSuppressed.length} chars)`);
+    }
+    /**
+     * Append text the agent tried to say while the user was speaking, but which we
+     * suppressed at the tts_say gate to avoid talking over them. Folded into
+     * lastInterruption so it travels to Claude in the next chat() call.
+     * If no interruption context exists yet (e.g. user just started speaking with no
+     * prior TTS interrupt), creates a fresh entry.
+     */
+    function appendSuppressedText(text) {
+        const t = text.trim();
+        if (!t)
+            return;
+        if (lastInterruption) {
+            const sep = lastInterruption.suppressedText ? '\n' : '';
+            lastInterruption.suppressedText = lastInterruption.suppressedText + sep + t;
+            lastInterruption.timestamp = Date.now();
+        }
+        else {
+            lastInterruption = { spokenText: '', recentMessages: '', suppressedText: t, timestamp: Date.now() };
+        }
+        console.log(`🤐 Suppressed text buffered (+${t.length} chars, total ${lastInterruption.suppressedText.length}): "${t.substring(0, 80)}${t.length > 80 ? '...' : ''}"`);
     }
     /**
      * Callback for PipelineDirectLLM — returns pending interruption context and clears it.
@@ -1311,7 +1336,11 @@ async function main() {
             lastInterruption = null;
             return null;
         }
-        const ctx = { spokenText: lastInterruption.spokenText, recentMessages: lastInterruption.recentMessages };
+        const ctx = {
+            spokenText: lastInterruption.spokenText,
+            recentMessages: lastInterruption.recentMessages,
+            suppressedText: lastInterruption.suppressedText,
+        };
         lastInterruption = null;
         return ctx;
     }
@@ -1821,6 +1850,15 @@ async function main() {
                 console.log(`🔇 tts_say fired but text is empty — skipping`);
                 return;
             }
+            // Suppress while the user is mid-utterance. Without this, agent text generated
+            // in parallel by the Claude SDK plays right over the user — same problem as
+            // pre-interrupt overlap, but at the *output* side. The suppressed text gets
+            // folded into lastInterruption so the next chat() to Claude carries it as
+            // "you wrote this but the user did not hear it — re-articulate if relevant."
+            if (userState === 'speaking') {
+                appendSuppressedText(data.text);
+                return;
+            }
             const sayId = Date.now(); // simple ID to correlate start/end logs
             console.log(`🗣️ [${sayId}] session.say START (${data.text.length} chars): "${data.text}"`);
             // Forward spoken text + audio to meeting output page when bot is in a meeting.

package/dist/pipeline-direct-llm.d.ts

@@ -14,6 +14,13 @@ import { EventEmitter } from 'events';
 export interface InterruptionContext {
     spokenText: string;
     recentMessages: string;
+    /**
+     * Text the agent generated while the user was still speaking, which we
+     * suppressed at session.say() to avoid talking over the user. The agent
+     * receives this so it knows what it tried to say but the user did not hear,
+     * and can re-articulate the relevant bits in its next response.
+     */
+    suppressedText: string;
 }
 export interface PipelineDirectOptions extends ClaudeLLMOptions {
     onFastBrainResult?: (result: FastBrainPanelResult) => void;

package/dist/pipeline-direct-llm.js

@@ -83,31 +83,89 @@ export class PipelineDirectLLM extends llm.LLM {
             }
         }
         console.log(`📥 [pipeline] chat() call #${callN} (${userText.length} chars): "${userText}"`);
-        // Check for pending interruption context — enrich user message if interrupted
+        // 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
+        // while the user was speaking, regardless of whether they were actually
+        // interrupting active TTS. We need to forward BOTH cases so the agent knows
+        // what it produced that the user didn't hear, and so the buffer is cleared
+        // every turn even when there was no interrupt.
         const interruptCtx = this.#opts.getAndConsumeInterruptionContext?.();
         if (interruptCtx && userText.trim()) {
-            console.log(`🔇 [pipeline] Enriching user message with interruption context`);
-            // Interrupt Claude's current work before sending enriched message
-            this.#claudeLLM.interruptQuery().catch(() => { });
-            // Replace user message in chatCtx with context-enriched version
-            const enrichedMessage = [
-                `[INTERRUPTED] The user interrupted your response mid-speech.`,
-                ``,
-                `What the user heard before cutoff:`,
-                `"${interruptCtx.spokenText}"`,
-                ``,
-                `Your recent messages (full untruncated — you wrote these):`,
-                interruptCtx.recentMessages || '(no recent messages found)',
-                ``,
-                `User's message: "${userText}"`,
-                ``,
-                `RESPOND with speech first, then act:`,
-                `- ALWAYS reply with at least one spoken sentence before doing any tool calls`,
-                `- 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`,
-                `- 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');
+            const hasInterrupt = !!interruptCtx.spokenText;
+            const hasSuppressed = !!interruptCtx.suppressedText;
+            const suppressedBlock = hasSuppressed
+                ? [
+                    ``,
+                    `Text you generated while the user was speaking — NOT played (we suppressed it so we wouldn't talk over them):`,
+                    `"${interruptCtx.suppressedText}"`,
+                    `If any of that is still relevant to the user's current message, re-articulate the key points naturally. If it's no longer relevant, drop it.`,
+                ].join('\n')
+                : '';
+            let enrichedMessage;
+            if (hasInterrupt) {
+                // Actual mid-TTS interruption — keep the full [INTERRUPTED] template
+                console.log(`🔇 [pipeline] Enriching: interrupt (spoken=${interruptCtx.spokenText.length} chars, suppressed=${interruptCtx.suppressedText.length} chars)`);
+                this.#claudeLLM.interruptQuery().catch(() => { });
+                enrichedMessage = [
+                    `[INTERRUPTED] The user interrupted your response mid-speech.`,
+                    ``,
+                    `What the user heard before cutoff:`,
+                    `"${interruptCtx.spokenText}"`,
+                    ``,
+                    `WHAT THE USER DID NOT HEAR (you wrote this but it was cut off):`,
+                    `Anything in "Your recent messages" below that appears AFTER the quoted heard text is content the user did not hear. The user has no memory of it.`,
+                    ``,
+                    `Your recent messages (full untruncated — you wrote these):`,
+                    interruptCtx.recentMessages || '(no recent messages found)',
+                    suppressedBlock,
+                    ``,
+                    `User's message: "${userText}"`,
+                    ``,
+                    `CONTEXT PRESERVATION (READ THIS):`,
+                    `The user has NO memory of unheard content. If any of it bears on their current message — answers a question they just asked, sets up a follow-up they're now asking about, or shows a knowledge gap and fills in a detail they're reacting to — you MUST surface it. Briefly is fine if their message is off-topic or explores a direction they haven't asked about yet. But never assume they remember what they never heard.`,
+                    ``,
+                    `RESPOND with speech first, then act:`,
+                    `- ALWAYS reply with at least one spoken sentence before doing any tool calls`,
+                    `- 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`,
+                    `- 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');
+            }
+            else if (hasSuppressed) {
+                // No real interrupt — user was speaking while we had text queued. They
+                // weren't cutting Osborn off, just talking over a gap. Don't claim an
+                // interrupt happened; symmetric structure to [INTERRUPTED] so Claude
+                // treats both signals consistently.
+                console.log(`🤐 [pipeline] Enriching: suppressed-only (${interruptCtx.suppressedText.length} chars, no interrupt)`);
+                enrichedMessage = [
+                    `[CONTEXT] You generated speech while the user was already talking. None of it played.`,
+                    ``,
+                    `What the user is saying now:`,
+                    `"${userText}"`,
+                    ``,
+                    `Text you produced that the user did NOT hear:`,
+                    `"${interruptCtx.suppressedText}"`,
+                    ``,
+                    `CONTEXT PRESERVATION (READ THIS):`,
+                    `The user has NO memory of the unheard text. If any of it bears on their current message — answers a question they just asked, sets up a follow-up they're now asking about, or shows a knowledge gap and fills in a detail they're reacting to — you MUST surface it. Briefly is fine if their message is off-topic or explores a direction they haven't asked about yet. But never assume they remember what they never heard.`,
+                    ``,
+                    `RESPOND with speech first, then act:`,
+                    `- ALWAYS reply with at least one spoken sentence before doing any tool calls`,
+                    `- Three likely cases — figure out which applies:`,
+                    `  (a) the user didn't realize you were responding → forward the key points of the unheard text`,
+                    `  (b) the user changed direction → drop the unheard text, follow their lead`,
+                    `  (c) the user's message builds on the unheard text → integrate it as if they'd heard it`,
+                    `- Keep it tight — this is a voice response.`,
+                ].join('\n');
+            }
+            else {
+                // Context object existed but both fields empty — defensive no-op,
+                // shouldn't happen because appendSuppressedText only creates entries
+                // when text is non-empty.
+                enrichedMessage = userText;
+            }
             // Modify the last user message in chatCtx
             for (let i = chatCtx.items.length - 1; i >= 0; i--) {
                 const item = chatCtx.items[i];

package/package.json

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