@shawnstack/quickforge 1.3.29 → 1.4.0

package/dist/assets/xterm-BrP-ENHg.css

@@ -0,0 +1 @@
+.xterm{cursor:text;-webkit-user-select:none;user-select:none;position:relative}.xterm.focus,.xterm:focus{outline:none}.xterm .xterm-helpers{z-index:5;position:absolute;top:0}.xterm .xterm-helper-textarea{opacity:0;z-index:-5;white-space:nowrap;resize:none;border:0;width:0;height:0;margin:0;padding:0;position:absolute;top:0;left:-9999em;overflow:hidden}.xterm .composition-view{color:#fff;white-space:nowrap;z-index:1;background:#000;display:none;position:absolute}.xterm .composition-view.active{display:block}.xterm .xterm-viewport{cursor:default;background-color:#000;position:absolute;inset:0;overflow-y:scroll}.xterm .xterm-screen{position:relative}.xterm .xterm-screen canvas{position:absolute;top:0;left:0}.xterm-char-measure-element{visibility:hidden;line-height:normal;display:inline-block;position:absolute;top:0;left:-9999em}.xterm.enable-mouse-events{cursor:default}.xterm.xterm-cursor-pointer,.xterm .xterm-cursor-pointer{cursor:pointer}.xterm.column-select.focus{cursor:crosshair}.xterm .xterm-accessibility:not(.debug),.xterm .xterm-message{z-index:10;color:#0000;pointer-events:none;position:absolute;inset:0}.xterm .xterm-accessibility-tree:not(.debug) ::selection{color:#0000}.xterm .xterm-accessibility-tree{-webkit-user-select:text;user-select:text;white-space:pre;font-family:monospace}.xterm .xterm-accessibility-tree>div{transform-origin:0;width:fit-content}.xterm .live-region{width:1px;height:1px;position:absolute;left:-9999px;overflow:hidden}.xterm-dim{opacity:1!important}.xterm-underline-1{text-decoration:underline}.xterm-underline-2{-webkit-text-decoration:underline double;text-decoration:underline double}.xterm-underline-3{-webkit-text-decoration:underline wavy;text-decoration:underline wavy}.xterm-underline-4{-webkit-text-decoration:underline dotted;text-decoration:underline dotted}.xterm-underline-5{-webkit-text-decoration:underline dashed;text-decoration:underline dashed}.xterm-overline{text-decoration:overline}.xterm-overline.xterm-underline-1{text-decoration:underline overline}.xterm-overline.xterm-underline-2{-webkit-text-decoration:overline double underline;text-decoration:overline double underline}.xterm-overline.xterm-underline-3{-webkit-text-decoration:overline wavy underline;text-decoration:overline wavy underline}.xterm-overline.xterm-underline-4{-webkit-text-decoration:overline dotted underline;text-decoration:overline dotted underline}.xterm-overline.xterm-underline-5{-webkit-text-decoration:overline dashed underline;text-decoration:overline dashed underline}.xterm-strikethrough{text-decoration:line-through}.xterm-screen .xterm-decoration-container .xterm-decoration{z-index:6;position:absolute}.xterm-screen .xterm-decoration-container .xterm-decoration.xterm-decoration-top-layer{z-index:7}.xterm-decoration-overview-ruler{z-index:8;pointer-events:none;position:absolute;top:0;right:0}.xterm-decoration-top{z-index:2;position:relative}.xterm .xterm-scrollable-element>.scrollbar{cursor:default}.xterm .xterm-scrollable-element>.scrollbar>.scra{cursor:pointer;font-size:11px!important}.xterm .xterm-scrollable-element>.visible{opacity:1;z-index:11;background:0 0;transition:opacity .1s linear}.xterm .xterm-scrollable-element>.invisible{opacity:0;pointer-events:none}.xterm .xterm-scrollable-element>.invisible.fade{transition:opacity .8s linear}.xterm .xterm-scrollable-element>.shadow{display:none;position:absolute}.xterm .xterm-scrollable-element>.shadow.top{width:100%;height:3px;box-shadow:var(--vscode-scrollbar-shadow,#000) 0 6px 6px -6px inset;display:block;top:0;left:3px}.xterm .xterm-scrollable-element>.shadow.left{width:3px;height:100%;box-shadow:var(--vscode-scrollbar-shadow,#000) 6px 0 6px -6px inset;display:block;top:3px;left:0}.xterm .xterm-scrollable-element>.shadow.top-left-corner{width:3px;height:3px;display:block;top:0;left:0}.xterm .xterm-scrollable-element>.shadow.top.left{box-shadow:var(--vscode-scrollbar-shadow,#000) 6px 0 6px -6px inset}

package/dist/index.html

@@ -11,13 +11,16 @@
     <meta name="apple-mobile-web-app-title" content="QuickForge" />
     <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
     <title>速构 QuickForge</title>
-    <script type="module" crossorigin src="/assets/index-CnT_4xVs.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/rolldown-runtime-CkqCuyE9.js">
+    <script type="module" crossorigin src="/assets/index-YTL26wyJ.js"></script>
+    <link rel="modulepreload" crossorigin href="/assets/rolldown-runtime-DWdDZTNf.js">
+    <link rel="modulepreload" crossorigin href="/assets/pi-ai-Cx633yhb.js">
     <link rel="modulepreload" crossorigin href="/assets/lit-vendor-Dr3cpBGF.js">
+    <link rel="modulepreload" crossorigin href="/assets/pi-web-ui-CBet4bMl.js">
     <link rel="modulepreload" crossorigin href="/assets/css-utils-rkE68RDy.js">
-    <link rel="modulepreload" crossorigin href="/assets/icons-BVM5--R9.js">
-    <link rel="modulepreload" crossorigin href="/assets/react-vendor-DAoL5p8_.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-CcvNhwdQ.css">
+    <link rel="modulepreload" crossorigin href="/assets/icons-Dsc5yL3l.js">
+    <link rel="modulepreload" crossorigin href="/assets/react-vendor-CiCXOLb5.js">
+    <link rel="modulepreload" crossorigin href="/assets/logger-B65Akg8A.js">
+    <link rel="stylesheet" crossorigin href="/assets/index-CPAWYhzz.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shawnstack/quickforge",
-  "version": "1.3.29",
+  "version": "1.4.0",
   "description": "AI chat application with YOLO-mode local workspace tools. React + Vite + Tailwind CSS frontend, local Node.js storage server.",
   "keywords": [
     "ai",

package/server/agent-manager.mjs

@@ -196,19 +196,14 @@ function createApprovalPromise(session, toolCallId, toolName, args, source) {
       source,
     })
 
-    // Notify the frontend via both the session-level and global event buses.
-    // The global SSE handler (/api/agents/events) only listens to `agentEvents`,
-    // so events emitted only on session.eventBus never reach the client.
-    const approvalEvent = {
+    emitSessionEvent(session, {
       type: 'tool_approval_required',
       sessionId: session.sessionId,
       toolCallId,
       toolName,
       args,
       source,
-    }
-    session.eventBus.emit('agent_event', approvalEvent)
-    agentEvents.emit('agent_event', approvalEvent)
+    })
   })
 }
 
