osborn 0.9.218 → 0.9.220

package/dist/claude-llm.d.ts

@@ -59,23 +59,13 @@ export declare const NAMED_AGENTS: {
         description: string;
         tools: string[];
         grounded: boolean;
-        policy: {
-            write: "anywhere";
-        };
-        reminder: string;
+        criticalSystemReminder_EXPERIMENTAL: string;
         model: string;
         prompt: string;
     };
     tester: {
         description: string;
         tools: string[];
-        policy: {
-            write: {
-                extensions: RegExp;
-                label: string;
-                matchBasename: boolean;
-            };
-        };
         model: string;
         prompt: string;
     };
@@ -89,12 +79,6 @@ export declare const NAMED_AGENTS: {
     reviewer: {
         description: string;
         tools: string[];
-        policy: {
-            write: {
-                extensions: RegExp;
-                label: string;
-            };
-        };
         model: string;
         prompt: string;
     };
@@ -125,6 +109,21 @@ export declare function applyTurbo(agents: Record<string, any>, turbo: boolean):
  * Adversarial agents (reviewer/tester) leave `grounded` unset → untouched, stay blind.
  */
 export declare function applyGrounding(agents: Record<string, any>, sessionId: string | null, workingDir: string | undefined): Record<string, any>;
+/**
+ * Decide a Write/Edit/MultiEdit for the acting agent (null = main orchestrator).
+ * Pure lookup against WRITE_RULES. Returns:
+ *   'allow' → fall through (→ canUseTool workspace auto-approve, or {}).
+ *   'defer' → PreToolUse 'ask' (canUseTool decides).
+ *   'deny'  → hard block with reason.
+ */
+export declare function decideWrite(agentType: string | null, filePath: string): {
+    decision: 'allow' | 'defer' | 'deny';
+    reason?: string;
+};
+export declare const VERIFIER_CHAIN: Record<string, {
+    then: string[];
+    mode?: 'parallel' | 'sequential';
+}>;
 /**
  * Claude LLM - Wraps Claude Agent SDK for LiveKit
  * Research mode: reads anything, writes only to session workspace

package/dist/claude-llm.js

@@ -402,6 +402,7 @@ export const NAMED_AGENTS = {
             'Return findings to the orchestrator — never directly to the user.',
             'Run several researchers in parallel when there are independent threads to investigate.',
             'Hand off back to the orchestrator; it decides whether to invoke planner or writer next.',
+            'After you return, a reasoner-based gate judges whether your findings are COMPLETE and well-sourced; thin or unsourced findings get sent back to you — so cite paths/line numbers and state what you looked for but did NOT find.',
         ].join('\n'),
     },
     reasoner: {
@@ -468,10 +469,8 @@ export const NAMED_AGENTS = {
         ].join(' '),
         tools: ['Read', 'Write', 'Edit', 'MultiEdit', 'Bash', 'Glob', 'Grep', 'NotebookRead', 'NotebookEdit'],
         grounded: true, // applyGrounding() injects the osborn-recall command
-        policy: { write: 'anywhere' }, // sole writer — unrestricted; funnels through canUseTool
-        // Soft behavior via the composable `reminder` seam → SDK criticalSystemReminder_EXPERIMENTAL.
-        // Pinned into the writer's system prompt as a hard-to-ignore reminder.
-        reminder: 'BEFORE you write implementation code: make sure a test exists for the behavior you are about to change. If none exists, say so explicitly in your report so the tester can cover it — the tester is the agent that writes tests. NEVER weaken, skip, or delete a test to make your change pass.',
+        // SDK-native soft-behavior field — pinned into the writer's system prompt.
+        criticalSystemReminder_EXPERIMENTAL: 'BEFORE you write implementation code: make sure a test exists for the behavior you are about to change. If none exists, say so explicitly in your report so the tester can cover it — the tester is the agent that writes tests. NEVER weaken, skip, or delete a test to make your change pass.',
         model: 'opus',
         prompt: [
             'You are Osborn\'s writer agent. You execute file changes with a verify-first approach.',
@@ -514,6 +513,7 @@ export const NAMED_AGENTS = {
             '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.',
         ].join('\n'),
     },
     tester: {
@@ -523,9 +523,7 @@ export const NAMED_AGENTS = {
             'Returns structured pass/fail results with exact output — does NOT edit files.',
             'NOT GROUNDED: no session index access — runs tests with fresh eyes, adversarial validation.',
         ].join(' '),
-        tools: ['Bash', 'Read', 'Glob', 'Grep', 'Write', 'Edit'],
-        // Fail-closed: may ONLY write test files (basename .test/.spec.[jt]sx?).
-        policy: { write: { extensions: /\.(test|spec)\.[jt]sx?$/, label: 'test', matchBasename: true } },
+        tools: ['Bash', 'Read', 'Glob', 'Grep', 'Write', 'Edit'], // write-gate: test files only (WRITE_RULES.tester)
         model: 'sonnet',
         prompt: [
             'You are Osborn\'s tester agent. Your job is running tests and builds, then reporting results.',
@@ -674,9 +672,7 @@ export const NAMED_AGENTS = {
             'and returns an ACCEPT or REJECT verdict with specific, actionable feedback. May write documentation files (.md etc.) only.',
             'NOT GROUNDED: no session index access — reviews with fresh eyes for unbiased adversarial check.',
         ].join(' '),
-        tools: ['Read', 'Glob', 'Grep', 'Bash', 'Write', 'Edit'],
-        // Fail-closed: may ONLY write documentation files.
-        policy: { write: { extensions: /\.(md|markdown|mdx|txt|rst|adoc)$/i, label: 'documentation' } },
+        tools: ['Read', 'Glob', 'Grep', 'Bash', 'Write', 'Edit'], // write-gate: docs only (WRITE_RULES.reviewer)
         model: 'sonnet',
         prompt: [
             'You are Osborn\'s reviewer agent. You are the VERIFY step in a generator-verifier loop.',
@@ -844,59 +840,53 @@ export function applyGrounding(agents, sessionId, workingDir) {
     }
     return out;
 }
-const DEFAULT_WRITE_POLICY = 'workspace';
+const WRITE_RULES = {
+    writer: 'anywhere',
+    tester: { extensions: /\.(test|spec)\.[jt]sx?$/, label: 'test', matchBasename: true },
+    reviewer: { extensions: /\.(md|markdown|mdx|txt|rst|adoc)$/i, label: 'documentation' },
+};
 /** Path is inside the per-session sandbox workspace. */
 function isWorkspacePath(filePath) {
     return !!filePath && (filePath.includes('/osb/') ||
         filePath.includes('.osborn/sessions/') ||
         filePath.includes('.osborn/research/'));
 }
-/** Effective write policy for the acting agent (null agentType = main orchestrator). */
-function resolveWritePolicy(agentType, roster) {
-    const def = agentType ? roster?.[agentType] : null;
-    return def?.policy?.write ?? DEFAULT_WRITE_POLICY;
-}
 /**
- * Decide a Write/Edit/MultiEdit against a policy. Pure — no side effects.
- *   'allow'  → let it fall through (→ canUseTool workspace auto-approve, or {}).
- *   'defer'  → PreToolUse returns permissionDecision:'ask' (canUseTool decides).
- *   'deny'   → hard block with reason.
+ * Decide a Write/Edit/MultiEdit for the acting agent (null = main orchestrator).
+ * Pure lookup against WRITE_RULES. Returns:
+ *   'allow' → fall through (→ canUseTool workspace auto-approve, or {}).
+ *   'defer' → PreToolUse 'ask' (canUseTool decides).
+ *   'deny'  → hard block with reason.
  */
-function decideWrite(policy, filePath) {
-    if (policy === 'anywhere')
+export function decideWrite(agentType, filePath) {
+    const rule = (agentType && WRITE_RULES[agentType]) || 'workspace';
+    if (rule === 'anywhere')
         return { decision: 'defer' };
-    if (policy === 'workspace') {
+    if (rule === 'workspace') {
         if (filePath && !isWorkspacePath(filePath)) {
             return { decision: 'deny', reason: 'Research mode: writes restricted to session workspace.' };
         }
         return { decision: 'allow' };
     }
     // Extension whitelist — fail closed (empty/unknown path denied).
-    const target = policy.matchBasename ? (filePath ? basename(resolve(filePath)) : '') : filePath;
-    if (!filePath || !policy.extensions.test(target)) {
+    const target = rule.matchBasename ? (filePath ? basename(resolve(filePath)) : '') : filePath;
+    if (!filePath || !rule.extensions.test(target)) {
         const reason = filePath
-            ? `Write denied: ${filePath} is not a ${policy.label} file. This agent may only write ${policy.label} files.`
+            ? `Write denied: ${filePath} is not a ${rule.label} file. This agent may only write ${rule.label} files.`
             : 'Write denied: could not determine target file path. Failing closed.';
         return { decision: 'deny', reason };
     }
     return { decision: 'defer' };
 }
-/**
- * Strip/map behavior meta-fields so the roster is a clean AgentDefinition set
- * for the SDK: drop `policy` (enforced in-process by the write-gate) and map
- * `reminder` → criticalSystemReminder_EXPERIMENTAL. NEVER mutates the input.
- */
-function finalizeRoster(agents) {
-    const out = {};
-    for (const [name, agent] of Object.entries(agents)) {
-        const { policy, reminder, ...rest } = agent;
-        if (reminder && !rest.criticalSystemReminder_EXPERIMENTAL) {
-            rest.criticalSystemReminder_EXPERIMENTAL = reminder;
-        }
-        out[name] = rest;
-    }
-    return out;
-}
+// ── 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.
+export const VERIFIER_CHAIN = {
+    writer: { then: ['reviewer', 'tester'], mode: 'parallel' },
+    researcher: { then: ['reasoner'] },
+};
 const RESEARCH_TOOLS = [
     'Read', 'Write', 'Edit', 'Glob', 'Grep',
     'Bash', 'WebSearch', 'WebFetch',
@@ -2016,10 +2006,6 @@ class ClaudeLLMStream extends llm.LLMStream {
                 ? getSessionWorkspace(this.#opts.workingDirectory, sessionId)
                 : null;
             const allowedTools = this.#opts.allowedTools || [];
-            // Roster the PreToolUse write-gate reads policy from — the PRE-strip view
-            // (retains `policy`), so DB-backed custom agents (set_agents) get their
-            // write policy enforced too. The SDK receives the finalized copy (agents:).
-            const enforcementRoster = this.#opts.agents ?? NAMED_AGENTS;
             const sdkOptions = {
                 cwd: this.#opts.workingDirectory,
                 permissionMode: this.#opts.permissionMode,
@@ -2137,23 +2123,22 @@ class ClaudeLLMStream extends llm.LLMStream {
                                         }
                                         console.log(`🔧 Tool call ${turnToolCallCount}/${TOOL_CALL_BUDGET}: ${toolName}`);
                                     }
-                                    // Write/Edit/MultiEdit access control — DATA-DRIVEN by each agent's
-                                    // declarative policy.write (see AgentWritePolicy). Replaces the old
-                                    // hardcoded per-role branches; DB-backed custom agents get enforced too.
+                                    // Write/Edit/MultiEdit access control — plain WRITE_RULES lookup
+                                    // keyed by agent name (see decideWrite). Same behavior the old
+                                    // hardcoded per-role branches had, now in one visible place.
                                     if (toolName === 'Write' || toolName === 'Edit' || toolName === 'MultiEdit') {
                                         const filePath = String(toolInput.file_path || '');
-                                        const policy = resolveWritePolicy(agentType, enforcementRoster);
-                                        const { decision, reason } = decideWrite(policy, filePath);
-                                        console.log(`🔎 Write gate: agent=${agentType ?? 'main'} policy=${JSON.stringify(policy)} path="${filePath || '(none)'}" → ${decision}`);
+                                        const { decision, reason } = decideWrite(agentType, filePath);
+                                        console.log(`🔎 Write gate: agent=${agentType ?? 'main'} path="${filePath || '(none)'}" → ${decision}`);
                                         if (decision === 'deny') {
                                             this.#eventEmitter.emit('tool_blocked', { name: toolName, reason });
                                             return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny' }, reason };
                                         }
                                         if (decision === 'defer') {
-                                            // Writer (write:'anywhere') surfaces its write in the live trace
-                                            // before the permission dialog; adversarial agents (reviewer/tester)
-                                            // do NOT emit here — parity with the prior hardcoded branches.
-                                            if (policy === 'anywhere') {
+                                            // Writer ('anywhere') surfaces its write in the live trace before
+                                            // the permission dialog; adversarial agents (reviewer/tester) do
+                                            // NOT emit here — parity with the prior hardcoded branches.
+                                            if (agentType === 'writer') {
                                                 this.#eventEmitter.emit('tool_use', { name: toolName, input: toolInput, agentRole: agentType || 'main' });
                                             }
                                             return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'ask' } };
@@ -2501,6 +2486,27 @@ 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.`,
+                                    };
+                                }]
+                        }],
                     SubagentStart: [{
                             matcher: '.*',
                             hooks: [async (input) => {
@@ -2518,15 +2524,33 @@ 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 — never re-dispatch the reviewer, tester, or reasoner.
+                                    // 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 {};
-                                    if (at === 'writer' && msg) {
-                                        void this.#llmRef.spawnReviewer(aid, msg, this.#eventEmitter);
-                                        void this.#llmRef.spawnTester(aid, msg, this.#eventEmitter);
-                                    }
-                                    else if (at === 'researcher' && msg) {
-                                        void this.#llmRef.spawnResearchGate(aid, msg, this.#eventEmitter);
+                                    // 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);
+                                        }
                                     }
                                     return {};
                                 }]
@@ -2553,9 +2577,9 @@ class ClaudeLLMStream extends llm.LLMStream {
                 // opts.agents is undefined — the ?? NAMED_AGENTS fallback would skip
                 // the override entirely. Explicitly apply applyTurbo(NAMED_AGENTS)
                 // so built-in agents always get FAST_MODEL when turbo is on.
-                agents: finalizeRoster(applyGrounding(this.#llmRef.turbo
+                agents: applyGrounding(this.#llmRef.turbo
                     ? applyTurbo(this.#opts.agents ?? NAMED_AGENTS, true)
-                    : (this.#opts.agents ?? NAMED_AGENTS), this.#sessionId, this.#opts.workingDirectory)),
+                    : (this.#opts.agents ?? NAMED_AGENTS), this.#sessionId, this.#opts.workingDirectory),
             };
             // Run Claude Agent SDK query() and stream results
             let hasOutput = false;

package/package.json

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