osborn 0.9.226 → 0.9.228

package/dist/claude-llm.d.ts

@@ -121,8 +121,8 @@ export declare function decideWrite(agentType: string | null, filePath: string):
     reason?: string;
 };
 export declare const VERIFIER_CHAIN: Record<string, {
-    then: string[];
-    mode?: 'parallel' | 'sequential';
+    parallelAtStart?: string[];
+    afterReminder?: string;
 }>;
 /**
  * Claude LLM - Wraps Claude Agent SDK for LiveKit
@@ -297,25 +297,6 @@ export declare class ClaudeLLM extends llm.LLM {
         onCheckpoint: (checkpointId: string) => void;
         eventEmitter: EventEmitter;
     }): void;
-    /**
-     * Dispatcher v1 — auto-spawn a reviewer after a writer sub-agent completes.
-     * Runs a one-shot query() with the reviewer agent and emits dispatch_rejected
-     * if the verdict is REJECT. A reviewer failure must never crash the consumer.
-     * Public so ClaudeLLMStream can call it via this.#llmRef.spawnReviewer().
-     */
-    spawnReviewer(agentId: string, writerOutput: string, emitter: EventEmitter): Promise<void>;
-    /**
-     * Dispatcher v1 — auto-spawn a tester after a writer sub-agent completes,
-     * in parallel with spawnReviewer. Runs tests against the diff and emits
-     * dispatch_rejected with verdict 'TEST-FAIL' if they fail.
-     */
-    spawnTester(agentId: string, _writerOutput: string, emitter: EventEmitter): Promise<void>;
-    /**
-     * Dispatcher v1 — research gate: vet a researcher sub-agent's output before
-     * it reaches the main agent. Emits dispatch_rejected with verdict 'NEEDS-MORE'
-     * (distinct from reviewer's 'REJECT') so the frontend can tell them apart.
-     */
-    spawnResearchGate(agentId: string, researchOutput: string, emitter: EventEmitter): Promise<void>;
     chat({ chatCtx, toolCtx, connOptions, abortController, }: {
         chatCtx: llm.ChatContext;
         toolCtx?: llm.ToolContext;

package/dist/claude-llm.js

@@ -12,7 +12,6 @@ import { EventEmitter } from 'events';
 import { saveSessionMetadata, getSessionWorkspace } from './config.js';
 import { statusManager } from './status-manager.js';
 import { getResearchSystemPrompt, getDirectModeResearchPrompt, getGroundingBlock, getRecalledContextBlock } from './prompts.js';
-import { getIndexPath } from './summary-index.js';
 import { openStore, recall, storeExists, updateSessionStore, getStorePath } from './session-store.js';
 import { getEmbedder } from './embedder.js';
 import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync, statSync } from 'node:fs';
@@ -39,15 +38,10 @@ const TURN_SHAPE_REMINDER_PATH = join(__claudeLlmDir, 'prompts', 'turn-shape-rem
 const RECALL_TOP_K = 5;
 const RECALL_PER_HIT_CHARS = 800;
 const RECALL_ENABLED = () => process.env.OSBORN_RECALL_INJECT !== '0';
-// Warm the embedder once (fire-and-forget) so hybrid recall is ready without blocking
-// the first turn; until it's warm, recall() falls back to keyword-only (~16ms).
-let __embedderWarmed = false;
-function warmEmbedder() {
-    if (__embedderWarmed || process.env.OSBORN_EMBED === '0')
-        return;
-    __embedderWarmed = true;
-    getEmbedder().catch(() => { });
-}
+// Query-side embed budget. Vector/hybrid is the PREFERRED recall path; keyword is only
+// the fallback. This tight timeout means a slow network degrades to keyword FAST rather
+// than stalling the turn — the read path never waits the full write-path (20s) budget.
+const QUERY_EMBED_TIMEOUT_MS = Number(process.env.OSBORN_QUERY_EMBED_TIMEOUT_MS || 2500);
 /** Build the recalled-context block to inject alongside the turn-shape reminder. '' on any miss. */
 async function buildRecallInjection(sessionId, workingDir, prompt) {
     try {
@@ -58,9 +52,11 @@ async function buildRecallInjection(sessionId, workingDir, prompt) {
             return '';
         if (!storeExists(sessionId, workingDir))
             return '';
-        warmEmbedder();
-        // Only use the embedder if it's already loaded — never block the turn on a cold load.
-        const embed = (__embedderWarmed && process.env.OSBORN_EMBED !== '0') ? (await getEmbedder()) ?? undefined : undefined;
+        // Vector/hybrid is the PREFERRED recall path; keyword is only the fallback when the
+        // embedder is unavailable or the query embed exceeds its short budget. Acquire the
+        // embedder every turn with a tight query timeout — no warm-up needed (it's a cloud
+        // fetch, not a local model load). If embed is null, recall() runs keyword-only.
+        const embed = process.env.OSBORN_EMBED !== '0' ? (await getEmbedder(QUERY_EMBED_TIMEOUT_MS)) ?? undefined : undefined;
         const { getStorePath } = await import('./session-store.js');
         const db = openStore(getStorePath(sessionId, workingDir));
         let hits;
@@ -443,7 +439,7 @@ export const NAMED_AGENTS = {
             '',
             '## Research-review gate',
             'When reviewing a researcher\'s findings, judge whether the research is COMPLETE and well-sourced against the original task. If it is, pass it. If it\'s thin, missing sources, or the answer likely lives somewhere the researcher didn\'t look, report that it needs more — so the orchestrator sends the researcher back.',
-            'End every research review with exactly one of:',
+            'Before you finalize, re-check your gate call ONCE: is the research genuinely complete and well-sourced for the original question — not passing thin work, nor failing solid work? Then end every research review with exactly one of:',
             '  GATE: PASS',
             '  GATE: NEEDS-MORE — <what\'s missing / where to look>',
             '',
@@ -512,8 +508,8 @@ export const NAMED_AGENTS = {
             '## 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.',
-            'Because that verification runs automatically after you finish, make the change review-ready and leave the tree in a runnable state — do not skip cleanup expecting a second pass.',
+            'A tester runs IN PARALLEL with you — it writes tests from the spec, blind to your implementation (TDD). After you return, the orchestrator RUNS those tests against your code and dispatches the reviewer; on test-fail or REJECT you may be sent back to fix (bounded rounds).',
+            'Because that verification runs after you finish, make the change review-ready and leave the tree in a runnable state — write the code so the independently-written tests can pass; do not skip cleanup expecting a second pass.',
         ].join('\n'),
     },
     tester: {
@@ -572,6 +568,7 @@ export const NAMED_AGENTS = {
             '7. Cap yourself at 6-8 tool calls unless the investigation clearly requires more.',
             '',
             '## What to return',
+            'Before you finalize, re-check your conclusion ONCE: did you actually RUN the commands (not assume the outcome), does your result match the real output, and did you distinguish a genuine regression from a flaky/environment failure? Then report:',
             '- RESULT: PASS or FAIL (one word, first line)',
             '- COMMAND: the exact command(s) you ran',
             '- OUTPUT: relevant excerpt (errors, failing test names, line numbers)',
@@ -748,7 +745,7 @@ export const NAMED_AGENTS = {
             '  NIT     — style, naming, or polish; never a reason to REJECT on its own',
             '',
             '## What to return',
-            'Structure your response EXACTLY as follows:',
+            'Before you finalize, re-check your verdict ONCE: is each BLOCKER/MAJOR real and reproducible (not a style nit or false positive), and does your ACCEPT/REJECT match the severity of what you actually found? Then structure your response EXACTLY as follows:',
             '',
             'VERDICT: ACCEPT | REJECT  — <one-line rationale>',
             '',
@@ -878,14 +875,31 @@ export function decideWrite(agentType, filePath) {
     }
     return { decision: 'defer' };
 }
-// ── Verifier chaining ───────────────────────────────────────────────────────
-// A plain name→verifiers lookup read by the SubagentStop hook. Same wiring the
-// old hardcoded branches had (writer→reviewer+tester, researcher→reasoner gate),
-// gathered in one visible place. Names resolve to spawnReviewer / spawnTester /
-// spawnResearchGate. Any agent not listed chains to nothing.
+// ── Verifier chaining (Pattern #1) ──────────────────────────────────────────
+// Verifiers are real named Task sub-agents (the `agents` roster), NOT out-of-band
+// query() spawns. Two enforcement points:
+//   • parallelAtStart — verifiers the ORCHESTRATOR must dispatch IN PARALLEL with
+//     the keyed agent (enforced by the orchestrator prompt; a post-hoc hook cannot
+//     make two Tasks run concurrently). Tester is TDD: it WRITES tests from the
+//     spec in parallel with the writer, blind to the implementation.
+//   • afterReminder — injected into the MAIN agent by the PostToolUse-on-Task hook
+//     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.
 export const VERIFIER_CHAIN = {
-    writer: { then: ['reviewer', 'tester'], mode: 'parallel' },
-    researcher: { then: ['reasoner'] },
+    writer: {
+        parallelAtStart: ['tester'],
+        afterReminder: 'The writer sub-agent just finished. Before you finalize, you MUST now use the Task tool to: ' +
+            "(1) RUN the tester's tests against the new implementation and report PASS/FAIL; " +
+            '(2) dispatch the `reviewer` on the diff for a VERDICT. ' +
+            'If tests FAIL or the reviewer REJECTs, dispatch the `writer` to fix and then re-verify — ' +
+            'at most 2 fix rounds, after which surface the outcome to the user rather than looping.',
+    },
+    researcher: {
+        afterReminder: 'The researcher sub-agent just finished. Before you finalize, use the Task tool to dispatch the ' +
+            '`reasoner` gate to judge whether the research is complete and well-sourced for the original ' +
+            'question. If it returns NEEDS-MORE, send the researcher back — at most 2 rounds, then surface.',
+    },
 };
 const RESEARCH_TOOLS = [
     'Read', 'Write', 'Edit', 'Glob', 'Grep',
@@ -1623,327 +1637,6 @@ export class ClaudeLLM extends llm.LLM {
             console.log('🔒 Persistent session background consumer exited');
         }
     }
-    /**
-     * Dispatcher v1 — auto-spawn a reviewer after a writer sub-agent completes.
-     * Runs a one-shot query() with the reviewer agent and emits dispatch_rejected
-     * if the verdict is REJECT. A reviewer failure must never crash the consumer.
-     * Public so ClaudeLLMStream can call it via this.#llmRef.spawnReviewer().
-     */
-    // writerOutput intentionally NOT fed to the reviewer (neutrality); kept for signature stability
-    async spawnReviewer(agentId, writerOutput, emitter) {
-        // Dedup guard — SubagentStop may fire more than once for the same agent_id.
-        if (this.#dispatchedFor.has(agentId))
-            return;
-        this.#dispatchedFor.add(agentId);
-        try {
-            // Get the actual diff to give reviewer concrete evidence instead of just the narrative
-            let gitDiff = '';
-            try {
-                const { execSync } = await import('child_process');
-                const diffStat = execSync('git diff HEAD~1 HEAD --stat 2>/dev/null', { cwd: this.#opts.workingDirectory, timeout: 5000 }).toString().trim();
-                const diff = execSync('git diff HEAD~1 HEAD 2>/dev/null', { cwd: this.#opts.workingDirectory, timeout: 5000 }).toString().trim();
-                gitDiff = diffStat ? `\n\n<git_diff_stat>\n${diffStat}\n</git_diff_stat>\n\n<git_diff>\n${diff.slice(0, 6000)}\n</git_diff>` : '';
-            }
-            catch {
-                // non-fatal: if git fails, proceed without diff
-            }
-            const prompt = [
-                'Review the change below for correctness, spec/requirement adherence, and obvious bugs.',
-                'The git diff is the AUTHORITATIVE source of what changed. Judge it on its own merits —',
-                'you are deliberately NOT given the writer\'s rationale or the session index; form an independent verdict from the code and the project\'s own documented standards.',
-                'Read the actual modified files and their callers as needed (you are not limited to the diff).',
-                'End your reply with exactly `VERDICT: ACCEPT` or `VERDICT: REJECT`.',
-                gitDiff,
-            ].join('\n');
-            // Do NOT pass agents here — the reviewer must be review-only and must not
-            // be able to spawn writer/researcher/reasoner sub-agents. Passing an empty
-            // agents roster prevents any SubagentStop(agent_type==='writer') from
-            // firing inside this one-shot query and re-arming the backstop loop.
-            const reviewerOptions = {
-                cwd: getSubagentsDir(this.#opts.workingDirectory),
-                permissionMode: 'default',
-                systemPrompt: NAMED_AGENTS.reviewer.prompt,
-                allowedTools: ['Read', 'Glob', 'Grep', 'Bash', 'Write', 'Edit'],
-                hooks: {
-                    PreToolUse: [
-                        {
-                            matcher: '.*',
-                            hooks: [async (input) => {
-                                    const toolName = input?.tool_name || 'unknown';
-                                    const toolInput = input?.tool_input || {};
-                                    emitter.emit('tool_use', { name: toolName, input: toolInput, agentRole: 'reviewer' });
-                                    return {};
-                                }],
-                        },
-                        {
-                            matcher: '.*',
-                            hooks: [async (input) => {
-                                    const toolName = input?.tool_name || '';
-                                    const toolInput = input?.tool_input;
-                                    if ((toolName === 'Write' || toolName === 'Edit' || toolName === 'MultiEdit') &&
-                                        !/\.(md|markdown|mdx|txt|rst|adoc)$/i.test(String(toolInput?.file_path))) {
-                                        return {
-                                            hookSpecificOutput: {
-                                                hookEventName: 'PreToolUse',
-                                                permissionDecision: 'deny',
-                                            },
-                                            reason: 'reviewer may only write documentation files (.md/.markdown/.mdx/.txt/.rst/.adoc)',
-                                        };
-                                    }
-                                    return {};
-                                }],
-                        },
-                    ],
-                    PostToolUse: [{
-                            matcher: '.*',
-                            hooks: [async (input) => {
-                                    const toolName = input?.tool_name || 'unknown';
-                                    const toolInput = input?.tool_input || {};
-                                    const toolResponse = input?.tool_response;
-                                    emitter.emit('tool_result', { name: toolName, input: toolInput, response: toolResponse, agentRole: 'reviewer' });
-                                    return {};
-                                }],
-                        }],
-                    // Self-review gate — block ONCE (stop_hook_active-guarded) so the reviewer
-                    // re-checks its own verdict before returning, instead of stopping on a
-                    // first-pass judgment.
-                    Stop: [{
-                            matcher: '.*',
-                            hooks: [async (input) => {
-                                    if (input?.stop_hook_active)
-                                        return {};
-                                    return { decision: 'block', reason: 'Before you finalize: re-read your findings against the diff once. Confirm each BLOCKER/MAJOR is real and reproducible (not a style nit or a false positive), and that your verdict matches the severity of what you actually found. Then end with exactly `VERDICT: ACCEPT` or `VERDICT: REJECT`.' };
-                                }],
-                        }],
-                },
-            };
-            console.log(`[DISPATCH] spawning reviewer for agentId=${agentId.slice(0, 8)}`);
-            const reviewerQuery = query({ prompt, options: reviewerOptions });
-            this.#activeQueries.add(reviewerQuery);
-            this.#activeQueriesById.set(agentId, reviewerQuery);
-            let reviewerText = '';
-            try {
-                for await (const msg of reviewerQuery) {
-                    const m = msg;
-                    if (m.type === 'result' && m.result) {
-                        reviewerText = String(m.result);
-                    }
-                }
-            }
-            finally {
-                this.#activeQueries.delete(reviewerQuery);
-                this.#activeQueriesById.delete(agentId);
-            }
-            const verdictMatch = reviewerText.match(/VERDICT:\s*(ACCEPT|REJECT)/i);
-            const verdict = verdictMatch ? verdictMatch[1].toUpperCase() : null;
-            if (verdict === 'REJECT') {
-                console.log(`[DISPATCH] review REJECT for agentId=${agentId.slice(0, 8)}`);
-                statusManager.upsertDispatch(agentId, { dispatchState: 'rejected', artifact: reviewerText });
-                emitter.emit('dispatch_rejected', { tuid: agentId, verdict: 'REJECT', review: reviewerText });
-            }
-            else {
-                console.log(`[DISPATCH] review ACCEPT for agentId=${agentId.slice(0, 8)}`);
-            }
-        }
-        catch (err) {
-            console.error('[DISPATCH] reviewer spawn failed (non-fatal):', err);
-        }
-    }
-    /**
-     * Dispatcher v1 — auto-spawn a tester after a writer sub-agent completes,
-     * in parallel with spawnReviewer. Runs tests against the diff and emits
-     * dispatch_rejected with verdict 'TEST-FAIL' if they fail.
-     */
-    async spawnTester(agentId, _writerOutput, emitter) {
-        // Use a scoped key so reviewer's dedup guard (keyed on raw agentId) doesn't block us.
-        const testerKey = `${agentId}:tester`;
-        if (this.#dispatchedFor.has(testerKey))
-            return;
-        this.#dispatchedFor.add(testerKey);
-        try {
-            let gitDiff = '';
-            try {
-                const { execSync } = await import('child_process');
-                const diffStat = execSync('git diff HEAD~1 HEAD --stat 2>/dev/null', { cwd: this.#opts.workingDirectory, timeout: 5000 }).toString().trim();
-                const diff = execSync('git diff HEAD~1 HEAD 2>/dev/null', { cwd: this.#opts.workingDirectory, timeout: 5000 }).toString().trim();
-                gitDiff = diffStat ? `\n\n<git_diff_stat>\n${diffStat}\n</git_diff_stat>\n\n<git_diff>\n${diff.slice(0, 6000)}\n</git_diff>` : '';
-            }
-            catch {
-                // non-fatal
-            }
-            const prompt = [
-                'Run tests and verify that the change below did not introduce regressions.',
-                'Use the git diff as your scope — run the full existing test suite to establish a baseline,',
-                'then target tests at the specific changed files/functions.',
-                'If no test suite exists, run the build or execute the changed code directly to confirm it works.',
-                'End your reply with exactly `RESULT: PASS` or `RESULT: FAIL` followed by a brief summary.',
-                gitDiff,
-            ].join('\n');
-            const testerOptions = {
-                cwd: getSubagentsDir(this.#opts.workingDirectory),
-                permissionMode: 'default',
-                systemPrompt: NAMED_AGENTS.tester.prompt,
-                allowedTools: ['Read', 'Glob', 'Grep', 'Bash', 'Write', 'Edit'],
-                hooks: {
-                    PreToolUse: [{
-                            matcher: '.*',
-                            hooks: [async (input) => {
-                                    const toolName = input?.tool_name || 'unknown';
-                                    const toolInput = input?.tool_input || {};
-                                    emitter.emit('tool_use', { name: toolName, input: toolInput, agentRole: 'tester' });
-                                    return {};
-                                }],
-                        }],
-                    PostToolUse: [{
-                            matcher: '.*',
-                            hooks: [async (input) => {
-                                    const toolName = input?.tool_name || 'unknown';
-                                    const toolInput = input?.tool_input || {};
-                                    const toolResponse = input?.tool_response;
-                                    emitter.emit('tool_result', { name: toolName, input: toolInput, response: toolResponse, agentRole: 'tester' });
-                                    return {};
-                                }],
-                        }],
-                    // Self-review gate — block ONCE (stop_hook_active-guarded) so the tester
-                    // re-checks its own conclusion before returning.
-                    Stop: [{
-                            matcher: '.*',
-                            hooks: [async (input) => {
-                                    if (input?.stop_hook_active)
-                                        return {};
-                                    return { decision: 'block', reason: 'Before you finalize: re-check your conclusion once. Did you actually RUN the commands (not assume the outcome)? Does your result match the real output, and did you distinguish a genuine regression from a flaky/environment failure? Then end with exactly `RESULT: PASS` or `RESULT: FAIL` followed by a brief summary.' };
-                                }],
-                        }],
-                },
-            };
-            console.log(`[DISPATCH] spawning tester for agentId=${agentId.slice(0, 8)}`);
-            const testerQuery = query({ prompt, options: testerOptions });
-            this.#activeQueries.add(testerQuery);
-            this.#activeQueriesById.set(testerKey, testerQuery);
-            let testerText = '';
-            try {
-                for await (const msg of testerQuery) {
-                    const m = msg;
-                    if (m.type === 'result' && m.result) {
-                        testerText = String(m.result);
-                    }
-                }
-            }
-            finally {
-                this.#activeQueries.delete(testerQuery);
-                this.#activeQueriesById.delete(testerKey);
-            }
-            const resultMatch = testerText.match(/RESULT:\s*(PASS|FAIL)/i);
-            const result = resultMatch ? resultMatch[1].toUpperCase() : null;
-            if (result === 'FAIL') {
-                console.log(`[DISPATCH] tester FAIL for agentId=${agentId.slice(0, 8)}`);
-                statusManager.upsertDispatch(agentId, { dispatchState: 'rejected', artifact: testerText });
-                emitter.emit('dispatch_rejected', { tuid: agentId, verdict: 'TEST-FAIL', review: testerText });
-            }
-            else {
-                console.log(`[DISPATCH] tester PASS for agentId=${agentId.slice(0, 8)}`);
-            }
-        }
-        catch (err) {
-            console.error('[DISPATCH] tester spawn failed (non-fatal):', err);
-        }
-    }
-    /**
-     * Dispatcher v1 — research gate: vet a researcher sub-agent's output before
-     * it reaches the main agent. Emits dispatch_rejected with verdict 'NEEDS-MORE'
-     * (distinct from reviewer's 'REJECT') so the frontend can tell them apart.
-     */
-    async spawnResearchGate(agentId, researchOutput, emitter) {
-        // Dedup guard — SubagentStop may fire more than once for the same agent_id.
-        if (this.#dispatchedFor.has(agentId))
-            return;
-        this.#dispatchedFor.add(agentId);
-        try {
-            const idxPathGate = (this.#sessionId && this.#opts.workingDirectory)
-                ? getIndexPath(this.#sessionId, this.#opts.workingDirectory)
-                : null;
-            const prompt = [
-                'Use the reasoner sub-agent to vet this research output.',
-                'Determine whether the research is sufficient to answer the original question.',
-                'End your reply with exactly `GATE: PASS` or `GATE: NEEDS-MORE`.',
-                ...(idxPathGate ? [`The session index is at ${idxPathGate} — you MUST read it before reviewing.`] : []),
-                '',
-                '<research_output>',
-                researchOutput.slice(0, 8000),
-                '</research_output>',
-            ].join('\n');
-            // Do NOT pass agents here — the research-gate reasoner must be review-only
-            // and must not be able to spawn sub-agents. Same rationale as spawnReviewer:
-            // 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: getSubagentsDir(this.#opts.workingDirectory),
-                permissionMode: 'default',
-                systemPrompt: NAMED_AGENTS.reasoner.prompt,
-                hooks: {
-                    PreToolUse: [{
-                            matcher: '.*',
-                            hooks: [async (input) => {
-                                    const toolName = input?.tool_name || 'unknown';
-                                    const toolInput = input?.tool_input || {};
-                                    emitter.emit('tool_use', { name: toolName, input: toolInput, agentRole: 'reasoner' });
-                                    return {};
-                                }],
-                        }],
-                    PostToolUse: [{
-                            matcher: '.*',
-                            hooks: [async (input) => {
-                                    const toolName = input?.tool_name || 'unknown';
-                                    const toolInput = input?.tool_input || {};
-                                    const toolResponse = input?.tool_response;
-                                    emitter.emit('tool_result', { name: toolName, input: toolInput, response: toolResponse, agentRole: 'reasoner' });
-                                    return {};
-                                }],
-                        }],
-                    // Self-review gate — block ONCE (stop_hook_active-guarded) so the gate
-                    // re-checks its own PASS/NEEDS-MORE call before returning.
-                    Stop: [{
-                            matcher: '.*',
-                            hooks: [async (input) => {
-                                    if (input?.stop_hook_active)
-                                        return {};
-                                    return { decision: 'block', reason: 'Before you finalize: re-check your gate decision once. Is the research genuinely complete and well-sourced for the original question — not passing thin work, nor failing solid work? Then end with exactly `GATE: PASS` or `GATE: NEEDS-MORE`.' };
-                                }],
-                        }],
-                },
-            };
-            console.log(`[DISPATCH] spawning research-gate for agentId=${agentId.slice(0, 8)}`);
-            const gateQuery = query({ prompt, options: gateOptions });
-            this.#activeQueries.add(gateQuery);
-            this.#activeQueriesById.set(agentId, gateQuery);
-            let review = '';
-            try {
-                for await (const msg of gateQuery) {
-                    const m = msg;
-                    if (m.type === 'result' && m.result) {
-                        review = String(m.result);
-                    }
-                }
-            }
-            finally {
-                this.#activeQueries.delete(gateQuery);
-                this.#activeQueriesById.delete(agentId);
-            }
-            const gateMatch = review.match(/GATE:\s*(PASS|NEEDS-MORE)/i);
-            const gateVerdict = gateMatch ? gateMatch[1].toUpperCase() : null;
-            if (gateVerdict === 'NEEDS-MORE') {
-                console.log(`[DISPATCH] research-gate NEEDS-MORE for agentId=${agentId.slice(0, 8)}`);
-                statusManager.upsertDispatch(agentId, { dispatchState: 'rejected', artifact: review });
-                emitter.emit('dispatch_rejected', { tuid: agentId, verdict: 'NEEDS-MORE', review });
-            }
-            else {
-                console.log(`[DISPATCH] research-gate PASS for agentId=${agentId.slice(0, 8)}`);
-            }
-        }
-        catch (err) {
-            console.error('[DISPATCH] research-gate spawn failed (non-fatal):', err);
-        }
-    }
     chat({ chatCtx, toolCtx, connOptions = DEFAULT_API_CONNECT_OPTIONS, abortController, }) {
         return new ClaudeLLMStream(this, {
             chatCtx,
@@ -2195,6 +1888,23 @@ 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,
+                                                },
+                                            };
+                                        }
+                                    }
                                     return {};
                                 }]
                         }],
@@ -2231,15 +1941,17 @@ class ClaudeLLMStream extends llm.LLMStream {
                                         if (!fromSubagent && sid && this.#opts.workingDirectory) {
                                             this.#llmRef.triggerStoreUpdate(sid, this.#opts.workingDirectory);
                                         }
-                                        // Recall injection is best-effort and must NEVER approach the SDK's 30s hook
-                                        // budget. Cap it hard at 1.5s — if the store is momentarily busy (e.g. a large
-                                        // ingest sweep still draining), we skip recall for this turn rather than block
-                                        // the prompt. The keyword/vector layers catch up on the next turn.
+                                        // Recall is best-effort and must never approach the SDK's 30s hook budget.
+                                        // buildRecallInjection is already self-bounding — the query embed has a tight
+                                        // timeout (falls back to keyword INSIDE recall) and the SQL is local/ms. This
+                                        // outer race is only a catastrophic-hang backstop (e.g. a momentarily locked
+                                        // store), set well above the embed budget so a slow embed degrades to keyword
+                                        // rather than being cut to nothing.
                                         const recalled = fromSubagent
                                             ? ''
                                             : await Promise.race([
                                                 buildRecallInjection(sid, this.#opts.workingDirectory, String(input?.prompt || '')),
-                                                new Promise((res) => setTimeout(() => res(''), 1500)),
+                                                new Promise((res) => setTimeout(() => res(''), 6000)),
                                             ]);
                                         const additionalContext = recalled ? `${reminder}\n\n${recalled}` : reminder;
                                         console.log(`📌 UserPromptSubmit: injected turn-shape reminder (${reminder.length} chars)${recalled ? ` + recall (${recalled.length} chars)` : ''} for prompt="${promptPreview}..." [tool budget reset to 0/${TOOL_CALL_BUDGET}]`);
@@ -2524,27 +2236,11 @@ class ClaudeLLMStream extends llm.LLMStream {
                                     return {};
                                 }]
                         }],
-                    // Idle-agent guard / end-of-run self-review. When the main agent tries
-                    // to end its turn while background work is still in flight, block ONCE
-                    // (stop_hook_active guards against a loop) and force one more turn so it
-                    // either waits + synthesizes, or explicitly tells the user what's still
-                    // running — never goes silent leaving dispatched work dangling.
-                    Stop: [{
-                            matcher: '.*',
-                            hooks: [async (input) => {
-                                    const inFlight = Array.isArray(input?.background_tasks) ? input.background_tasks : [];
-                                    if (input?.stop_hook_active || inFlight.length === 0)
-                                        return {};
-                                    const labels = inFlight
-                                        .map((t) => t?.agent_type || t?.name || t?.command || t?.type || 'task')
-                                        .slice(0, 6);
-                                    console.log(`🛑 Stop gate: ${inFlight.length} background task(s) in flight → blocking once for self-review`);
-                                    return {
-                                        decision: 'block',
-                                        reason: `Before you end your turn: ${inFlight.length} background task(s) are still running (${labels.join(', ')}). Do NOT go idle. Either wait for them and synthesize their results into your answer, or explicitly tell the user what is still running and what you will do when it finishes.`,
-                                    };
-                                }]
-                        }],
+                    // (Removed the end-of-turn idle-guard Stop gate: it polled `background_tasks`
+                    // — Bash background jobs, never the verifier queries — so it couldn't coordinate
+                    // them, and its block-loop was a hang surface. Pattern #1 chaining via the
+                    // PostToolUse-on-Task reminder makes verifiers return inline, so the main agent
+                    // sees their verdicts deterministically without an end-turn gate.)
                     SubagentStart: [{
                             matcher: '.*',
                             hooks: [async (input) => {
@@ -2562,34 +2258,9 @@ 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) });
-                                    // Infinite-loop guard — verifiers never re-dispatch (they carry no
-                                    // VERIFIER_CHAIN entry anyway; defense-in-depth).
-                                    if (at === 'reviewer' || at === 'tester' || at === 'reasoner')
-                                        return {};
-                                    // Verifier chaining — driven by the plain VERIFIER_CHAIN lookup
-                                    // (replaces the hardcoded writer/researcher branches).
-                                    const chain = at ? VERIFIER_CHAIN[at] : undefined;
-                                    if (chain?.then?.length && msg) {
-                                        const spawn = (role) => {
-                                            if (role === 'reviewer')
-                                                return this.#llmRef.spawnReviewer(aid, msg, this.#eventEmitter);
-                                            if (role === 'tester')
-                                                return this.#llmRef.spawnTester(aid, msg, this.#eventEmitter);
-                                            if (role === 'reasoner' || role === 'gate')
-                                                return this.#llmRef.spawnResearchGate(aid, msg, this.#eventEmitter);
-                                            console.warn(`[DISPATCH] unknown chain target '${role}' for ${at} — skipped`);
-                                            return Promise.resolve();
-                                        };
-                                        if (chain.mode === 'sequential') {
-                                            // Await in order WITHOUT blocking the hook return (fire the chain async).
-                                            void (async () => { for (const r of chain.then)
-                                                await spawn(r); })();
-                                        }
-                                        else {
-                                            for (const r of chain.then)
-                                                void spawn(r);
-                                        }
-                                    }
+                                    // 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.
                                     return {};
                                 }]
                         }],

package/dist/embedder.d.ts

@@ -25,4 +25,4 @@ import { type Embedder } from './session-store.js';
  * Returns an Embedder, or null if embeddings are disabled or no key is configured.
  * The returned function degrades to null on any per-call failure (keyword-only recall).
  */
-export declare function getEmbedder(): Promise<Embedder | null>;
+export declare function getEmbedder(timeoutMs?: number): Promise<Embedder | null>;

package/dist/embedder.js

@@ -25,7 +25,16 @@ const OPENROUTER_URL = process.env.OPENROUTER_EMBED_URL || 'https://openrouter.a
 const MODEL_ID = EMBED_MODEL;
 const MAX_BATCH = 64; // inputs per request (OpenAI-compatible arrays)
 const REQUEST_TIMEOUT_MS = Number(process.env.OSBORN_EMBED_TIMEOUT_MS || 20_000);
-let disabled = false;
+let lastEmbedWarn = 0;
+/** Throttled failure log (max ~1/30s) so a bulk re-embed can't spam, but embedded=0 is
+ * never silent — every failure surfaces a reason (status/network) in the machine logs. */
+function embedWarn(msg) {
+    const now = Date.now();
+    if (now - lastEmbedWarn > 30_000) {
+        lastEmbedWarn = now;
+        console.warn(`[embedder] ${msg}`);
+    }
+}
 function apiKey() {
     return process.env.OPENROUTER_API_KEY || process.env.OPENROUTER_WORKSPACE_API_KEY;
 }
@@ -52,9 +61,9 @@ function normalizeAndQuantize(floats) {
     return out;
 }
 /** Embed one batch (≤ MAX_BATCH inputs). Returns aligned int8 vectors, or null on any failure. */
-async function embedBatch(inputs, key) {
+async function embedBatch(inputs, key, timeoutMs) {
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
     try {
         const res = await fetch(OPENROUTER_URL, {
             method: 'POST',
@@ -72,26 +81,35 @@ async function embedBatch(inputs, key) {
             }),
             signal: controller.signal,
         });
-        if (!res.ok)
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            embedWarn(`OpenRouter ${res.status} ${res.statusText}: ${body.slice(0, 200)}`);
             return null;
+        }
         const json = await res.json();
         const data = json?.data;
-        if (!Array.isArray(data) || !data.length)
+        if (!Array.isArray(data) || !data.length) {
+            embedWarn('empty/invalid embeddings response');
             return null;
+        }
         // OpenAI-compatible: each entry carries its input `index`; align by it.
+        // Fall back to array order if `index` is absent so a missing field never voids the batch.
         const byIndex = new Array(inputs.length).fill(null);
-        for (const d of data) {
-            const idx = typeof d?.index === 'number' ? d.index : -1;
+        data.forEach((d, pos) => {
+            const idx = typeof d?.index === 'number' ? d.index : pos;
             const emb = d?.embedding;
             if (idx >= 0 && idx < inputs.length && Array.isArray(emb)) {
                 byIndex[idx] = normalizeAndQuantize(emb);
             }
+        });
+        if (byIndex.some((v) => v == null)) {
+            embedWarn('response missing/misaligned embeddings');
+            return null;
         }
-        if (byIndex.some((v) => v == null))
-            return null; // malformed / partial response
         return byIndex;
     }
-    catch {
+    catch (err) {
+        embedWarn(`request failed: ${err?.name || ''} ${err?.message || err}`);
         return null; // network error, timeout/abort, bad JSON — degrade to keyword-only
     }
     finally {
@@ -102,12 +120,17 @@ async function embedBatch(inputs, key) {
  * Returns an Embedder, or null if embeddings are disabled or no key is configured.
  * The returned function degrades to null on any per-call failure (keyword-only recall).
  */
-export async function getEmbedder() {
-    if (process.env.OSBORN_EMBED === '0' || disabled)
+export async function getEmbedder(timeoutMs = REQUEST_TIMEOUT_MS) {
+    if (process.env.OSBORN_EMBED === '0')
         return null;
+    // Re-read the key EVERY call and never latch off on a missing key: the platform
+    // OpenRouter key is hydrated into the env by the secrets layer, which can finish
+    // AFTER the first (boot-time) warm call. A permanent latch there disabled embedding
+    // for the whole session (embedded=0) even though fast-brain — which reads the key
+    // fresh per request — kept working. Re-reading recovers as soon as the key lands.
     const key = apiKey();
     if (!key) {
-        disabled = true; // no key on this machine — don't retry every turn
+        embedWarn('no OPENROUTER_API_KEY in env yet — keyword-only for this call');
         return null;
     }
     const embed = async (texts) => {
@@ -116,7 +139,7 @@ export async function getEmbedder() {
         const out = [];
         for (let i = 0; i < texts.length; i += MAX_BATCH) {
             const chunk = texts.slice(i, i + MAX_BATCH).map((t) => t || ' ');
-            const vecs = await embedBatch(chunk, key);
+            const vecs = await embedBatch(chunk, key, timeoutMs);
             if (!vecs)
                 return null; // any failure → keyword-only for this call
             out.push(...vecs);

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

@@ -107,13 +107,15 @@ THE BUDGET — HARD QUANTITATIVE RULE:
 THE SUB-AGENTS:
   · researcher (Sonnet) — info gathering, web research, multi-file reads. Read-only outside workspace.
   · 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.
+  · writer (Sonnet) — ALL file changes outside the workspace. The ONLY agent with write access outside the workspace.
+  · tester (Sonnet) — TDD verifier. Dispatched IN PARALLEL with the writer: writes tests from the SPEC, blind to the writer's implementation. After the writer finishes, its tests are RUN against the new code (PASS/FAIL).
+  · reviewer (Sonnet) — dispatched AFTER the writer completes: reads the diff and returns VERDICT: ACCEPT/REJECT.
+  · 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, writer, tester, or reviewer 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.
+  researcher (gather facts) → planner (step plan for multi-step work) → THEN dispatch writer AND tester IN THE SAME STEP, in parallel: the writer executes the plan while the tester writes tests from the spec, blind to the implementation (TDD) → after the writer returns, RUN the tester's tests against the new code AND dispatch the reviewer on the diff → on test-FAIL or REJECT, send the writer back to fix and re-verify (at most 2 rounds) → you synthesize and speak.
 For a quick factual query: researcher only → you speak.
-NEVER skip tester and reviewer after a code change.
+NEVER skip the tester+reviewer verification after a code change — and dispatch the tester IN PARALLEL with the writer (not after), so tests are written independently of the code.
 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>

package/dist/session-store.d.ts

@@ -63,7 +63,9 @@ export interface StoreStats {
 export declare function getStorePath(sessionId: string, workingDir: string): string;
 /** Returns the store path if it exists and is non-empty, else null. */
 export declare function storeExists(sessionId: string, workingDir: string): string | null;
-export declare function openStore(dbPath: string): Database.Database;
+export declare function openStore(dbPath: string, opts?: {
+    readonly?: boolean;
+}): Database.Database;
 /**
  * Build or update the session store incrementally.
  * Ingests the main JSONL + all sub-agent JSONLs from their last stored offsets.

package/dist/session-store.js

@@ -66,11 +66,23 @@ export function storeExists(sessionId, workingDir) {
 // ============================================================
 // DB OPEN / SCHEMA
 // ============================================================
-export function openStore(dbPath) {
+export function openStore(dbPath, opts) {
+    // Read-only open for the hot read path (buildRecallInjection, fast-brain). A readonly
+    // connection takes only SHARED locks — under WAL it never blocks (or is blocked by) the
+    // writer — and it skips the DDL/migration/meta writes below entirely (a reader must not
+    // migrate). busy_timeout lets a transient exclusive lock (checkpoint/DDL on the writer)
+    // resolve instead of throwing SQLITE_BUSY. Caller guarantees the db exists (storeExists).
+    if (opts?.readonly) {
+        const rdb = new Database(dbPath, { readonly: true });
+        sqliteVec.load(rdb); // vec0 module must be registered per-connection for vec_int8() in recall()
+        rdb.pragma('busy_timeout = 5000');
+        return rdb;
+    }
     const db = new Database(dbPath);
     sqliteVec.load(db);
     db.pragma('journal_mode = WAL');
     db.pragma('synchronous = NORMAL');
+    db.pragma('busy_timeout = 5000'); // wait out a transient lock instead of throwing SQLITE_BUSY
     // ── Migration gate ──────────────────────────────────────────────
     // The derived tables (content/fts/vec/sources) are a re-derivable cache of the
     // JSONL, which is the source of truth. If this DB was built by a different
@@ -256,12 +268,22 @@ function countLines(filePath, upToBytes) {
     return c;
 }
 /**
- * Max bytes ingested from a single JSONL per sweep. A very large session file
- * (100MB+) is drained gap-free across many turns instead of being read whole in
- * one synchronous pass — that whole-file read + insert transaction is what pegged
- * the single Node event loop and starved the SDK's time-boxed UserPromptSubmit hook.
+ * Max bytes ingested from a SINGLE JSONL per sweep. Kept small so each synchronous
+ * read+parse+gzip+FTS-insert block is short (~sub-300ms) and never stutters realtime
+ * voice (VAD) between event-loop yields.
+ */
+const MAX_INGEST_BYTES = 1 * 1024 * 1024;
+/**
+ * Max bytes ingested across ALL sources in one turn. This is the cap that actually
+ * matters: a session can have HUNDREDS of subagent JSONL files, and on a store
+ * migration the offsets reset so every source re-ingests from 0 at once. The old
+ * code looped all sources inside ONE synchronous db.transaction — hundreds of MB of
+ * synchronous work that pegged the single Node thread for minutes and starved VAD,
+ * the SDK's UserPromptSubmit hook (30s timeout), and fast-brain. Bounding the total
+ * per turn (and yielding between sources) drains large sessions over many turns
+ * without ever monopolizing the loop.
  */
-const MAX_INGEST_BYTES = 4 * 1024 * 1024;
+const MAX_INGEST_BYTES_PER_TURN = 4 * 1024 * 1024;
 /**
  * Ingest new bytes from a single JSONL file into the store.
  * Reads only from `fromOffset` forward, at most `maxBytes` per call. Returns rows
@@ -370,21 +392,44 @@ export async function updateSessionStore(sessionId, workingDir, opts) {
         const upSrc = db.prepare(`INSERT INTO sources(source, jsonl_path, byte_offset, line_count) VALUES (@source,@path,@off,@lines)
        ON CONFLICT(source) DO UPDATE SET jsonl_path=@path, byte_offset=@off, line_count=@lines`);
         const freshRows = [];
-        const txn = db.transaction(() => {
-            for (const s of sources) {
-                const prev = getSrc.get(s.source);
-                const fromOffset = prev?.byte_offset ?? 0;
-                const res = ingestFile(db, s.path, s.source, fromOffset);
-                if (res.inserted.length || res.newOffset !== fromOffset) {
-                    upSrc.run({
-                        source: s.source, path: s.path, off: res.newOffset,
-                        lines: (prev?.line_count ?? 0) + res.linesProcessed,
-                    });
-                }
-                freshRows.push(...res.inserted);
+        let budget = MAX_INGEST_BYTES_PER_TURN;
+        let sinceYield = 0;
+        for (const s of sources) {
+            // Yield to the event loop periodically even across drained sources, so iterating
+            // a large source list (statSync + SELECT each) can't itself stall voice/hook.
+            if (++sinceYield >= 8) {
+                sinceYield = 0;
+                await new Promise((r) => setImmediate(r));
             }
-        });
-        txn();
+            if (budget <= 0)
+                break; // per-turn cap reached — remaining sources drain next turn
+            const prev = getSrc.get(s.source);
+            const fromOffset = prev?.byte_offset ?? 0;
+            const cap = Math.min(budget, MAX_INGEST_BYTES);
+            let res;
+            try {
+                // Per-source transaction (not one giant txn over all sources) so we can yield
+                // between them and never hold the thread for the whole fleet of subagent files.
+                res = db.transaction(() => ingestFile(db, s.path, s.source, fromOffset, cap))();
+            }
+            catch {
+                continue; // a bad source never blocks the rest
+            }
+            if (res.inserted.length || res.newOffset !== fromOffset) {
+                upSrc.run({
+                    source: s.source, path: s.path, off: res.newOffset,
+                    lines: (prev?.line_count ?? 0) + res.linesProcessed,
+                });
+            }
+            const consumed = res.newOffset - fromOffset;
+            budget -= consumed;
+            freshRows.push(...res.inserted);
+            // Yield after any source that did real synchronous work.
+            if (consumed > 0) {
+                sinceYield = 0;
+                await new Promise((r) => setImmediate(r));
+            }
+        }
         opts?.onProgress?.(`content: +${freshRows.length} rows across ${sources.length} sources`);
         // ── Embeddings (best-effort, never blocks the keyword layer) ──
         let embeddedRows = 0;

package/package.json

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