osborn 0.9.233 → 0.9.235

package/dist/claude-llm.js

@@ -95,6 +95,15 @@ async function buildRecallInjection(sessionId, workingDir, prompt) {
 // agent's direct tool calls count against the budget.
 let turnToolCallCount = 0;
 const TOOL_CALL_BUDGET = 5;
+// Writer PROVENANCE REMINDER (Chesterton's Fence): before the writer mutates a
+// version-controlled file it should review that file's git history so the edit is
+// backward-informed (root cause / prior + reverted attempts / cross-component coupling),
+// not forward-only. Delivered as a ONE-SHOT PreToolUse deny-with-reminder on the writer's
+// first edit of an existing file each turn. This single flag is the irreducible minimum:
+// a PreToolUse hook can only allow/deny/ask (no "inject note + proceed"), so the reminder
+// must be a deny — and without a "already nudged this turn" flag that deny would loop
+// forever. Reset on every UserPromptSubmit (new turn).
+let writerHistoryReminded = false;
 /**
  * Strip markdown formatting for TTS (text-to-speech)
  * Removes **bold**, ##headers, ```code```, etc. so TTS doesn't read them literally
@@ -493,6 +502,13 @@ export const NAMED_AGENTS = {
             '4. If ANYTHING has drifted from the plan (file moved, code refactored, dependency changed):',
             '   STOP and report back to the main agent. Do NOT improvise.',
             '',
+            '### Step 1b: Review history before touching a versioned file',
+            'For any file that ALREADY EXISTS (i.e. has git history), review its lineage BEFORE you edit it (on your first edit of an existing file each turn you\'ll get a one-time reminder to). This is Chesterton\'s Fence — understand WHY the code is there before you change it. Do:',
+            '  1. `git log --follow -p -- "<file>"` — recent commits and the rationale behind them.',
+            '  2. `git blame` on the exact lines you will change — who/when/which commit introduced them.',
+            '  3. `git log --oneline --grep=<feature>` and `git log --oneline -S"<symbol>"` — look for related OR REVERTED work so you do not redo something already tried, and note which components were co-changed (coupling).',
+            'Fix problems backward-informed — root cause, systemic implications, prior attempts — not forward-only. New files are exempt (no history to review).',
+            '',
             '### Step 2: Clarify unknowns',
             '1. If the plan is vague or ambiguous — ask the main agent a specific clarifying question.',
             '   Examples: "Which config format — YAML or JSON?", "New file or extend existing auth.ts?"',
@@ -1583,8 +1599,15 @@ export class ClaudeLLM extends llm.LLM {
                 if (msg.requestId) {
                     callbacks.eventEmitter.emit('query_request_id', { requestId: msg.requestId });
                 }
-                // Stream assistant text → tts_say events
-                if (msg.type === 'assistant' && msg.message?.content) {
+                // Stream assistant text → tts_say events.
+                // SUBAGENT GUARD (regression fix): the SDK surfaces a Task sub-agent's assistant
+                // messages inline in THIS same stream, tagged with a non-null parent_tool_use_id
+                // ("non-null when the message was produced inside a subagent" — SDK docs). Only the
+                // MAIN orchestrator (parent_tool_use_id === null) may speak or post a chat bubble;
+                // a sub-agent's raw narration must NOT reach TTS/UI (its work already shows via the
+                // tool_use activity events). Without this, once verifiers/researcher became real Task
+                // sub-agents their text "took over the mic" and leaked raw code/markdown into audio.
+                if (msg.type === 'assistant' && msg.message?.content && !msg.parent_tool_use_id) {
                     // Assign a stable messageId for this turn (first block sets it, rest reuse)
                     if (!this.#currentTurnMessageId) {
                         this.#currentTurnMessageId = crypto.randomUUID();
@@ -1866,6 +1889,25 @@ class ClaudeLLMStream extends llm.LLMStream {
                                     // hardcoded per-role branches had, now in one visible place.
                                     if (toolName === 'Write' || toolName === 'Edit' || toolName === 'MultiEdit') {
                                         const filePath = String(toolInput.file_path || '');
+                                        // Writer PROVENANCE REMINDER (Chesterton's Fence): on the writer's FIRST edit of
+                                        // an EXISTING (version-controlled) file this turn, deny ONCE with a reminder to
+                                        // review the file's git history so the change is backward-informed (root cause,
+                                        // prior/reverted attempts, cross-component coupling), not forward-only — then it
+                                        // proceeds. New files are exempt (no history). One-shot per turn so it can't loop.
+                                        if (agentType === 'writer' && filePath && existsSync(filePath) && !writerHistoryReminded) {
+                                            writerHistoryReminded = true;
+                                            const base = filePath.split('/').pop() || filePath;
+                                            const gateReason = [
+                                                `Before editing ${base}, first review its history so your change is backward-informed, not forward-only (Chesterton's Fence — understand WHY this code exists before changing it):`,
+                                                `  1. git log --follow -p -- "${filePath}"   (recent commits + rationale)`,
+                                                `  2. git blame the specific lines you're about to change   (who/when/which commit)`,
+                                                `  3. git log --oneline --grep=<feature>  and  git log --oneline -S"<symbol>"   (related OR reverted work so you don't redo something already tried; note components co-changed in those commits)`,
+                                                `Then re-attempt this edit. (One-time reminder this turn; new files are exempt.)`,
+                                            ].join('\n');
+                                            console.log(`🏛️  Writer provenance reminder: nudging before ${base} (first edit of an existing file this turn)`);
+                                            this.#eventEmitter.emit('tool_blocked', { name: toolName, reason: `Review ${base}'s git history first (one-time provenance reminder).` });
+                                            return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny' }, reason: gateReason };
+                                        }
                                         const { decision, reason } = decideWrite(agentType, filePath);
                                         console.log(`🔎 Write gate: agent=${agentType ?? 'main'} path="${filePath || '(none)'}" → ${decision}`);
                                         if (decision === 'deny') {
@@ -1937,6 +1979,8 @@ class ClaudeLLMStream extends llm.LLMStream {
                                     try {
                                         // Reset the per-turn tool call counter so the new turn starts fresh.
                                         turnToolCallCount = 0;
+                                        // Reset the writer provenance-reminder flag for the new turn.
+                                        writerHistoryReminded = false;
                                         const reminder = readFileSync(TURN_SHAPE_REMINDER_PATH, 'utf-8');
                                         const promptPreview = String(input?.prompt || '').substring(0, 60).replace(/\n/g, ' ');
                                         // Reliable recall: retrieve prior messages relevant to THIS prompt and inject
@@ -2391,7 +2435,9 @@ class ClaudeLLMStream extends llm.LLMStream {
                     this.#onCheckpoint(checkpointId);
                 }
                 // Stream text chunks — send each assistant text block to TTS
-                if (message.type === 'assistant' && message.message?.content) {
+                // SUBAGENT GUARD (see the persistent-consumer loop above): skip sub-agent messages
+                // (non-null parent_tool_use_id) so only the main orchestrator's text speaks/streams.
+                if (message.type === 'assistant' && message.message?.content && !message.parent_tool_use_id) {
                     // Emit SDK requestId on first assistant message — identifies this query()
                     // in the JSONL for tracking which research task produced which output
                     const sdkRequestId = message.requestId;

package/package.json

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