@sideboard-ai/core 0.1.88 → 0.1.89

package/dist/agents/cursor-runner.cjs

@@ -286,6 +286,49 @@ function cursorSdkMessageToEvents(msg) {
   return [];
 }
 
+// src/agents/cursor-stream-coalesce.ts
+function isTextEvent(event) {
+  return event.type === "stdout" || event.type === "thinking";
+}
+function createAgentStreamCoalescer(emit2, opts) {
+  const intervalMs = opts?.intervalMs ?? 32;
+  let pending = null;
+  let timer = null;
+  const flush = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (!pending) return;
+    const event = pending;
+    pending = null;
+    emit2({ type: event.type, data: event.data });
+  };
+  const schedule = () => {
+    if (timer) return;
+    timer = setTimeout(flush, intervalMs);
+    timer.unref?.();
+  };
+  return {
+    push(event) {
+      if (!isTextEvent(event)) {
+        flush();
+        emit2(event);
+        return;
+      }
+      if (!event.data) return;
+      if (pending && pending.type === event.type) {
+        pending.data += event.data;
+      } else {
+        flush();
+        pending = { type: event.type, data: event.data };
+      }
+      schedule();
+    },
+    flush
+  };
+}
+
 // src/agents/cursor-runner.ts
 dropNestedElectronEnvFromProcess();
 function emit(event) {
@@ -442,12 +485,14 @@ async function main() {
     emit({ type: "session_id", data: agent.agentId });
     const run = await sendPrompt(agent);
     liveRun = run;
+    const stream = createAgentStreamCoalescer(emit);
     try {
       for await (const msg of run.stream()) {
         for (const event of cursorSdkMessageToEvents(msg)) {
-          emit(event);
+          stream.push(event);
         }
       }
+      stream.flush();
       const result = await run.wait();
       if (result.status === "error") {
         const detail = formatUnknownDetail(result.error);
@@ -460,6 +505,7 @@ async function main() {
       if (result.status === "cancelled") return 0;
       return 0;
     } finally {
+      stream.flush();
       liveRun = null;
     }
   }

package/dist/agents/cursor-runner.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  createAgentStreamCoalescer
+} from "../chunk-MMI4RJ5I.js";
 import {
   cursorSdkMessageToEvents,
   formatUnknownDetail
@@ -208,12 +211,14 @@ async function main() {
     emit({ type: "session_id", data: agent.agentId });
     const run = await sendPrompt(agent);
     liveRun = run;
+    const stream = createAgentStreamCoalescer(emit);
     try {
       for await (const msg of run.stream()) {
         for (const event of cursorSdkMessageToEvents(msg)) {
-          emit(event);
+          stream.push(event);
         }
       }
+      stream.flush();
       const result = await run.wait();
       if (result.status === "error") {
         const detail = formatUnknownDetail(result.error);
@@ -226,6 +231,7 @@ async function main() {
       if (result.status === "cancelled") return 0;
       return 0;
     } finally {
+      stream.flush();
       liveRun = null;
     }
   }

package/dist/chunk-MMI4RJ5I.js

@@ -0,0 +1,46 @@
+// src/agents/cursor-stream-coalesce.ts
+function isTextEvent(event) {
+  return event.type === "stdout" || event.type === "thinking";
+}
+function createAgentStreamCoalescer(emit, opts) {
+  const intervalMs = opts?.intervalMs ?? 32;
+  let pending = null;
+  let timer = null;
+  const flush = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (!pending) return;
+    const event = pending;
+    pending = null;
+    emit({ type: event.type, data: event.data });
+  };
+  const schedule = () => {
+    if (timer) return;
+    timer = setTimeout(flush, intervalMs);
+    timer.unref?.();
+  };
+  return {
+    push(event) {
+      if (!isTextEvent(event)) {
+        flush();
+        emit(event);
+        return;
+      }
+      if (!event.data) return;
+      if (pending && pending.type === event.type) {
+        pending.data += event.data;
+      } else {
+        flush();
+        pending = { type: event.type, data: event.data };
+      }
+      schedule();
+    },
+    flush
+  };
+}
+
+export {
+  createAgentStreamCoalescer
+};

package/dist/index.cjs

@@ -10441,6 +10441,51 @@ function normalizeParseResult(parsed) {
 // src/agents/spawn.ts
 init_path();
 init_usage();
+
+// src/agents/cursor-stream-coalesce.ts
+function isTextEvent(event) {
+  return event.type === "stdout" || event.type === "thinking";
+}
+function createAgentStreamCoalescer(emit, opts) {
+  const intervalMs = opts?.intervalMs ?? 32;
+  let pending = null;
+  let timer = null;
+  const flush = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (!pending) return;
+    const event = pending;
+    pending = null;
+    emit({ type: event.type, data: event.data });
+  };
+  const schedule = () => {
+    if (timer) return;
+    timer = setTimeout(flush, intervalMs);
+    timer.unref?.();
+  };
+  return {
+    push(event) {
+      if (!isTextEvent(event)) {
+        flush();
+        emit(event);
+        return;
+      }
+      if (!event.data) return;
+      if (pending && pending.type === event.type) {
+        pending.data += event.data;
+      } else {
+        flush();
+        pending = { type: event.type, data: event.data };
+      }
+      schedule();
+    },
+    flush
+  };
+}
+
+// src/agents/spawn.ts
 async function spawnAgentTurn(thread, input, onEvent) {
   ensureAgentPath();
   if (!thread.worktreePath?.trim()) {
@@ -10495,12 +10540,13 @@ async function spawnAgentTurn(thread, input, onEvent) {
   let assistantText = "";
   let parts = [];
   let usage = null;
+  const outbound = createAgentStreamCoalescer(onEvent);
   const consume = (stream, kind) => {
     if (!stream) return;
     const rl = (0, import_node_readline2.createInterface)({ input: stream, crlfDelay: Infinity });
     rl.on("line", (line) => {
       if (kind === "stderr") {
-        onEvent({ type: "stderr", data: line });
+        outbound.push({ type: "stderr", data: line });
         return;
       }
       let events = normalizeParseResult(adapter.parseEvent(line));
@@ -10515,12 +10561,12 @@ async function spawnAgentTurn(thread, input, onEvent) {
       for (const parsed of events) {
         if (parsed.type === "session_id") {
           sessionId = parsed.data;
-          onEvent(parsed);
+          outbound.push(parsed);
           continue;
         }
         if (parsed.type === "usage") {
           usage = applyTurnUsage(usage, parsed.data, parsed.scope ?? "request");
-          onEvent(parsed);
+          outbound.push(parsed);
           continue;
         }
         if (parsed.type === "stdout") {
@@ -10533,13 +10579,14 @@ async function spawnAgentTurn(thread, input, onEvent) {
           assistantText += parsed.data;
         }
         parts = applyAgentEvent(parts, parsed);
-        onEvent(parsed);
+        outbound.push(parsed);
       }
     });
   };
   consume(child.stdout, "stdout");
   consume(child.stderr, "stderr");
   const done = child.then((result) => {
+    outbound.flush();
     const exitCode = result.exitCode ?? null;
     onEvent({ type: "exit", data: exitCode });
     const finalized = finalizeParts(parts);
@@ -15560,10 +15607,12 @@ var Orchestrator = class {
           if (event.type === "stderr" && typeof event.data === "string") {
             pushTurnStderr(stderrTail, event.data);
           }
-          const live = readThread(threadId);
-          if (live?.lastError?.includes("reconciled on startup") && (this.activeTurns.has(threadId) || this.startingTurns.has(threadId))) {
-            setStatus(threadId, "running");
-            this.emit({ type: "status_changed", threadId, status: "running" });
+          if (event.type !== "stdout" && event.type !== "thinking") {
+            const live = readThread(threadId);
+            if (live?.lastError?.includes("reconciled on startup") && (this.activeTurns.has(threadId) || this.startingTurns.has(threadId))) {
+              setStatus(threadId, "running");
+              this.emit({ type: "status_changed", threadId, status: "running" });
+            }
           }
         }
       );

package/dist/index.js

@@ -124,6 +124,9 @@ import {
   resolvePlanMarkdown,
   writePlanFile
 } from "./chunk-QTUESPAW.js";
+import {
+  createAgentStreamCoalescer
+} from "./chunk-MMI4RJ5I.js";
 import {
   cursorSdkMessageToEvents,
   fallbackTurnFailDetail,
@@ -1372,12 +1375,13 @@ async function spawnAgentTurn(thread, input, onEvent) {
   let assistantText = "";
   let parts = [];
   let usage = null;
+  const outbound = createAgentStreamCoalescer(onEvent);
   const consume = (stream, kind) => {
     if (!stream) return;
     const rl = createInterface({ input: stream, crlfDelay: Infinity });
     rl.on("line", (line) => {
       if (kind === "stderr") {
-        onEvent({ type: "stderr", data: line });
+        outbound.push({ type: "stderr", data: line });
         return;
       }
       let events = normalizeParseResult(adapter.parseEvent(line));
@@ -1392,12 +1396,12 @@ async function spawnAgentTurn(thread, input, onEvent) {
       for (const parsed of events) {
         if (parsed.type === "session_id") {
           sessionId = parsed.data;
-          onEvent(parsed);
+          outbound.push(parsed);
           continue;
         }
         if (parsed.type === "usage") {
           usage = applyTurnUsage(usage, parsed.data, parsed.scope ?? "request");
-          onEvent(parsed);
+          outbound.push(parsed);
           continue;
         }
         if (parsed.type === "stdout") {
@@ -1410,13 +1414,14 @@ async function spawnAgentTurn(thread, input, onEvent) {
           assistantText += parsed.data;
         }
         parts = applyAgentEvent(parts, parsed);
-        onEvent(parsed);
+        outbound.push(parsed);
       }
     });
   };
   consume(child.stdout, "stdout");
   consume(child.stderr, "stderr");
   const done = child.then((result) => {
+    outbound.flush();
     const exitCode = result.exitCode ?? null;
     onEvent({ type: "exit", data: exitCode });
     const finalized = finalizeParts(parts);
@@ -6354,10 +6359,12 @@ var Orchestrator = class {
           if (event.type === "stderr" && typeof event.data === "string") {
             pushTurnStderr(stderrTail, event.data);
           }
-          const live = readThread(threadId);
-          if (live?.lastError?.includes("reconciled on startup") && (this.activeTurns.has(threadId) || this.startingTurns.has(threadId))) {
-            setStatus(threadId, "running");
-            this.emit({ type: "status_changed", threadId, status: "running" });
+          if (event.type !== "stdout" && event.type !== "thinking") {
+            const live = readThread(threadId);
+            if (live?.lastError?.includes("reconciled on startup") && (this.activeTurns.has(threadId) || this.startingTurns.has(threadId))) {
+              setStatus(threadId, "running");
+              this.emit({ type: "status_changed", threadId, status: "running" });
+            }
           }
         }
       );

package/dist/mcp/run-stdio.cjs

@@ -9312,6 +9312,51 @@ function normalizeParseResult(parsed) {
 // src/agents/spawn.ts
 init_path();
 init_usage();
+
+// src/agents/cursor-stream-coalesce.ts
+function isTextEvent(event) {
+  return event.type === "stdout" || event.type === "thinking";
+}
+function createAgentStreamCoalescer(emit, opts) {
+  const intervalMs = opts?.intervalMs ?? 32;
+  let pending = null;
+  let timer = null;
+  const flush = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (!pending) return;
+    const event = pending;
+    pending = null;
+    emit({ type: event.type, data: event.data });
+  };
+  const schedule = () => {
+    if (timer) return;
+    timer = setTimeout(flush, intervalMs);
+    timer.unref?.();
+  };
+  return {
+    push(event) {
+      if (!isTextEvent(event)) {
+        flush();
+        emit(event);
+        return;
+      }
+      if (!event.data) return;
+      if (pending && pending.type === event.type) {
+        pending.data += event.data;
+      } else {
+        flush();
+        pending = { type: event.type, data: event.data };
+      }
+      schedule();
+    },
+    flush
+  };
+}
+
+// src/agents/spawn.ts
 async function spawnAgentTurn(thread, input, onEvent) {
   ensureAgentPath();
   if (!thread.worktreePath?.trim()) {
@@ -9366,12 +9411,13 @@ async function spawnAgentTurn(thread, input, onEvent) {
   let assistantText = "";
   let parts = [];
   let usage = null;
+  const outbound = createAgentStreamCoalescer(onEvent);
   const consume = (stream, kind) => {
     if (!stream) return;
     const rl = (0, import_node_readline2.createInterface)({ input: stream, crlfDelay: Infinity });
     rl.on("line", (line) => {
       if (kind === "stderr") {
-        onEvent({ type: "stderr", data: line });
+        outbound.push({ type: "stderr", data: line });
         return;
       }
       let events = normalizeParseResult(adapter.parseEvent(line));
@@ -9386,12 +9432,12 @@ async function spawnAgentTurn(thread, input, onEvent) {
       for (const parsed of events) {
         if (parsed.type === "session_id") {
           sessionId = parsed.data;
-          onEvent(parsed);
+          outbound.push(parsed);
           continue;
         }
         if (parsed.type === "usage") {
           usage = applyTurnUsage(usage, parsed.data, parsed.scope ?? "request");
-          onEvent(parsed);
+          outbound.push(parsed);
           continue;
         }
         if (parsed.type === "stdout") {
@@ -9404,13 +9450,14 @@ async function spawnAgentTurn(thread, input, onEvent) {
           assistantText += parsed.data;
         }
         parts = applyAgentEvent(parts, parsed);
-        onEvent(parsed);
+        outbound.push(parsed);
       }
     });
   };
   consume(child.stdout, "stdout");
   consume(child.stderr, "stderr");
   const done = child.then((result) => {
+    outbound.flush();
     const exitCode = result.exitCode ?? null;
     onEvent({ type: "exit", data: exitCode });
     const finalized = finalizeParts(parts);
@@ -13624,10 +13671,12 @@ var Orchestrator = class {
           if (event.type === "stderr" && typeof event.data === "string") {
             pushTurnStderr(stderrTail, event.data);
           }
-          const live = readThread(threadId);
-          if (live?.lastError?.includes("reconciled on startup") && (this.activeTurns.has(threadId) || this.startingTurns.has(threadId))) {
-            setStatus(threadId, "running");
-            this.emit({ type: "status_changed", threadId, status: "running" });
+          if (event.type !== "stdout" && event.type !== "thinking") {
+            const live = readThread(threadId);
+            if (live?.lastError?.includes("reconciled on startup") && (this.activeTurns.has(threadId) || this.startingTurns.has(threadId))) {
+              setStatus(threadId, "running");
+              this.emit({ type: "status_changed", threadId, status: "running" });
+            }
           }
         }
       );

package/dist/mcp/run-stdio.js

@@ -888,6 +888,49 @@ function normalizeParseResult(parsed) {
   return Array.isArray(parsed) ? parsed : [parsed];
 }
 
+// src/agents/cursor-stream-coalesce.ts
+function isTextEvent(event) {
+  return event.type === "stdout" || event.type === "thinking";
+}
+function createAgentStreamCoalescer(emit, opts) {
+  const intervalMs = opts?.intervalMs ?? 32;
+  let pending = null;
+  let timer = null;
+  const flush = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (!pending) return;
+    const event = pending;
+    pending = null;
+    emit({ type: event.type, data: event.data });
+  };
+  const schedule = () => {
+    if (timer) return;
+    timer = setTimeout(flush, intervalMs);
+    timer.unref?.();
+  };
+  return {
+    push(event) {
+      if (!isTextEvent(event)) {
+        flush();
+        emit(event);
+        return;
+      }
+      if (!event.data) return;
+      if (pending && pending.type === event.type) {
+        pending.data += event.data;
+      } else {
+        flush();
+        pending = { type: event.type, data: event.data };
+      }
+      schedule();
+    },
+    flush
+  };
+}
+
 // src/agents/spawn.ts
 async function spawnAgentTurn(thread, input, onEvent) {
   ensureAgentPath();
@@ -943,12 +986,13 @@ async function spawnAgentTurn(thread, input, onEvent) {
   let assistantText = "";
   let parts = [];
   let usage = null;
+  const outbound = createAgentStreamCoalescer(onEvent);
   const consume = (stream, kind) => {
     if (!stream) return;
     const rl = createInterface({ input: stream, crlfDelay: Infinity });
     rl.on("line", (line) => {
       if (kind === "stderr") {
-        onEvent({ type: "stderr", data: line });
+        outbound.push({ type: "stderr", data: line });
         return;
       }
       let events = normalizeParseResult(adapter.parseEvent(line));
@@ -963,12 +1007,12 @@ async function spawnAgentTurn(thread, input, onEvent) {
       for (const parsed of events) {
         if (parsed.type === "session_id") {
           sessionId = parsed.data;
-          onEvent(parsed);
+          outbound.push(parsed);
           continue;
         }
         if (parsed.type === "usage") {
           usage = applyTurnUsage(usage, parsed.data, parsed.scope ?? "request");
-          onEvent(parsed);
+          outbound.push(parsed);
           continue;
         }
         if (parsed.type === "stdout") {
@@ -981,13 +1025,14 @@ async function spawnAgentTurn(thread, input, onEvent) {
           assistantText += parsed.data;
         }
         parts = applyAgentEvent(parts, parsed);
-        onEvent(parsed);
+        outbound.push(parsed);
       }
     });
   };
   consume(child.stdout, "stdout");
   consume(child.stderr, "stderr");
   const done = child.then((result) => {
+    outbound.flush();
     const exitCode = result.exitCode ?? null;
     onEvent({ type: "exit", data: exitCode });
     const finalized = finalizeParts(parts);
@@ -5136,10 +5181,12 @@ var Orchestrator = class {
           if (event.type === "stderr" && typeof event.data === "string") {
             pushTurnStderr(stderrTail, event.data);
           }
-          const live = readThread(threadId);
-          if (live?.lastError?.includes("reconciled on startup") && (this.activeTurns.has(threadId) || this.startingTurns.has(threadId))) {
-            setStatus(threadId, "running");
-            this.emit({ type: "status_changed", threadId, status: "running" });
+          if (event.type !== "stdout" && event.type !== "thinking") {
+            const live = readThread(threadId);
+            if (live?.lastError?.includes("reconciled on startup") && (this.activeTurns.has(threadId) || this.startingTurns.has(threadId))) {
+              setStatus(threadId, "running");
+              this.emit({ type: "status_changed", threadId, status: "running" });
+            }
           }
         }
       );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sideboard-ai/core",
-  "version": "0.1.88",
+  "version": "0.1.89",
   "description": "Sideboard core — orchestration, agents, git worktrees, MCP server",
   "license": "Apache-2.0",
   "type": "module",