osborn 0.9.244 → 0.9.246

package/dist/claude-llm.js

@@ -1002,25 +1002,63 @@ class MessageChannel {
  * refuses, caps, or blocks a dispatch — the agent reads it and decides. Returns
  * '' on any error so it can never break the turn.
  */
-function buildMachineNudge() {
+/**
+ * Instant CPU busy% from /proc/stat (Linux). One aggregate 'cpu' line: idle+iowait
+ * vs total. Two reads a short interval apart give real-time utilization across all
+ * cores — unlike the 1-min loadavg, which lags a fresh burst of heavy commands by
+ * ~30-60s. Returns null off-Linux / on any parse error (caller falls back to loadavg).
+ */
+function readProcStatCpu() {
+    try {
+        const line = readFileSync('/proc/stat', 'utf8').split('\n', 1)[0];
+        const n = line.trim().split(/\s+/).slice(1).map(Number); // drop the "cpu" label
+        if (n.length < 5 || n.some(Number.isNaN))
+            return null;
+        const idle = n[3] + (n[4] || 0); // idle + iowait
+        const total = n.reduce((a, b) => a + b, 0);
+        return { idle, total };
+    }
+    catch {
+        return null;
+    }
+}
+async function buildMachineNudge() {
     try {
         const ncpu = Math.max(1, cpus().length);
-        const cpuPct = Math.round((loadavg()[0] / ncpu) * 100); // 1-min load ÷ cores
+        // #3: prefer an INSTANT CPU read (proc/stat delta over ~200ms) over the lagging
+        // 1-min loadavg, so a fresh storm of tsc/build/test shows up on THIS turn, not a
+        // minute later. Falls back to loadavg÷cores off-Linux or if the delta is unusable.
+        let cpuPct;
+        const a = readProcStatCpu();
+        if (a) {
+            await new Promise((r) => setTimeout(r, 200));
+            const b = readProcStatCpu();
+            const dTotal = b ? b.total - a.total : 0;
+            cpuPct = b && dTotal > 0
+                ? Math.round(((dTotal - (b.idle - a.idle)) / dTotal) * 100)
+                : Math.round((loadavg()[0] / ncpu) * 100);
+        }
+        else {
+            cpuPct = Math.round((loadavg()[0] / ncpu) * 100);
+        }
         const memPct = Math.round((1 - freemem() / totalmem()) * 100);
         const subagents = statusManager.getActiveDispatchIds().length;
-        // Recommended concurrent heavy sub-agents, adapted to live headroom. This is a
-        // concrete DEFAULT the agent should follow unless a task genuinely warrants
-        // otherwise — surfaced as an actual number/target, never enforced.
+        // Recommended concurrent heavy sub-agents, adapted to live headroom. A concrete
+        // DEFAULT the agent follows unless a task warrants otherwise — never enforced.
         const recMax = (cpuPct >= 80 || memPct >= 90) ? Math.max(1, ncpu - 1) // hot: pull back below cores
             : (cpuPct >= 60) ? ncpu // busy: ~cores
                 : ncpu + 1; // calm: a little headroom
         const over = subagents > recMax;
         const warn = over || cpuPct >= 80;
-        const head = `[MACHINE${warn ? ' ⚠️' : ''}] CPU ~${cpuPct}% · MEM ${memPct}% · sub-agents ${subagents}/${recMax} recommended`;
+        // #4: name the actual CPU culprits — the spikes come from heavy COMMANDS sub-agents
+        // run, not their count. One tsc/build/test pegs a core for 30-120s; ten file-reading
+        // agents barely register. Tell the agent WHAT to throttle.
+        const culprits = 'CPU cost is heavy commands (tsc/typecheck, build, test, npm/pnpm install, eslint) — not agent count. Prefer scoped/incremental runs, cache, and never fire several at once.';
+        const head = `[MACHINE${warn ? ' ⚠️' : ''}] CPU ${cpuPct}% · MEM ${memPct}% · sub-agents ${subagents}/${recMax} recommended`;
         if (over)
-            return `${head} — over the recommended concurrency; wind down to ≤${recMax} (finish or stop in-flight sub-agents) unless a task must continue. (recommendation — the agent decides, not enforced)`;
+            return `${head} — over the recommended concurrency; wind down to ≤${recMax} (finish or stop in-flight sub-agents) unless a task must continue. ${culprits} (recommendation — the agent decides, not enforced)`;
         if (cpuPct >= 80)
-            return `${head} — load high; hold new sub-agents beyond ${recMax} unless needed. (recommendation — the agent decides, not enforced)`;
+            return `${head} — load high; hold new sub-agents beyond ${recMax} unless needed. ${culprits} (recommendation — the agent decides, not enforced)`;
         return head;
     }
     catch {
@@ -1779,6 +1817,10 @@ class ClaudeLLMStream extends llm.LLMStream {
     #abortController;
     #llmRef;
     #approvedWriterToolUseIds = new Set();
+    // Last Task/Agent dispatch description per subagent_type, captured at PreToolUse so
+    // SubagentStart can label the Running row with WHAT the sub-agent is doing even if the
+    // SDK hook input omits the prompt. Cleared when consumed by the matching start.
+    #pendingTaskByType = new Map();
     constructor(llmInstance, { chatCtx, toolCtx, connOptions, opts, sessionId, onSessionId, eventEmitter, onCheckpoint, onPermissionRequest, abortController, }) {
         super(llmInstance, { chatCtx, toolCtx, connOptions });
         this.#llmRef = llmInstance;
@@ -1988,6 +2030,14 @@ class ClaudeLLMStream extends llm.LLMStream {
                                         // tool_use, returns {} → canUseTool workspace auto-approve).
                                     }
                                     console.log(`🔧 Claude: ${toolName}`);
+                                    // Capture the dispatch description/prompt per subagent_type so SubagentStart
+                                    // can show WHAT a sub-agent is working on (see #pendingTaskByType).
+                                    if (toolName === 'Task' || toolName === 'Agent') {
+                                        const st = String(toolInput?.subagent_type || toolInput?.agent_type || '');
+                                        const d = String(toolInput?.description || toolInput?.prompt || '');
+                                        if (st && d)
+                                            this.#pendingTaskByType.set(st, d);
+                                    }
                                     this.#eventEmitter.emit('tool_use', { name: toolName, input: toolInput, agentRole: agentType || 'main' });
                                     return {};
                                 }]
@@ -2064,7 +2114,7 @@ class ClaudeLLMStream extends llm.LLMStream {
                                         // Lightweight machine-load nudge (main agent only). Cheap synchronous
                                         // snapshot, prepended so it's present even when recall degrades under load.
                                         // Advisory only — never caps/refuses a dispatch.
-                                        const machineNudge = fromSubagent ? '' : buildMachineNudge();
+                                        const machineNudge = fromSubagent ? '' : await buildMachineNudge();
                                         const additionalContext = [machineNudge, reminder, recalled].filter(Boolean).join('\n\n');
                                         console.log(`📌 UserPromptSubmit: injected turn-shape reminder (${reminder.length} chars)${recalled ? ` + recall (${recalled.length} chars)` : ''}${machineNudge ? ` + machine(${machineNudge.includes('⚠️') ? 'HOT' : 'ok'})` : ''} for prompt="${promptPreview}..." [tool budget reset to 0/${TOOL_CALL_BUDGET}]`);
                                         return {
@@ -2357,7 +2407,16 @@ class ClaudeLLMStream extends llm.LLMStream {
                             matcher: '.*',
                             hooks: [async (input) => {
                                     console.log('[LIFECYCLE-PROBE] SubagentStart', JSON.stringify(input));
-                                    this.#eventEmitter.emit('agent_started', { agent_type: input?.agent_type, agent_id: input?.agent_id });
+                                    // Surface WHAT the sub-agent was dispatched to do (not just its type) so the
+                                    // Running panel shows the task while it's in flight, before any result lands.
+                                    // The SDK hook may carry the initial prompt/description; fall back to the last
+                                    // Task/Agent dispatch of this type captured at PreToolUse. Best-effort.
+                                    const at0 = input?.agent_type;
+                                    const rawTask = input?.prompt ?? input?.description ?? (at0 ? this.#pendingTaskByType.get(String(at0)) : undefined);
+                                    if (at0)
+                                        this.#pendingTaskByType.delete(String(at0));
+                                    const task = rawTask ? String(rawTask).replace(/\s+/g, ' ').trim().slice(0, 160) : undefined;
+                                    this.#eventEmitter.emit('agent_started', { agent_type: input?.agent_type, agent_id: input?.agent_id, task });
                                     // Record the dispatch as LIVE so the frontend can reconcile orphaned
                                     // "running" rows against statusManager.getActiveDispatchIds(). Without a
                                     // start-time entry the manager only knew about dispatches at completion,

package/package.json

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