osborn 0.9.238 → 0.9.240

package/dist/claude-auth.d.ts

@@ -63,6 +63,21 @@ export declare function runClaudeAuthFlow(callbacks: ClaudeAuthCallbacks): {
     handle: ClaudeAuthHandle;
     done: Promise<void>;
 };
+/**
+ * Re-deliver the current in-flight auth prompt to a frontend that has just
+ * (re)subscribed. WHY THIS EXISTS: ensureClaudeAuth runs inside the
+ * ParticipantConnected ("User joined") handler and publishes claude_auth_*
+ * over the LiveKit reliable data channel — but that fires ~5-6s BEFORE the
+ * browser's data channel actually finishes subscribing (observed: auth_url at
+ * :01, TrackSubscribed at :07). LiveKit reliable data is NOT buffered for a
+ * peer that hasn't subscribed yet, so a no-auth user's one-shot "Connect
+ * Claude" prompt is published to nobody and the modal never appears. Calling
+ * this on TrackSubscribed (data channel confirmed up) re-delivers the exact
+ * cached state. No-op (returns false) when no flow is in-flight — i.e. the
+ * user is already authenticated — so it costs nothing on the common path.
+ * Idempotent on the frontend (re-setting the same auth status is harmless).
+ */
+export declare function replayInFlightAuth(send: (type: string, payload: unknown) => void): boolean;
 /**
  * Ensure Claude is authenticated before proceeding.
  *

package/dist/claude-auth.js

@@ -485,6 +485,36 @@ export function runClaudeAuthFlow(callbacks) {
     return { handle, done };
 }
 let inFlightAuth = null;
+/**
+ * Re-deliver the current in-flight auth prompt to a frontend that has just
+ * (re)subscribed. WHY THIS EXISTS: ensureClaudeAuth runs inside the
+ * ParticipantConnected ("User joined") handler and publishes claude_auth_*
+ * over the LiveKit reliable data channel — but that fires ~5-6s BEFORE the
+ * browser's data channel actually finishes subscribing (observed: auth_url at
+ * :01, TrackSubscribed at :07). LiveKit reliable data is NOT buffered for a
+ * peer that hasn't subscribed yet, so a no-auth user's one-shot "Connect
+ * Claude" prompt is published to nobody and the modal never appears. Calling
+ * this on TrackSubscribed (data channel confirmed up) re-delivers the exact
+ * cached state. No-op (returns false) when no flow is in-flight — i.e. the
+ * user is already authenticated — so it costs nothing on the common path.
+ * Idempotent on the frontend (re-setting the same auth status is harmless).
+ */
+export function replayInFlightAuth(send) {
+    if (!inFlightAuth)
+        return false;
+    send('claude_auth_required', {
+        message: 'Claude authentication required. A login URL will appear shortly.',
+    });
+    if (inFlightAuth.lastUrl) {
+        send('claude_auth_url', { url: inFlightAuth.lastUrl });
+    }
+    if (inFlightAuth.lastStatus === 'waiting_code') {
+        send('claude_auth_waiting_code', {
+            message: 'Paste the authentication code from the browser.',
+        });
+    }
+    return true;
+}
 /**
  * Ensure Claude is authenticated before proceeding.
  *

package/dist/claude-llm.d.ts

@@ -120,6 +120,7 @@ export declare function decideWrite(agentType: string | null, filePath: string):
     decision: 'allow' | 'defer' | 'deny';
     reason?: string;
 };
+export declare const SILENT_VERIFY_PREFIX: string;
 export declare const VERIFIER_CHAIN: Record<string, {
     parallelAtStart?: string[];
     afterReminder?: string;
@@ -278,6 +279,13 @@ export declare class ClaudeLLM extends llm.LLM {
     stopAgent(agentId: string): boolean;
     /** Whether a persistent session is alive and consuming messages */
     hasSession(): boolean;