@@ -312,11 +307,18 @@ function estimateTokenReduction(originalChars, finalChars) {
   return Math.max(0, Math.min(99, Math.round(((originalChars - finalChars) / originalChars) * 100)))
 }
 
+function nextSessionStateVersion(session) {
+  const current = Number.isFinite(session?.stateVersion) ? session.stateVersion : 0
+  session.stateVersion = current + 1
+  return session.stateVersion
+}
+
 function emitSessionEvent(session, event) {
+  const stateVersion = nextSessionStateVersion(session)
   const enrichedEvent = (event?.type === 'message_end' || event?.type === 'agent_end' || event?.type === 'messages_replaced' || event?.type === 'auto_compact_completed')
     && event.contextUsage === undefined
-    ? { ...event, contextUsage: getSessionContextUsage(session) }
-    : event
+    ? { ...event, contextUsage: getSessionContextUsage(session), stateVersion }
+    : { ...event, stateVersion }
   session.eventBus.emit('agent_event', enrichedEvent)
   agentEvents.emit('agent_event', { sessionId: session.sessionId, ...enrichedEvent })
 }
@@ -556,7 +558,7 @@ async function resolveCommandState(session, userMessage) {
     return {
       userMessage,
       commandPrompt: formatPlanCommandPrompt(internalResponse.args),
-      permissions: { allowEdit: false, allowCommands: false },
+      permissions: { allowEdit: false, allowCommands: false, allowSubagents: true },
       commandName: 'plan',
     }
   }
