osborn 0.9.189 → 0.9.191

package/dist/claude-llm.js

@@ -62,6 +62,11 @@ function stripMarkdownForTTS(text) {
         .replace(/  +/g, ' ')
         .trim();
 }
+function getSubagentsDir(workingDir) {
+    const dir = join(workingDir, 'subagents');
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
 /**
  * Load skill files from agent/.claude/skills/{name}/SKILL.md
  * Injects into system prompt so Claude sees them as available capabilities.
@@ -1332,7 +1337,7 @@ export class ClaudeLLM extends llm.LLM {
             // agents roster prevents any SubagentStop(agent_type==='writer') from
             // firing inside this one-shot query and re-arming the backstop loop.
             const reviewerOptions = {
-                cwd: this.#opts.workingDirectory,
+                cwd: getSubagentsDir(this.#opts.workingDirectory),
                 permissionMode: 'default',
                 systemPrompt: NAMED_AGENTS.reviewer.prompt,
                 allowedTools: ['Read', 'Glob', 'Grep', 'Bash', 'Write', 'Edit'],
@@ -1441,7 +1446,7 @@ export class ClaudeLLM extends llm.LLM {
                 gitDiff,
             ].join('\n');
             const testerOptions = {
-                cwd: this.#opts.workingDirectory,
+                cwd: getSubagentsDir(this.#opts.workingDirectory),
                 permissionMode: 'default',
                 systemPrompt: NAMED_AGENTS.tester.prompt,
                 allowedTools: ['Read', 'Glob', 'Grep', 'Bash', 'Write', 'Edit'],
@@ -1528,7 +1533,7 @@ export class ClaudeLLM extends llm.LLM {
             // an agents roster would allow delegation back to the writer, which would
             // fire SubagentStop(agent_type==='writer') and re-arm the backstop.
             const gateOptions = {
-                cwd: this.#opts.workingDirectory,
+                cwd: getSubagentsDir(this.#opts.workingDirectory),
                 permissionMode: 'default',
                 systemPrompt: NAMED_AGENTS.reasoner.prompt,
                 hooks: {

package/dist/config.d.ts

@@ -146,7 +146,7 @@ export declare function invalidateSessionListCache(): void;
  *
  * @param limit - Max sessions to return (default 100, sorted by recency)
  */
-export declare function listAllClaudeSessions(limit?: number): Promise<ClaudeSessionEntry[]>;
+export declare function listAllClaudeSessions(limit?: number, includeSubagents?: boolean): Promise<ClaudeSessionEntry[]>;
 /**
  * Session summary for context briefing when switching sessions
  */

package/dist/config.js

@@ -555,15 +555,23 @@ export function invalidateSessionListCache() {
  *
  * @param limit - Max sessions to return (default 100, sorted by recency)
  */
-export async function listAllClaudeSessions(limit = 1000) {
+export async function listAllClaudeSessions(limit = 1000, includeSubagents = false) {
     if (_sessionListCache && Date.now() < _sessionListCache.expiresAt) {
-        return _sessionListCache.data.slice(0, limit);
+        const cached = includeSubagents
+            ? _sessionListCache.data
+            : _sessionListCache.data.filter(s => !s.projectSlug.endsWith('-subagents'));
+        return cached.slice(0, limit);
     }
     const projectsDir = getClaudeProjectsDir();
     if (!existsSync(projectsDir))
         return [];
-    // 1. Discover all project folders
+    // 1. Discover all project folders — skip subagent slugs unless explicitly requested.
+    //    Subagent sessions live in {workingDir}/subagents, which slugifies to a folder
+    //    ending in "-subagents". Filtering here keeps the session limit budget for
+    //    real user sessions and prevents subagent noise from crowding out other projects.
     const projectFolders = readdirSync(projectsDir).filter(name => {
+        if (!includeSubagents && name.endsWith('-subagents'))
+            return false;
         const fullPath = join(projectsDir, name);
         try {
             return statSync(fullPath).isDirectory();

package/dist/index.js

@@ -29,7 +29,7 @@ import { createGunzip } from 'node:zlib';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 import { createPatch } from 'diff';
-import { loadConfig, getMcpServers, getEnabledMcpServerNames, getVoiceMode, getDirectConfig, listAllClaudeSessions, invalidateSessionListCache, getMostRecentSessionId, sessionExists, getSessionSummary, getConversationHistory, ensureSessionWorkspace, getMcpServerStatusList, buildMcpServersForKeys, listWorkspaceArtifacts } from './config.js';
+import { loadConfig, getMcpServers, getEnabledMcpServerNames, getVoiceMode, getDirectConfig, listSessions, listAllClaudeSessions, invalidateSessionListCache, getMostRecentSessionId, sessionExists, getSessionSummary, getConversationHistory, ensureSessionWorkspace, getMcpServerStatusList, buildMcpServersForKeys, listWorkspaceArtifacts } from './config.js';
 import { createSTT, createTTS, DIRECT_MODE_STT, DIRECT_MODE_TTS } from './voice-io.js';
 import { createClaudeLLM, NAMED_AGENTS, applyTurbo } from './claude-llm.js';
 import { clearPipelineFastBrainSession, prewarmBM25Index } from './pipeline-fastbrain.js';
@@ -3603,9 +3603,19 @@ async function main() {
         // discardAudioIfUninterruptible: true, ttsReadIdleTimeout: 10000,
         // maxUnrecoverableErrors: 3) are what was silently running via caret-resolved
         // 1.4.5 throughout the user's working month. Restoring them.
-        const turnDetector = process.env.LIVEKIT_REMOTE_EOT_URL ? new CloudTurnDetector() : undefined;
+        // STT endpointing is the default (nova-3, 25ms silence-based VAD — reliable, fast).
+        // CloudTurnDetector (ML semantic EOT) is used ONLY if LIVEKIT_REMOTE_EOT_URL is set
+        // AND the endpoint passes a startup probe (returns valid JSON probability).
+        // If the probe fails (wrong URL, no auth, non-JSON response), STT is kept.
+        let turnDetection = 'stt';
+        if (process.env.LIVEKIT_REMOTE_EOT_URL) {
+            const detector = new CloudTurnDetector();
+            const eotLive = await detector.probe();
+            if (eotLive)
+                turnDetection = detector;
+        }
         const session = new voice.AgentSession({
-            turnDetection: (turnDetector ?? 'stt'),
+            turnDetection,
             preemptiveGeneration: false, // Only fire LLM on final committed transcript, not partial preemptives
             // Commented out — kept for reference. These were added across 0.9.60/0.9.61
             // to try to harden interrupt + TTS handling, but evidence (osbornojure
@@ -4553,11 +4563,32 @@ async function main() {
             console.log('💓 Sending agent_ready signal...');
             let readySent = false;
             // (realtime provider removed)
-            // Session list state — populated async so it doesn't block the first sendReady
+            // Session list state — populated in two tiers (fast then full)
             let sessionsForFrontend = [];
             let recentSessionId = null;
             let hasRecentSession = false;
             let sessionsLoaded = false;
+            // Tier 1: fast scan — current project only, ~5ms
+            // Gives the frontend enough to show "Resume last session?" immediately.
+            try {
+                const recentSessions = await listSessions(workingDir);
+                if (recentSessions.length > 0) {
+                    const top = recentSessions[0];
+                    recentSessionId = top.sessionId;
+                    hasRecentSession = true;
+                    sessionsForFrontend = [{
+                            sessionId: top.sessionId,
+                            projectSlug: top.projectPath,
+                            projectPath: top.projectPath,
+                            cwd: top.projectPath,
+                            timestamp: top.timestamp.toISOString(),
+                            lastMessage: top.lastMessage,
+                            messageCount: top.messageCount,
+                            fileSize: 0,
+                        }];
+                }
+            }
+            catch { }
             const sendReady = async () => {
                 if (readySent)
                     return;
@@ -4580,13 +4611,13 @@ async function main() {
                 });
             };
             const readyInterval = setInterval(sendReady, 2000);
-            // Fire immediately (sessionsLoaded:false) so the frontend unblocks right away
+            // Fire immediately with the fast-scanned recent session (sessionsLoaded still false)
             await sendReady();
             setTimeout(() => {
                 clearInterval(readyInterval);
                 console.log('✅ agent_ready retries complete');
             }, 20000);
-            // Load session list in background — re-send agent_ready once populated
+            // Tier 2: full cross-project scan in background — no blocking
             listAllClaudeSessions().then(allSessions => {
                 recentSessionId = allSessions.length > 0 ? allSessions[0].sessionId : null;
                 hasRecentSession = allSessions.length > 0;

package/dist/turn-detector-shim.d.ts

@@ -5,14 +5,14 @@
  * because it calls getJobContext(). This shim implements the same _TurnDetector
  * interface but makes the remote HTTP call directly — no worker framework needed.
  *
+ * Auth: LiveKit Cloud inference requires a signed JWT (same format as room access
+ * tokens). We cache the token and refresh it before expiry so we're not signing
+ * on every turn.
+ *
  * On LiveKit Cloud (LIVEKIT_REMOTE_EOT_URL set): HTTP call to inference gateway.
  * Without the URL: Returns 1.0 (always end of turn — STT endpointing handles it).
  */
 import type { llm } from '@livekit/agents';
-/**
- * Implements _TurnDetector interface for LiveKit Cloud remote inference
- * without requiring JobContext / worker framework.
- */
 export declare class CloudTurnDetector {
     #private;
     readonly model = "lk_end_of_utterance_multilingual";
@@ -20,5 +20,11 @@ export declare class CloudTurnDetector {
     constructor();
     unlikelyThreshold(_language?: string): Promise<number | undefined>;
     supportsLanguage(_language?: string): Promise<boolean>;
+    /**
+     * Startup probe — send a minimal request to confirm the endpoint returns
+     * valid JSON probability. Returns true if the EOT service is live and real.
+     * Called once at session init; if false, index.ts falls back to 'stt'.
+     */
+    probe(): Promise<boolean>;
     predictEndOfTurn(chatCtx: llm.ChatContext, _timeout?: number): Promise<number>;
 }

package/dist/turn-detector-shim.js

@@ -5,19 +5,24 @@
  * because it calls getJobContext(). This shim implements the same _TurnDetector
  * interface but makes the remote HTTP call directly — no worker framework needed.
  *
+ * Auth: LiveKit Cloud inference requires a signed JWT (same format as room access
+ * tokens). We cache the token and refresh it before expiry so we're not signing
+ * on every turn.
+ *
  * On LiveKit Cloud (LIVEKIT_REMOTE_EOT_URL set): HTTP call to inference gateway.
  * Without the URL: Returns 1.0 (always end of turn — STT endpointing handles it).
  */
 import { log } from '@livekit/agents';
+import { AccessToken } from 'livekit-server-sdk';
 const REMOTE_INFERENCE_TIMEOUT = 2000;
 const MAX_HISTORY_TURNS = 15;
-/**
- * Implements _TurnDetector interface for LiveKit Cloud remote inference
- * without requiring JobContext / worker framework.
- */
+const TOKEN_TTL_SECONDS = 600; // 10-minute JWT
+const TOKEN_REFRESH_BUFFER = 60; // refresh 60s before expiry
 export class CloudTurnDetector {
     #remoteUrl;
     #logger = log();
+    #cachedToken;
+    #tokenExpiresAt = 0;
     model = 'lk_end_of_utterance_multilingual';
     provider = 'livekit';
     constructor() {
@@ -30,18 +35,78 @@ export class CloudTurnDetector {
             console.log(`🧠 Turn detector: LiveKit Cloud remote inference (${this.#remoteUrl})`);
         }
         else {
-            console.log('🧠 Turn detector: No LIVEKIT_REMOTE_EOT_URL — STT endpointing fallback');
+            console.log('🧠 Turn detector: No LIVEKIT_REMOTE_EOT_URL — STT endpointing only');
+        }
+    }
+    async #getAuthToken() {
+        const apiKey = process.env.LIVEKIT_API_KEY;
+        const apiSecret = process.env.LIVEKIT_API_SECRET;
+        if (!apiKey || !apiSecret)
+            return undefined;
+        const nowSec = Math.floor(Date.now() / 1000);
+        if (this.#cachedToken && nowSec < this.#tokenExpiresAt - TOKEN_REFRESH_BUFFER) {
+            return this.#cachedToken;
         }
+        // Sign a fresh token — identity is the agent, no room grants needed for inference
+        const at = new AccessToken(apiKey, apiSecret, {
+            identity: 'osborn-eot-agent',
+            ttl: `${TOKEN_TTL_SECONDS}s`,
+        });
+        this.#cachedToken = await at.toJwt();
+        this.#tokenExpiresAt = nowSec + TOKEN_TTL_SECONDS;
+        return this.#cachedToken;
     }
     async unlikelyThreshold(_language) {
-        return undefined; // Let the framework use defaults
+        return undefined;
     }
     async supportsLanguage(_language) {
-        return true; // Multilingual model supports all languages
+        return true;
+    }
+    /**
+     * Startup probe — send a minimal request to confirm the endpoint returns
+     * valid JSON probability. Returns true if the EOT service is live and real.
+     * Called once at session init; if false, index.ts falls back to 'stt'.
+     */
+    async probe() {
+        if (!this.#remoteUrl)
+            return false;
+        try {
+            const token = await this.#getAuthToken();
+            const headers = { 'Content-Type': 'application/json' };
+            if (token)
+                headers['Authorization'] = `Bearer ${token}`;
+            const resp = await fetch(`${this.#remoteUrl}/eot/multi`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    messages: [{ role: 'user', content: 'test' }],
+                    jobId: 'osborn-probe',
+                    workerId: 'osborn-direct',
+                }),
+                headers,
+                signal: AbortSignal.timeout(3000),
+            });
+            if (!resp.ok)
+                return false;
+            const text = await resp.text();
+            try {
+                const data = JSON.parse(text);
+                const ok = typeof data.probability === 'number';
+                console.log(`🧠 EOT probe: ${ok ? '✅ live' : '❌ non-JSON ("' + text.slice(0, 30) + '")'} — ${ok ? 'using CloudTurnDetector' : 'falling back to STT'}`);
+                return ok;
+            }
+            catch {
+                console.log(`🧠 EOT probe: ❌ non-JSON response ("${text.slice(0, 40)}") — falling back to STT endpointing`);
+                return false;
+            }
+        }
+        catch (err) {
+            console.log(`🧠 EOT probe: ❌ unreachable — ${err instanceof Error ? err.message : err} — falling back to STT`);
+            return false;
+        }
     }
     async predictEndOfTurn(chatCtx, _timeout) {
         if (!this.#remoteUrl) {
-            return 1.0; // No remote URL = always end of turn (STT handles it)
+            return 1.0;
         }
         try {
             const messages = chatCtx
@@ -57,31 +122,41 @@ export class CloudTurnDetector {
                     excludeAudio: true,
                     excludeTimestamp: true,
                 }),
-                // Dummy IDs — LiveKit Cloud uses these for routing/logging, not auth
                 jobId: `osborn-${Date.now()}`,
                 workerId: 'osborn-direct',
             };
             const agentId = process.env.LIVEKIT_AGENT_ID;
-            if (agentId) {
+            if (agentId)
                 request.agentId = agentId;
-            }
+            const token = await this.#getAuthToken();
+            const headers = { 'Content-Type': 'application/json' };
+            if (token)
+                headers['Authorization'] = `Bearer ${token}`;
             const resp = await fetch(`${this.#remoteUrl}/eot/multi`, {
                 method: 'POST',
                 body: JSON.stringify(request),
-                headers: { 'Content-Type': 'application/json' },
+                headers,
                 signal: AbortSignal.timeout(REMOTE_INFERENCE_TIMEOUT),
             });
             if (!resp.ok) {
-                return 1.0; // Failed — default to end of turn
+                this.#logger.warn(`EOT inference returned ${resp.status} — falling back to STT`);
+                return 1.0;
             }
-            const data = (await resp.json());
-            if (typeof data.probability === 'number' && data.probability >= 0) {
-                return data.probability;
+            const text = await resp.text();
+            try {
+                const data = JSON.parse(text);
+                if (typeof data.probability === 'number' && data.probability >= 0) {
+                    return data.probability;
+                }
+            }
+            catch {
+                // Non-JSON response (e.g. "OK") — log once then fall through
+                this.#logger.warn(`EOT inference returned non-JSON: "${text.slice(0, 40)}" — auth may be wrong`);
             }
             return 1.0;
         }
         catch {
-            return 1.0; // Timeout/error — default to end of turn
+            return 1.0;
         }
     }
 }

package/package.json

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