osborn 0.8.5 → 0.8.7

package/Dockerfile.sandbox

@@ -0,0 +1,59 @@
+# Osborn Sandbox — Fly.io Machines (per-user)
+# Installs osborn as npm package (not from source) for lightweight per-user machines.
+# Build: docker build -f Dockerfile.sandbox -t registry.fly.io/osborn-sandbox/agent:latest .
+# Push:  fly auth docker && docker push registry.fly.io/osborn-sandbox/agent:latest
+
+FROM node:22-slim
+
+# Runtime deps for osborn + claude-code
+RUN apt-get update -qq && \
+    apt-get install --no-install-recommends -y \
+    ca-certificates \
+    curl \
+    git \
+    python-is-python3 && \
+    rm -rf /var/lib/apt/lists/*
+
+# Install osborn + claude-code globally
+RUN npm install -g osborn@latest @anthropic-ai/claude-code
+
+# Persistent workspace + claude config dirs
+RUN mkdir -p /workspace /root/.claude
+
+ENV OSBORN_CWD=/workspace
+ENV OSBORN_API_PORT=8741
+ENV NODE_ENV=production
+
+WORKDIR /workspace
+
+EXPOSE 8741
+
+# Entrypoint: credential persistence + onboarding suppression + start
+COPY <<'ENTRYPOINT' /entrypoint.sh
+#!/bin/sh
+set -e
+
+# Claude credential persistence (volume at /workspace)
+mkdir -p /workspace/.claude
+rm -rf /root/.claude
+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
+mkdir -p /workspace/.claude
+echo "$ONBOARDING_JSON" > /workspace/.claude/.config.json
+echo "$ONBOARDING_JSON" > /workspace/.claude/claude.json
+
+# Restore OAuth token if persisted on volume
+if [ -f /workspace/.claude/.oauth-token ]; then
+  export CLAUDE_CODE_OAUTH_TOKEN="$(cat /workspace/.claude/.oauth-token)"
+  echo "[sandbox] Restored CLAUDE_CODE_OAUTH_TOKEN from volume"
+fi
+
+exec osborn
+ENTRYPOINT
+
+RUN chmod +x /entrypoint.sh
+
+CMD ["/entrypoint.sh"]

package/dist/claude-llm.js

@@ -12,7 +12,11 @@ import { EventEmitter } from 'events';
 import { saveSessionMetadata, getSessionWorkspace } from './config.js';
 import { getResearchSystemPrompt, getDirectModeResearchPrompt } from './prompts.js';
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+// 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');
 /**
  * Strip markdown formatting for TTS (text-to-speech)
  * Removes **bold**, ##headers, ```code```, etc. so TTS doesn't read them literally
@@ -617,7 +621,7 @@ export class ClaudeLLM extends llm.LLM {
                             callbacks.eventEmitter.emit('assistant_text', { text: block.text });
                             const ttsChunk = stripMarkdownForTTS(block.text);
                             if (ttsChunk.trim()) {
-                                console.log(`🔊 TTS say (${ttsChunk.length} chars): "${ttsChunk.substring(0, 60)}..."`);
+                                console.log(`🔊 TTS say (${ttsChunk.length} chars): "${ttsChunk}"`);
                                 callbacks.eventEmitter.emit('tts_say', { text: ttsChunk });
                             }
                         }
@@ -732,7 +736,7 @@ class ClaudeLLMStream extends llm.LLMStream {
                 });
                 return;
             }
-            console.log(`🎤 User: "${userText.substring(0, 100)}${userText.length > 100 ? '...' : ''}"`);
+            console.log(`🎤 User (${userText.length} chars): "${userText}"`);
             // Build Claude Agent SDK options
             const resumeSessionId = this.#opts.resumeSessionId;
             const continueSession = this.#opts.continueSession;
@@ -852,6 +856,35 @@ class ClaudeLLMStream extends llm.LLMStream {
                                     this.#eventEmitter.emit('tool_result', { name: toolName, input: toolInput, response: toolResponse });
                                     return {};
                                 }]
+                        }],
+                    // Per-turn behavioral re-anchor. Fires on EVERY user message that reaches Claude
+                    // (initial requests, follow-ups, mid-flight steering, resumed-session messages).
+                    // Reads the reminder text from disk every call, so it's hot-editable just like the
+                    // main prompt — edit agent/src/prompts/turn-shape-reminder.md, reconnect, next message
+                    // sees the new reminder. The SDK injects `additionalContext` alongside the user's actual
+                    // message so the model sees both the literal user input AND the reminder, weighing them
+                    // together. This is what fights JSONL-history-overrides-system-prompt drift on resumed
+                    // sessions: the conductor pattern gets re-asserted on every turn instead of being
+                    // anchored only at session-init time.
+                    UserPromptSubmit: [{
+                            matcher: '.*',
+                            hooks: [async (input) => {
+                                    try {
+                                        const reminder = readFileSync(TURN_SHAPE_REMINDER_PATH, 'utf-8');
+                                        const promptPreview = String(input?.prompt || '').substring(0, 60).replace(/\n/g, ' ');
+                                        console.log(`📌 UserPromptSubmit: injected turn-shape reminder (${reminder.length} chars) for prompt="${promptPreview}..."`);
+                                        return {
+                                            hookSpecificOutput: {
+                                                hookEventName: 'UserPromptSubmit',
+                                                additionalContext: reminder,
+                                            },
+                                        };
+                                    }
+                                    catch (err) {
+                                        console.error('⚠️ UserPromptSubmit: failed to load turn-shape-reminder.md:', err instanceof Error ? err.message : err);
+                                        return { hookSpecificOutput: { hookEventName: 'UserPromptSubmit' } };
+                                    }
+                                }]
                         }]
                 },
                 // Named sub-agents — Haiku overseer delegates to these specialists.
@@ -1076,12 +1109,12 @@ class ClaudeLLMStream extends llm.LLMStream {
                                 if (this.#opts.skipTTSQueue) {
                                     // Direct mode: emit event for session.say() — bypasses LiveKit's
                                     // BufferedTokenStream which causes stuck/delayed/out-of-order audio
-                                    console.log(`🔊 TTS say (${ttsChunk.length} chars): "${ttsChunk.substring(0, 60)}..."`);
+                                    console.log(`🔊 TTS say (${ttsChunk.length} chars): "${ttsChunk}"`);
                                     this.#eventEmitter.emit('tts_say', { text: ttsChunk });
                                 }
                                 else {
                                     // Realtime mode: use LLM stream queue (framework handles TTS)
-                                    console.log(`🔊 TTS stream (${ttsChunk.length} chars): "${ttsChunk.substring(0, 60)}..."`);
+                                    console.log(`🔊 TTS stream (${ttsChunk.length} chars): "${ttsChunk}"`);
                                     this.queue.put({
                                         id: requestId,
                                         delta: { role: 'assistant', content: ttsChunk },
@@ -1101,11 +1134,11 @@ class ClaudeLLMStream extends llm.LLMStream {
                         const ttsText = stripMarkdownForTTS(rawResult);
                         if (ttsText.trim()) {
                             if (this.#opts.skipTTSQueue) {
-                                console.log(`🔊 TTS say result (${ttsText.length} chars): "${ttsText.substring(0, 60)}..."`);
+                                console.log(`🔊 TTS say result (${ttsText.length} chars): "${ttsText}"`);
                                 this.#eventEmitter.emit('tts_say', { text: ttsText });
                             }
                             else {
-                                console.log(`🔊 TTS result (${ttsText.length} chars): "${ttsText.substring(0, 60)}..."`);
+                                console.log(`🔊 TTS result (${ttsText.length} chars): "${ttsText}"`);
                                 this.queue.put({
                                     id: requestId,
                                     delta: { role: 'assistant', content: ttsText },

package/dist/codex-llm.js

@@ -97,7 +97,7 @@ class CodexLLMStream extends llm.LLMStream {
                 });
                 return;
             }
-            console.log(`🎤 User: "${userText.substring(0, 100)}${userText.length > 100 ? '...' : ''}"`);
+            console.log(`🎤 User (${userText.length} chars): "${userText}"`);
             // Create or reuse thread
             if (!this.#thread) {
                 console.log('🆕 Starting new Codex thread');

package/dist/config.js

@@ -37,8 +37,13 @@ export const MCP_CATALOG = [
     },
 ];
 // Default config template
+// Note: workingDirectory is intentionally OMITTED here. Baking process.cwd() into the
+// default config at module-load time freezes whatever directory osborn happened to be
+// invoked from on first boot — which on cloud sandboxes can be the npm install dir
+// (`/usr/local/nvm/.../osborn`) and gets persisted to ~/.osborn/config.yaml forever.
+// Leaving it undefined lets the runtime self-heal in index.ts resolve it on every boot
+// from OSBORN_CWD → process.cwd() at the actual time the agent starts.
 const DEFAULT_CONFIG = {
-    workingDirectory: process.cwd(),
     defaultProvider: 'gemini',
     defaultCodingAgent: 'claude',
     // Voice mode: 'direct' (Claude Agent SDK) or 'realtime' (OpenAI/Gemini native)
@@ -504,36 +509,83 @@ export function sessionExists(sessionId, projectPath) {
     return existsSync(sessionFile);
 }
 /**
- * Reverse a project slug back to a path (best-effort — replace leading dash, then dashes→slashes).
- * "-Users-foo-bar" → "/Users/foo/bar"
+ * Reverse a project slug back to a path — LAST-RESORT fallback only.
+ *
+ * Claude's slug encoding (`/` → `-`, `.` → `-`) is LOSSY: you can't tell from a
+ * slug whether a given `-` was originally `/`, `.`, or a literal `-` inside a
+ * directory name like `pensive-bohr`. So this function cannot reliably
+ * round-trip an arbitrary path.
+ *
+ * Strategy: produce the naive guess (with a small `--` → `/.` improvement for
+ * dot-directories like `.claude`), then VALIDATE it with `existsSync`. If the
+ * guess doesn't exist, return empty string — that way the caller knows the
+ * reverse failed and can fall back cleanly instead of passing a broken path
+ * to `child_process.spawn` and crashing with ENOENT.
+ *
+ * The primary source of cwd is `extractCwd()` which reads the actual cwd from
+ * the JSONL file. This function is only reached when that fails.
  */
 function slugToPath(slug) {
-    return slug.replace(/^-/, '/').replace(/-/g, '/');
+    // Naive reverse: leading `-` → `/`, `--` → `/.`, remaining `-` → `/`.
+    // The `--` → `/.` pass handles dot-prefixed directories like `.claude`.
+    const guess = slug
+        .replace(/^-/, '/')
+        .replace(/--/g, '/.')
+        .replace(/-/g, '/');
+    // Validate — lossy encoding means we cannot trust the guess.
+    return existsSync(guess) ? guess : '';
 }
 const UUID_JSONL_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.jsonl$/i;
 /**
- * Extract cwd from first user message in a JSONL file.
- * Reuses the existing readline-based parsing pattern.
+ * Extract cwd from the first JSONL entry that carries a `cwd` field.
+ *
+ * Previously: read only the first 8KB and only accepted `type === 'user'`. That
+ * broke for sessions whose first JSONL entry was larger than 8KB — e.g. a
+ * `queue-operation` containing pasted email/page text. readline never emits the
+ * `line` event for an incomplete final chunk, so the scan finds nothing,
+ * `listAllClaudeSessions` falls through to the lossy `slugToPath` reverse, and
+ * the mangled path ends up as a `cwd` passed to `child_process.spawn`, producing
+ * the misleading "Claude Code executable not found" error (see MEMORY bug #11).
+ *
+ * Now: stream line-by-line with no byte cap, short-circuit on the first entry
+ * with a `cwd` field regardless of `type` (every `user` / `attachment` /
+ * `assistant` / `system` entry in a Claude JSONL session carries `cwd`, so the
+ * scan finishes in the first few KB of any normal session).
  */
 async function extractCwd(filePath) {
     return new Promise((resolve) => {
-        const fileStream = createReadStream(filePath, { end: 8192 }); // first 8KB
+        const fileStream = createReadStream(filePath);
         const rl = readline.createInterface({ input: fileStream, crlfDelay: Infinity });
+        let resolved = false;
+        const done = (value) => {
+            if (resolved)
+                return;
+            resolved = true;
+            try {
+                rl.close();
+            }
+            catch { }
+            try {
+                fileStream.destroy();
+            }
+            catch { }
+            resolve(value);
+        };
         rl.on('line', (line) => {
+            if (resolved)
+                return;
             if (!line.trim())
                 return;
             try {
                 const obj = JSON.parse(line);
-                if (obj.type === 'user' && obj.cwd) {
-                    rl.close();
-                    fileStream.destroy();
-                    resolve(obj.cwd);
+                if (typeof obj?.cwd === 'string' && obj.cwd.length > 0) {
+                    done(obj.cwd);
                 }
             }
             catch { }
         });
-        rl.on('close', () => resolve(''));
-        rl.on('error', () => resolve(''));
+        rl.on('close', () => done(''));
+        rl.on('error', () => done(''));
     });
 }
 /**

package/dist/index.js

@@ -227,6 +227,47 @@ function startApiServer(workingDir, port) {
             setTimeout(() => process.exit(0), 150);
             return;
         }
+        // GET /events — Server-Sent Events heartbeat for cloud-sandbox keepalive.
+        //
+        // This endpoint is the single thing preventing Sprites' CRIU-based
+        // hibernation from freezing osborn's Node.js event loop and dropping our
+        // LiveKit WebSocket mid-session. Short HTTP pings don't work: Sprites'
+        // warm state serves /health responses from a process snapshot without
+        // actually resuming the event loop, so background timers (including
+        // LiveKit heartbeats) stop firing after a few seconds. That causes the
+        // LiveKit server to drop osborn's participant, delete the room, and
+        // leave any future user joins stuck at "Connecting..." forever.
+        //
+        // An OPEN long-lived TCP connection keeps the sprite in 'running' state.
+        // The frontend opens this endpoint on chat page mount and holds it open
+        // for the entire voice session. While open, osborn's event loop ticks
+        // continuously, LiveKit heartbeats fire, and the room stays alive.
+        //
+        // For local (non-cloud) dev, this endpoint is harmless — it just idles
+        // on a client that may never connect. Zero cost when unused.
+        if (req.method === 'GET' && url.pathname === '/events') {
+            res.writeHead(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive',
+                // Disable proxy buffering (nginx-style) so each ping is flushed
+                // through Sprites' reverse proxy immediately rather than batched.
+                'X-Accel-Buffering': 'no',
+            });
+            res.write(`: sprite-keepalive connected at ${new Date().toISOString()}\n\n`);
+            const heartbeat = setInterval(() => {
+                try {
+                    res.write(`: ping ${Date.now()}\n\n`);
+                }
+                catch { }
+            }, 10_000);
+            req.on('close', () => {
+                clearInterval(heartbeat);
+                console.log('[events] SSE client disconnected');
+            });
+            console.log('[events] SSE client connected');
+            return;
+        }
         res.writeHead(404, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ error: 'Not found' }));
     });
@@ -322,13 +363,33 @@ async function main() {
     //    Always the Osborn agent install directory (where this process started).
     //    This ensures .osborn/sessions/ doesn't scatter across random directories.
     const sessionBaseDir = process.cwd(); // Always the Osborn install dir
-    const defaultWorkingDir = process.env.OSBORN_CWD || config.workingDirectory || process.cwd();
+    // Self-healing fallback: blindly trusting OSBORN_CWD without checking that the directory
+    // exists has bitten us in cloud sandboxes where the env var was set to a path that didn't
+    // exist (e.g. `/root/workspace` on a daytona/* user). The Claude SDK then fails its spawn
+    // call with ENOENT and reports the misleading "Claude Code executable not found" error.
+    // Walk the candidate list in priority order and pick the first one that ACTUALLY exists.
+    // process.cwd() is the ultimate safety net — it always exists by definition.
+    const cwdCandidates = [
+        { source: 'OSBORN_CWD env var', value: process.env.OSBORN_CWD },
+        { source: 'config.workingDirectory', value: config.workingDirectory },
+        { source: 'process.cwd()', value: process.cwd() },
+    ];
+    let defaultWorkingDir = process.cwd();
+    let cwdSource = 'process.cwd() (last-resort fallback)';
+    for (const c of cwdCandidates) {
+        if (c.value && existsSync(c.value)) {
+            defaultWorkingDir = c.value;
+            cwdSource = c.source;
+            break;
+        }
+        if (c.value) {
+            console.log(`   ⚠️ ${c.source} = ${c.value} (does not exist, skipping)`);
+        }
+    }
     let workingDir = defaultWorkingDir;
     console.log(`📂 Working directory (cwd): ${workingDir}`);
     console.log(`📂 Session base directory: ${sessionBaseDir}`);
-    if (process.env.OSBORN_CWD) {
-        console.log(`   (cwd from OSBORN_CWD env var)`);
-    }
+    console.log(`   (cwd from ${cwdSource})`);
     console.log(`🔬 Mode: RESEARCH`);
     // Determine voice mode
     const voiceMode = getVoiceMode(config);
@@ -386,6 +447,43 @@ async function main() {
     let currentSession = null;
     let currentAgent = null; // For updateChatCtx() context injection
     let currentLLM = null;
+    /**
+     * Hard-kill the in-flight Claude SDK query AND the persistent subprocess.
+     *
+     * Why this exists: the persistent ClaudeLLM session is deliberately kept alive
+     * across user messages to avoid JSONL replay (see CLAUDE.md "Persistent Session
+     * Architecture"). When the participant disconnects, simply nulling `currentLLM`
+     * drops the JS reference but does NOT kill the underlying Claude Code subprocess
+     * — the SDK keeps draining the MessageChannel, running tools, and pushing TTS
+     * calls into a now-null voice session. Visible in logs as repeated:
+     *   "⚠️ tts_say fired but currentSession is null — text dropped"
+     * followed by orphaned `🔧 Claude: Bash` calls and `📍 Checkpoint captured` lines
+     * that nobody is listening to. Wasted compute, wasted tokens, possible side effects.
+     *
+     * The right cleanup is `abortQuery()` (on ClaudeLLM directly) or `abortAgent()`
+     * (on PipelineDirectLLM, which wraps ClaudeLLM). They both call into
+     * `closeSession()` → kills the subprocess. We duck-type to handle both class
+     * shapes since `currentLLM` can hold either, depending on voice mode.
+     */
+    function killCurrentLLM(reason) {
+        if (!currentLLM)
+            return;
+        try {
+            const llm = currentLLM;
+            if (typeof llm.abortQuery === 'function') {
+                llm.abortQuery();
+            }
+            else if (typeof llm.abortAgent === 'function') {
+                llm.abortAgent();
+            }
+            else {
+                console.warn(`⚠️ killCurrentLLM(${reason}): no abort method on currentLLM`);
+            }
+        }
+        catch (err) {
+            console.error(`❌ killCurrentLLM(${reason}) failed:`, err instanceof Error ? err.message : err);
+        }
+    }
     let localParticipant = null;
     let agentState = 'initializing';
     // Session-level always-allow list: paths the user has approved for this session without prompting
@@ -459,7 +557,7 @@ async function main() {
         // fullText is what was being spoken when interrupted (passed from tts_say handler).
         // No word-level cutoff for say() — only generateReply pipeline has that — but Claude
         // knows its own output from JSONL, so the full block is enough context.
-        console.log(`🔇 Speech interrupted. Was speaking: "${fullText.substring(0, 80)}..."`);
+        console.log(`🔇 Speech interrupted. Was speaking (${fullText.length} chars): "${fullText}"`);
         // Read last 10 assistant messages from JSONL (Claude's full untruncated output).
         // SessionMessage.text is pre-joined from all text content blocks.
         let recentMessages = '';
@@ -835,7 +933,7 @@ async function main() {
         });
         // Wire up Claude text output - RAW text goes to frontend for chat bubbles
         directLLM.events.on('assistant_text', (data) => {
-            console.log(`💬 Claude text: ${data.text?.substring(0, 60)}...`);
+            console.log(`💬 Claude text (${data.text?.length || 0} chars): ${data.text || ''}`);
             sendToFrontend({
                 type: 'claude_output',
                 text: data.text,
@@ -845,7 +943,7 @@ async function main() {
         });
         // Wire up Claude final result - RAW result goes to frontend
         directLLM.events.on('assistant_result', (data) => {
-            console.log(`📋 Claude result: ${data.text?.substring(0, 60)}...`);
+            console.log(`📋 Claude result (${data.text?.length || 0} chars): ${data.text || ''}`);
             sendToFrontend({
                 type: 'claude_output',
                 text: data.text,
@@ -963,7 +1061,7 @@ async function main() {
         directLLM.events.on('tts_say', (data) => {
             // Guard: session must be alive — TTS errors can kill the session while background query runs
             if (!currentSession) {
-                console.warn(`⚠️ tts_say fired but currentSession is null — text dropped: "${data.text?.substring(0, 60)}"`);
+                console.warn(`⚠️ tts_say fired but currentSession is null — text dropped (${data.text?.length || 0} chars): "${data.text || ''}"`);
                 return;
             }
             if (!data.text?.trim()) {
@@ -971,7 +1069,7 @@ async function main() {
                 return;
             }
             const sayId = Date.now(); // simple ID to correlate start/end logs
-            console.log(`🗣️ [${sayId}] session.say START (${data.text.length} chars): "${data.text.substring(0, 60)}..."`);
+            console.log(`🗣️ [${sayId}] session.say START (${data.text.length} chars): "${data.text}"`);
             try {
                 const handle = currentSession.say(data.text);
                 if (handle && typeof handle.addDoneCallback === 'function') {
@@ -1099,7 +1197,7 @@ async function main() {
             }
         });
         realtimeClaudeHandler.events.on('assistant_result', (data) => {
-            console.log(`📋 Claude result: ${data.text?.substring(0, 60)}...`);
+            console.log(`📋 Claude result (${data.text?.length || 0} chars): ${data.text || ''}`);
             sendToFrontend({
                 type: 'claude_output',
                 text: data.text,
@@ -1591,6 +1689,9 @@ async function main() {
         lastCompletedResearch = null;
         currentSession = null;
         currentAgent = null;
+        // Same disconnect-leak fix as the other two cleanup sites — kill the Claude SDK
+        // subprocess BEFORE dropping the reference. See killCurrentLLM() for full context.
+        killCurrentLLM('disconnected_cleanup');
         currentLLM = null;
         clearFastBrainSession();
         clearPipelineFastBrainSession();
@@ -1633,6 +1734,9 @@ async function main() {
             catch { }
             currentSession = null;
             currentAgent = null;
+            // Same disconnect-leak fix — kill the previous user's Claude subprocess
+            // before binding currentLLM to the new user's session below.
+            killCurrentLLM('previous_session_cleanup');
             currentLLM = null;
         }
         // Extract voice architecture, provider, and sessionId from participant metadata (sent by frontend)
@@ -1660,10 +1764,26 @@ async function main() {
                 preSelectedSessionId = metadata.sessionId;
                 console.log(`📂 Pre-selected session from frontend: ${preSelectedSessionId}`);
             }
-            // Read working directory override from frontend
+            // Read working directory override from frontend.
+            //
+            // Must validate with existsSync before accepting: a broken reverse-slug in
+            // the frontend's session list (see `slugToPath` in config.ts — the encoding
+            // is lossy), a deleted project, or a bad legacy client can all produce a
+            // non-existent path here. Passing a non-existent cwd to
+            // `child_process.spawn` in the Claude SDK errors with ENOENT, which the
+            // SDK then reports as the misleading "Claude Code executable not found at
+            // .../cli.js" error (see MEMORY bug fix #11). Fall back to defaultWorkingDir
+            // (which is itself existsSync-verified at startup).
             if (metadata.workingDirectory && typeof metadata.workingDirectory === 'string' && metadata.workingDirectory.length > 0) {
-                workingDir = metadata.workingDirectory;
-                console.log(`📂 Working directory from frontend: ${workingDir}`);
+                if (existsSync(metadata.workingDirectory)) {
+                    workingDir = metadata.workingDirectory;
+                    console.log(`📂 Working directory from frontend: ${workingDir}`);
+                }
+                else {
+                    console.log(`⚠️  Frontend sent workingDirectory that does not exist: ${metadata.workingDirectory}`);
+                    console.log(`   Falling back to default: ${defaultWorkingDir}`);
+                    workingDir = defaultWorkingDir;
+                }
             }
             else {
                 // Reset to default for new connections (in case previous session changed it)
@@ -1785,7 +1905,7 @@ async function main() {
                 // (Gemini v1.0.51: userInput in generateReply creates a user conversation item)
                 if (normalized.startsWith('[SCRIPT]') || normalized.startsWith('[PROACTIVE]') || normalized.startsWith('[NOTIFICATION]'))
                     return;
-                console.log(`📝 User (${source}): "${transcript.substring(0, 60)}..."`);
+                console.log(`📝 User (${source}, ${transcript.length} chars): "${transcript}"`);
                 sendToFrontend({ type: 'user_transcript', text: transcript });
                 lastSentUserTranscript = normalized;
             }
@@ -1795,7 +1915,7 @@ async function main() {
                 const normalized = text.trim().replace(/\s+/g, ' ');
                 if (normalized === lastSentAgentTranscript)
                     return;
-                console.log(`💬 Agent (${source}): "${text.substring(0, 60)}..."`);
+                console.log(`💬 Agent (${source}, ${text.length} chars): "${text}"`);
                 sendToFrontend({ type: 'assistant_response', text });
                 lastSentAgentTranscript = normalized;
             }
@@ -2253,6 +2373,9 @@ async function main() {
             })();
         }
         currentAgent = null;
+        // Kill the Claude SDK subprocess BEFORE dropping the reference, otherwise the
+        // persistent session keeps running tools and pushing TTS into a dead session.
+        killCurrentLLM('participant_disconnected');
         currentLLM = null;
         clearFastBrainSession();
         clearPipelineFastBrainSession();
@@ -2298,10 +2421,10 @@ async function main() {
                             fullContent += `\n\n[Image attached: ${f.name}]`;
                         }
                     }
-                    console.log(`📝 Text + ${files.length} file(s): "${fullContent.substring(0, 100)}"`);
+                    console.log(`📝 Text + ${files.length} file(s) (${fullContent.length} chars): "${fullContent}"`);
                 }
                 else {
-                    console.log(`📝 Text: "${fullContent.substring(0, 100)}"`);
+                    console.log(`📝 Text (${fullContent.length} chars): "${fullContent}"`);
                 }
                 // Skip interrupt for Gemini — disrupts state machine (hangs in speaking state)
                 if (currentProvider !== 'gemini') {

package/dist/pipeline-direct-llm.js

@@ -82,7 +82,7 @@ export class PipelineDirectLLM extends llm.LLM {
                 break;
             }
         }
-        console.log(`📥 [pipeline] chat() call #${callN}: "${userText.substring(0, 60)}"`);
+        console.log(`📥 [pipeline] chat() call #${callN} (${userText.length} chars): "${userText}"`);
         // Check for pending interruption context — enrich user message if interrupted
         const interruptCtx = this.#opts.getAndConsumeInterruptionContext?.();
         if (interruptCtx && userText.trim()) {