+    /**
+     * Verifier-chain dedup: records that agent_id has triggered its chain dispatch and returns
+     * true only the FIRST time (so a double-fired SubagentStop can't double-dispatch). A NEW
+     * agent_id (e.g. a fresh writer spawned for a fix round) is not in the set → returns true,
+     * correctly allowing the re-verify loop. Cleared when the persistent session closes.
+     */
+    markChainDispatched(agentId: string): boolean;
     /**
      * Close the persistent session (kills subprocess).
      * Call on disconnect, session switch, or recovery.

package/dist/claude-llm.js

@@ -919,6 +919,11 @@ export function decideWrite(agentType, filePath) {
 //     when the keyed sub-agent's Task completes, so the main agent dispatches the
 //     next verifier(s) as real Tasks (verdicts return inline). Includes RUNNING the
 //     tester's tests against the finished code. Any agent not listed chains to nothing.
+// Prepended to a verifier-chain reminder pushed into the MAIN agent at SubagentStop. Keeps the
+// dispatch SILENT — the model should emit ONLY the Task tool call(s), no spoken/streamed text —
+// so the chain advances without a robotic "now running the review…" narration on the voice path.
+export const SILENT_VERIFY_PREFIX = '[SYSTEM — SILENT CONTROL MESSAGE. Do NOT narrate, speak, or emit any assistant text this turn. ' +
+    'Silently perform the following via the Task tool only.] ';
 export const VERIFIER_CHAIN = {
     writer: {
         parallelAtStart: ['tester'],
@@ -1480,6 +1485,18 @@ export class ClaudeLLM extends llm.LLM {
     hasSession() {
         return this.#persistentQuery !== null && !this.#messageChannel?.closed;
     }
+    /**
+     * Verifier-chain dedup: records that agent_id has triggered its chain dispatch and returns
+     * true only the FIRST time (so a double-fired SubagentStop can't double-dispatch). A NEW
+     * agent_id (e.g. a fresh writer spawned for a fix round) is not in the set → returns true,
+     * correctly allowing the re-verify loop. Cleared when the persistent session closes.
+     */
+    markChainDispatched(agentId) {
+        if (!agentId || this.#dispatchedFor.has(agentId))
+            return false;
+        this.#dispatchedFor.add(agentId);
+        return true;
+    }
     /**
      * Close the persistent session (kills subprocess).
      * Call on disconnect, session switch, or recovery.
@@ -1955,23 +1972,12 @@ class ClaudeLLMStream extends llm.LLMStream {
                                         console.log('[LIFECYCLE-PROBE] PostToolUse on', toolName, 'agent_id=', agentId, 'ts=', Date.now());
                                     }
                                     this.#eventEmitter.emit('tool_result', { name: toolName, input: toolInput, response: toolResponse, agentRole: agentTypePost || 'main' });
-                                    // Pattern #1 verifier chaining: when the MAIN agent's Task sub-agent of a
-                                    // chained type finishes, inject a reminder so the main agent dispatches the
-                                    // next verifier(s) as real Task sub-agents (verdicts return inline). Gated to
-                                    // the main thread (agent_type absent) so verifiers never re-chain themselves.
-                                    if (!agentTypePost && (toolName === 'Task' || toolName === 'Agent')) {
-                                        const subType = String(toolInput?.subagent_type || toolInput?.agent_type || '');
-                                        const link = subType ? VERIFIER_CHAIN[subType] : undefined;
-                                        if (link?.afterReminder) {
-                                            console.log(`[DISPATCH] Pattern#1 chain: ${subType} done → reminding main agent to verify`);
-                                            return {
-                                                hookSpecificOutput: {
-                                                    hookEventName: 'PostToolUse',
-                                                    additionalContext: link.afterReminder,
-                                                },
-                                            };
-                                        }
-                                    }
+                                    // Pattern #1 verifier chaining has MOVED to the SubagentStop hook below. Reason:
+                                    // sub-agents run with run_in_background:true, so PostToolUse-on-Task fires at
+                                    // DISPATCH (placeholder tool_response), not completion — injecting the "now verify"
+                                    // reminder here fired while the writer/researcher was still running (mistimed).
+                                    // SubagentStop is the true completion signal; it pushes the reminder into the main
+                                    // agent via pushMessage.
                                     return {};
                                 }]
                         }],
@@ -2327,9 +2333,32 @@ class ClaudeLLMStream extends llm.LLMStream {
                                     const aid = input?.agent_id ?? ('sa-' + Date.now());
                                     statusManager.upsertDispatch(aid, { subagentType: at, dispatchState: 'completed', artifact: msg });
                                     this.#eventEmitter.emit('task_completed', { agent_type: at, agent_id: aid, last_assistant_message: String(msg).slice(0, 400) });
-                                    // Verifier chaining is Pattern #1 now: the PostToolUse-on-Task hook injects a
-                                    // reminder into the MAIN agent, which dispatches the reviewer/tester as real
-                                    // Task sub-agents (verdicts return inline). No out-of-band spawns from here.
+                                    // Pattern #1 verifier chaining — CORRECT timing (moved here from PostToolUse).
+                                    // SubagentStop fires at REAL completion. When a chained producer (writer/researcher)
+                                    // finishes, push its afterReminder into the MAIN agent's streaming input so the main
+                                    // agent dispatches the next verifier(s) as real Task sub-agents (verdicts return
+                                    // inline). Only writer/researcher are VERIFIER_CHAIN keys with afterReminder, so
+                                    // verifiers (reviewer/tester/reasoner) never re-chain. Dedup on agent_id guards a
+                                    // double-fired SubagentStop; a fresh fix-round writer has a NEW id → re-chains (the
+                                    // intended bounded loop). Guarded on a live session so we never cold-start a query
+                                    // just to deliver a reminder. Silent-dispatch prefix keeps it off the voice.
+                                    const chainLink = at ? VERIFIER_CHAIN[at] : undefined;
+                                    // Dedup MUST key on the REAL agent_id, never the fabricated 'sa-<ts>' fallback used
+                                    // above for status/emit — a synthetic id is unique every call and would defeat the
+                                    // double-fire guard. If the SDK omits agent_id we can't dedup safely, so skip chaining.
+                                    if (chainLink?.afterReminder && input?.agent_id && this.#llmRef.hasSession() && this.#llmRef.markChainDispatched(input.agent_id)) {
+                                        console.log(`[DISPATCH] Pattern#1 chain (SubagentStop): ${at} done → pushing verify reminder to main agent`);
+                                        try {
+                                            this.#llmRef.pushMessage(SILENT_VERIFY_PREFIX + chainLink.afterReminder, sdkOptions, {
+                                                onSessionId: this.#onSessionId,
+                                                onCheckpoint: this.#onCheckpoint,
+                                                eventEmitter: this.#eventEmitter,
+                                            });
+                                        }
+                                        catch (e) {
+                                            console.warn('Pattern#1 chain push failed:', e);
+                                        }
+                                    }
                                     return {};
                                 }]
                         }],

package/dist/index.js

@@ -38,7 +38,7 @@ import { cleanupHousekeeping } from './housekeeping.js';
 import { createSTT, createTTS } from './voice-io.js';
 import { createClaudeLLM, NAMED_AGENTS, applyTurbo } from './claude-llm.js';
 import { clearPipelineFastBrainSession, prewarmBM25Index } from './pipeline-fastbrain.js';
-import { ensureClaudeAuth, applyAuthFallback } from './claude-auth.js';
+import { ensureClaudeAuth, applyAuthFallback, replayInFlightAuth } from './claude-auth.js';
 import { createSmitheryProxy, destroySmitheryProxy, parseSmitheryUrl, isSmitheryUrl, SmitheryAuthorizationError } from './smithery-proxy.js';
 import { DIRECT_MODE_PROMPT } from './prompts.js';
 import { MCP_CATALOG } from './config.js';
@@ -4035,6 +4035,20 @@ async function main() {
         room.on(RoomEvent.TrackSubscribed, (track, publication, participant) => {
             try {
                 console.log(`📥 [ROOM-TRACK-SUBSCRIBED] participant=${participant?.identity} kind=${track?.kind} source=${publication?.source} sid=${publication?.sid} t=${new Date().toISOString()}`);
+                // Auth-prompt race fix: the "Connect Claude" prompt is published in the
+                // ParticipantConnected handler ~5-6s before the browser's data channel
+                // finishes subscribing, so a no-auth user never receives it (reliable
+                // data isn't buffered for a not-yet-subscribed peer) and the modal never
+                // shows. TrackSubscribed means this participant's WebRTC transport (incl.
+                // data channel) is up — re-deliver any pending auth prompt now. No-op
+                // when already authenticated. Covers BOTH resume and new-conversation
+                // paths (both dispatch ensureClaudeAuth in the same participant handler).
+                const pid = participant?.identity;
+                if (typeof pid === 'string' && pid.startsWith('user-')) {
+                    const replayed = replayInFlightAuth((type, payload) => sendToFrontend({ type, ...payload }));
+                    if (replayed)
+                        console.log(`🔑 Re-delivered pending Claude auth prompt to ${pid} on TrackSubscribed`);
+                }
             }
             catch { }
         });

package/dist/pipeline-fastbrain.js

@@ -255,16 +255,6 @@ function buildSystemPrompt(chatHistory, researchContext) {
         `Greetings/thanks/confirmations: respond directly, no search.`,
         `Tasks needing live code analysis or new research: respond with [RESEARCH_NEEDED]`,
         ``,
-        `== DECISIONS: DEFER, DON'T ASSERT ==`,
-        `The grounded main agent answers the SAME question in parallel with full context — it owns`,
-        `decisions. For questions asking what was DECIDED / CHOSEN / SCOPED / AGREED / "what were the`,
-        `options" / "what did we settle on" / "remind me what we decided": do NOT state a definitive`,
-        `answer from one keyword hit. A single matched line is often a passing mention, not the`,
-        `decision (e.g. a file that "covers WhatsApp and LinkedIn" is NOT the scoping decision).`,
-        `Only assert a decision if MULTIPLE recent hits corroborate it AND one is clearly the decision`,
-        `itself. Otherwise hedge briefly and defer — e.g. "I think it involved X, but let the main`,
-        `agent confirm the exact decision" — or emit [RESEARCH_NEEDED]. Never contradict-with-confidence.`,
-        ``,
         `== STYLE ==`,
         `1-3 sentences. Grounded in results. Never fabricate.`,
         `If not found after thorough searching: "I didn't find that in the session history."`,

package/package.json

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