@@ -597,6 +599,7 @@ Rules for this turn:
 - Do not run shell commands.
 - Do not use write_file, edit_file, run_command, or any other state-changing tool.
 - You may use read-only tools such as read_file and grep_files if needed to inspect the project.
+- You may delegate bounded read-only research to subagents, but subagents must also obey this /plan turn: no file modifications and no shell commands.
 - Output the plan and then stop. Do not start implementation.
 
 Plan should include:
@@ -681,7 +684,7 @@ async function runSubagent(parentSession, params, parentSignal, onUpdate) {
     true,
     (toolName) => {
       if (!definition.allowedTools.includes(toolName)) return `Subagent ${definition.name} is not allowed to use ${toolName}.`
-      return null
+      return commandToolPermissionError(parentSession, toolName)
     },
     {
       allowedToolNames: definition.allowedTools,
@@ -764,6 +767,8 @@ async function runSubagent(parentSession, params, parentSignal, onUpdate) {
       if (!definition.allowedTools.includes(toolName)) {
         return { block: true, reason: `Subagent ${definition.name} is not allowed to use ${toolName}.` }
       }
+      const commandPermissionError = commandToolPermissionError(parentSession, toolName)
+      if (commandPermissionError) return { block: true, reason: commandPermissionError }
       if (!parentSession.yoloMode) {
         if (safeReadTools.has(toolName)) return undefined
         return createApprovalPromise(parentSession, context.toolCall?.id, toolName, context.args, {
@@ -1135,6 +1140,7 @@ export async function createAgent(sessionId, config = {}) {
     activeCommandPrompt: null,
     eventBus,
     idleTimer: null,
+    persistTimer: null,
     titleGenerated: false,
     toolTimings: new Map(),
     getApiKey,
@@ -1142,6 +1148,7 @@ export async function createAgent(sessionId, config = {}) {
     agentProfile: agentProfile ? agentProfileSnapshot(agentProfile) : null,
     lastTransformedContextMessages: null,
     autoCompacting: false,
+    stateVersion: 0,
     lastAutoCompactAt: null,
     lastAutoCompactRejected: null,
     /** Track active SSE connections. Only one SSE stream allowed per session to prevent
@@ -1156,8 +1163,20 @@ export async function createAgent(sessionId, config = {}) {
     // complete session history.  Replace with the authoritative full state
     // before forwarding to clients.
     const timedEvent = addToolTimingToEvent(session, event)
-    const forwardEvent = timedEvent.type === 'agent_end' && timedEvent.messages
-      ? { ...timedEvent, messages: agent.state.messages }
+    const eventEndStatus = event.type === 'agent_end'
+      ? session.agent.signal?.aborted
+        ? 'aborted'
+        : session.agent.state.errorMessage
+          ? 'error'
+          : 'idle'
+      : undefined
+    const forwardEvent = timedEvent.type === 'agent_end'
+      ? {
+          ...timedEvent,
+          ...(timedEvent.messages ? { messages: agent.state.messages } : {}),
+          status: eventEndStatus,
+          ...(session.agent.state.errorMessage && timedEvent.errorMessage === undefined ? { errorMessage: session.agent.state.errorMessage } : {}),
+        }
       : timedEvent
 
     // Forward all events to the session event bus and the global bus.
@@ -1175,22 +1194,21 @@ export async function createAgent(sessionId, config = {}) {
     }
 
     if (event.type === 'agent_end') {
-      session.status = session.agent.state.errorMessage ? 'error' : 'idle'
+      session.status = eventEndStatus || (session.agent.state.errorMessage ? 'error' : 'idle')
       session.finishedAt = new Date().toISOString()
       session.toolTimings?.clear()
       resetIdleTimer(session)
 
-      // Persist after run ends
-      persistSession(session).catch((err) =>
+      // Persist after run ends. Flush any debounced write so the final state is durable.
+      flushSessionPersist(session).catch((err) =>
         logger.error(`Failed to persist session ${sessionId}:`, err, { sessionId }),
       )
     }
 
     if (event.type === 'message_end') {
-      // Do a lightweight persist on message_end for crash recovery
-      persistSession(session).catch((err) =>
-        logger.error(`Failed to persist session ${sessionId}:`, err, { sessionId }),
-      )
+      // Debounced persist for crash recovery; coalesces the many message_end
+      // events within a single run into infrequent full-session writes.
+      scheduleSessionPersist(session)
     }
   })
 
@@ -1334,6 +1352,44 @@ async function persistSession(session) {
 }
 
 export async function persistSessionState(session) {
+  await flushSessionPersist(session)
+}
+
+/**
+ * Coalesce fire-and-forget session persists during a run.
+ *
+ * persistSession() serializes the ENTIRE session (all messages) on every call,
+ * and the agent event loop calls it on agent_start / each message_end / agent_end.
+ * Within a single run these events fire many times (one per assistant turn +
+ * tool result), so writing on each one makes cumulative disk I/O O(n^2) as a
+ * conversation grows. These message_end call sites are fire-and-forget
+ * (crash-recovery only), so we debounce them into at most one write per
+ * PERSIST_DEBOUNCE_MS. Run boundaries (agent_end) and explicit persists cancel
+ * the pending timer and write the current state immediately, so the final
+ * state is always durable.
+ */
+const PERSIST_DEBOUNCE_MS = 400
+
+function scheduleSessionPersist(session) {
+  if (session.persistTimer) return
+  session.persistTimer = setTimeout(() => {
+    session.persistTimer = null
+    persistSession(session).catch((err) =>
+      logger.error(`Failed to persist session ${session.sessionId}:`, err, { sessionId: session.sessionId }),
+    )
+  }, PERSIST_DEBOUNCE_MS).unref?.()
+}
+
+/**
+ * Cancel any pending debounced write and persist the current state immediately.
+ * Used at run boundaries (agent_end) and by explicit persistSessionState() so
+ * the final state is always durable regardless of a pending timer.
+ */
+async function flushSessionPersist(session) {
+  if (session.persistTimer) {
+    clearTimeout(session.persistTimer)
+    session.persistTimer = null
+  }
   await persistSession(session)
 }
 
@@ -1559,6 +1615,7 @@ export async function abortRun(sessionId) {
     )
     const event = {
       type: 'agent_end',
+      status: 'aborted',
       messages: session.agent.state.messages,
     }
     emitSessionEvent(session, event)
@@ -1628,6 +1685,7 @@ export function getSessionState(sessionId) {
     title: session.title,
     createdAt: session.createdAt,
     lastModified: session.lastModified,
+    stateVersion: session.stateVersion || 0,
     status: session.status,
     startedAt: session.startedAt,
     finishedAt: session.finishedAt,
@@ -1640,6 +1698,33 @@ export function getSessionState(sessionId) {
   }
 }
 
+/**
+ * Get a lightweight status snapshot for SSE-first state recovery.
+ */
+export function getSessionStatus(sessionId) {
+  const session = agentSessions.get(sessionId)
+  if (!session) return null
+
+  const messages = session.agent.state.messages || []
+  const lastMessage = messages[messages.length - 1]
+  return {
+    sessionId: session.sessionId,
+    scope: session.scope,
+    projectId: session.projectId,
+    title: session.title,
+    createdAt: session.createdAt,
+    lastModified: session.lastModified,
+    stateVersion: session.stateVersion || 0,
+    status: session.status,
+    startedAt: session.startedAt,
+    finishedAt: session.finishedAt,
+    isStreaming: session.agent.state.isStreaming,
+    errorMessage: session.agent.state.errorMessage,
+    messageCount: messages.length,
+    lastMessageTimestamp: lastMessage?.timestamp ?? null,
+  }
+}
+
 /**
  * Try to claim the SSE slot for a session. Returns true if acquired, false if
  * another tab already holds the SSE connection for this session.
@@ -1686,6 +1771,10 @@ export async function destroyAgent(sessionId) {
   logger.info(`Destroying session ${sessionId} (status: ${session.status})`, { sessionId, status: session.status })
 
   if (session.idleTimer) clearTimeout(session.idleTimer)
+  if (session.persistTimer) {
+    clearTimeout(session.persistTimer)
+    session.persistTimer = null
+  }
   session.toolTimings?.clear()
 
   try {

package/server/approval-store.mjs

@@ -49,7 +49,7 @@ export function commandToolPermissionError(session, toolName) {
   if (toolName === 'run_command' && permissions.allowCommands === false) {
     return `Command /${session.activeCommandName} does not allow running shell commands.`
   }
-  if (toolName === 'run_subagent' && (permissions.allowSubagents === false || permissions.allowCommands === false)) {
+  if (toolName === 'run_subagent' && permissions.allowSubagents === false) {
     return `Command /${session.activeCommandName} does not allow running subagents.`
   }
   if ((toolName === 'write_file' || toolName === 'edit_file') && permissions.allowEdit === false) {

package/server/auto-compaction.mjs

@@ -222,15 +222,50 @@ export function estimateSessionContextUsage(session, messages = session?.agent?.
   if (sourceMessages.length === 0) {
     return { inputTokens: 0, estimatedInputTokens: 0, knownInputTokens: 0, reservedOutputTokens: 0, totalTokens: 0, contextWindow, percent: 0 }
   }
+
+  // Cache by input identity. estimateContextUsage() scans every message with a
+  // tokenizer regex (O(n)) and JSON-stringifies the full tools array, but its
+  // inputs (messages, model, systemPrompt, tools, contextCompaction) are stable
+  // within a run and only change on discrete events (message_end, tool result,
+  // compaction). Reference equality makes the cache check essentially free, so
+  // the repeated calls from emitSessionEvent() on message_end/agent_end/etc.
+  // only recompute when something actually changed.
+  const lastMessage = sourceMessages[sourceMessages.length - 1]
+  const cacheKey = {
+    messages,
+    messagesLength: sourceMessages.length,
+    lastMessage,
+    model: session.model,
+    systemPrompt: session.agent.state.systemPrompt,
+    tools: session.agent.state.tools,
+    contextCompaction: session.contextCompaction,
+  }
+  const cached = session._contextUsageCache
+  if (
+    cached &&
+    cached.key.messages === cacheKey.messages &&
+    cached.key.messagesLength === cacheKey.messagesLength &&
+    cached.key.lastMessage === cacheKey.lastMessage &&
+    cached.key.model === cacheKey.model &&
+    cached.key.systemPrompt === cacheKey.systemPrompt &&
+    cached.key.tools === cacheKey.tools &&
+    cached.key.contextCompaction === cacheKey.contextCompaction
+  ) {
+    return cached.value
+  }
+
   const loopMessages = buildAutoCompactLoopMessages(session, sourceMessages)
   const knownInputTokens = latestKnownInputTokens(sourceMessages, latestCompactTimestampMs(session))
-  return estimateContextUsage({
+  const value = estimateContextUsage({
     systemPrompt: session.agent.state.systemPrompt,
     messages: loopMessages,
     tools: session.agent.state.tools,
     model: session.model,
     knownInputTokens,
   })
+
+  session._contextUsageCache = { key: cacheKey, value }
+  return value
 }
 
 export async function maybeAutoCompactSession({ session, messages, signal, emitSessionEvent, persistSession, logger, confirmAutoCompact }) {

package/server/index.mjs

@@ -537,6 +537,19 @@ await initializeActiveProject()
 setActiveWorkspaceRootForFilesystem(getWorkspaceRoot())
 startScheduledTaskRunner()
 
+server.on('error', (error) => {
+  // Handle listen errors (most commonly EADDRINUSE). Without this, Node would
+  // throw an uncaught exception and crash with only a raw stack trace in the log.
+  if (error.code === 'EADDRINUSE') {
+    logger.error(`Port ${port} is already in use. QuickForge could not start.`)
+    logger.error('Hint: stop the running instance with "quickforge stop" or "quickforge restart", or use a different port with QUICKFORGE_PORT=<port>.')
+  } else {
+    logger.error(`QuickForge failed to listen on ${host}:${port}: ${error.message}`)
+  }
+  flushLogger()
+  process.exit(1)
+})
+
 server.listen(port, host, () => {
   logger.info(`QuickForge local API: http://${host}:${port}`)
   if (shareLanEnabled) {

package/server/routes/agent.mjs

@@ -6,6 +6,7 @@ import {
   steerAgent,
   followUpAgent,
   getSessionState,
+  getSessionStatus,
   getSessionEventBus,
   tryAcquireSse,
   releaseSse,
@@ -112,6 +113,24 @@ export async function handleAgentApi(req, res, url) {
     return
   }
 
+  // GET /api/agents/:sessionId/status - get lightweight session status
+  if (req.method === 'GET' && subPath === 'status') {
+    let status = getSessionStatus(sessionId)
+    if (!status) {
+      // Try to restore from persistent storage before giving up.
+      // This recovers sessions that were evicted by idle timeout.
+      await restoreAgent(sessionId)
+      status = getSessionStatus(sessionId)
+    }
+    if (!status) {
+      const error = new Error('Session not found')
+      error.statusCode = 404
+      throw error
+    }
+    sendJson(res, 200, status)
+    return
+  }
+
   // POST /api/agents/:sessionId — create/ensure agent
   if (req.method === 'POST' && parts.length === 3) {
     const body = await readJsonBody(req)

package/server/storage.mjs

@@ -705,26 +705,38 @@ export async function atomicProjectConfigUpdate(updateFn) {
   })
 }
 
-export async function ensureStorage() {
-  await fs.mkdir(configDir, { recursive: true })
-  await fs.mkdir(storageDir, { recursive: true })
-  await fs.mkdir(cacheDir, { recursive: true })
-  await fs.mkdir(logsDir, { recursive: true })
-  await Promise.all([
-    fs.mkdir(path.join(cacheDir, 'global', 'llm'), { recursive: true }),
-    fs.mkdir(path.join(cacheDir, 'global', 'tmp'), { recursive: true }),
-    fs.mkdir(path.join(cacheDir, 'projects'), { recursive: true }),
-    fs.mkdir(path.join(storageDir, 'conversations', 'global', 'sessions'), { recursive: true }),
-    fs.mkdir(path.join(storageDir, 'conversations', 'projects'), { recursive: true }),
-    cleanOldLogs(),
-  ])
-
-  await migrateUnifiedConfig()
-
-  await Promise.all([
-    ensureJsonFile(quickForgeConfigFile, defaultConfig()),
-    ensureJsonFile(sessionStoreFile('sessions-metadata', { scope: 'global' })),
-  ])
+// Cached storage-initialization promise.  ensureStorage() is idempotent (mkdir
+// recursive, one-shot migration gated by a marker file, ensureJsonFile), so once
+// it succeeds we can skip the redundant syscalls (~20 per call) every later call
+// would perform.  Reset on failure so the next call can retry.
+let storageInitPromise = null
+
+export function ensureStorage() {
+  if (storageInitPromise) return storageInitPromise
+  storageInitPromise = (async () => {
+    await fs.mkdir(configDir, { recursive: true })
+    await fs.mkdir(storageDir, { recursive: true })
+    await fs.mkdir(cacheDir, { recursive: true })
+    await fs.mkdir(logsDir, { recursive: true })
+    await Promise.all([
+      fs.mkdir(path.join(cacheDir, 'global', 'llm'), { recursive: true }),
+      fs.mkdir(path.join(cacheDir, 'global', 'tmp'), { recursive: true }),
+      fs.mkdir(path.join(cacheDir, 'projects'), { recursive: true }),
+      fs.mkdir(path.join(storageDir, 'conversations', 'global', 'sessions'), { recursive: true }),
+      fs.mkdir(path.join(storageDir, 'conversations', 'projects'), { recursive: true }),
+      cleanOldLogs(),
+    ])
+
+    await migrateUnifiedConfig()
+
+    await Promise.all([
+      ensureJsonFile(quickForgeConfigFile, defaultConfig()),
+      ensureJsonFile(sessionStoreFile('sessions-metadata', { scope: 'global' })),
+    ])
+  })()
+  // Reset on failure so the next call can retry instead of caching a rejection.
+  storageInitPromise.catch(() => { storageInitPromise = null })
+  return storageInitPromise
 }
 
 export async function readStore(storeName) {

package/server/utils/logger.mjs

@@ -136,9 +136,7 @@ function writeLog(level, context, ...args) {
   const jsonLine = JSON.stringify(jsonObj) + '\n'
 
   try {
-    const s = getStream()
     pendingLines.push(jsonLine)
-    s.write(jsonLine) // also try immediate write
     scheduleFlush()
   } catch {
     // ignore write errors