cleanup: remove TEMP stderr diagnostics from rc3-rc5

Remove the [bcode]/[bcode-laminar] stderr lines that helped localize the headless V4 shutdown hook bugs. The actual fixes (async shutdown hook, pending-flush tracking, drop of sdk.shutdown bus race, drop of broken trace.getTracerProvider().forceFlush fallback) stay.

Verified rc6 on V4 staging: trace b2837d1e-... has the bcode-laminar turn span landed with all session.llm/ai.streamText.doStream/bash spans correctly parented. Multi-turn trace 4f53f62c-... (10 LLM rounds) also clean. Only remaining orphan is the v4.run cloud-control-plane span (separate known bug -- CP emits to wrong Laminar project).

Author: bcode

packages/bcode-laminar/src/plugin.ts

@@ -90,92 +90,44 @@ export const LaminarPlugin: Plugin = ({ client }) => {
         config.experimental = { ...(config.experimental ?? {}), openTelemetry: true }
       }
     },
-    // Synchronous end-of-turn drain. The bus-based session.idle /
-    // server.instance.disposed events race with Effect scope teardown in
-    // headless `bcode run` mode and don't reliably deliver, so the turn span
-    // was historically being left un-ended and never exported. The host calls
-    // this hook from its top-level finally before forceFlush, so span.end()
-    // here gets its export drained by the host's existing forceFlush race.
+    // End-of-process drain. The host calls this from its top-level finally
+    // before `process.exit()`. Awaits any forceFlush Promises kicked off by
+    // bus event handlers (session.idle, session.deleted) — those are orphan
+    // microtasks from the host's perspective and `process.exit()` would kill
+    // their in-flight OTLP HTTP exports otherwise. Host bounds this with
+    // `Promise.race([hooks, 3000ms])` so a wedged exporter cannot hang exit.
     shutdown: async () => {
-      // End any still-open turn spans, then drain. Awaits both an explicit
-      // forceFlush AND any pendingFlushes kicked off by the bus event
-      // handlers (session.idle, session.deleted) that the host doesn't
-      // otherwise wait for. The host's `Promise.race([hooks, 3000ms])`
-      // bounds this so a wedged exporter cannot hang `process.exit()`.
-      //
-      // The pendingFlushes set is the critical fix: session.idle's await
-      // on processor.forceFlush() is an orphan microtask from the host's
-      // perspective — it kicks off the OTLP HTTP export but `process.exit()`
-      // would kill the request mid-flight without us tracking it here.
-      //
-      // stderr writes go to v4-worker's bcode-output-<runId>.log so cloud
-      // verification can see whether this path executed. Temporary, will
-      // be removed once headless V4 telemetry is settled.
-      const sessionIds = Object.keys(sessionCurrentTurnSpan)
-      process.stderr.write(
-        `[bcode-laminar] shutdown: ending ${sessionIds.length} open turn span(s), waiting on ${pendingFlushes.size} pending flush(es)\n`,
-      )
-      for (const sessionId of sessionIds) {
+      for (const sessionId of Object.keys(sessionCurrentTurnSpan)) {
         const span = sessionCurrentTurnSpan[sessionId]
         if (!span) continue
-        try {
-          span.end()
-        } catch (err) {
-          process.stderr.write(
-            `[bcode-laminar] span.end threw for session ${sessionId}: ${(err as Error).message}\n`,
-          )
-        }
+        span.end()
         delete sessionCurrentTurnSpan[sessionId]
       }
-      const start = Date.now()
-      // Kick a final flush AND wait for any in-flight ones from bus handlers.
       trackFlush(processor.forceFlush())
-      try {
-        await Promise.all(Array.from(pendingFlushes))
-        process.stderr.write(
-          `[bcode-laminar] shutdown: all flushes done in ${Date.now() - start}ms\n`,
-        )
-      } catch (err) {
-        process.stderr.write(
-          `[bcode-laminar] shutdown: flush threw after ${Date.now() - start}ms: ${(err as Error).message}\n`,
-        )
-      }
+      await Promise.all(Array.from(pendingFlushes))
     },
     event: async ({ event }) => {
       switch (event.type) {
         case "session.idle": {
           const sessionId = event.properties.sessionID
           const span = sessionCurrentTurnSpan[sessionId]
           if (span) {
-            const sid = span.spanContext().spanId
-            process.stderr.write(
-              `[bcode-laminar] session.idle: ending turn span ${sid} session=${sessionId}\n`,
-            )
             span.end()
             delete sessionCurrentTurnSpan[sessionId]
-          } else {
-            process.stderr.write(
-              `[bcode-laminar] session.idle: no turn span for session=${sessionId}\n`,
-            )
           }
-          // Track the flush Promise so the sync shutdown hook can await it
-          // before process.exit. Fire-and-forget from this fiber's POV.
+          // Track the flush Promise so the shutdown hook can await it before
+          // `process.exit()`. Fire-and-forget from this fiber's POV.
           trackFlush(processor.forceFlush())
           break
         }
         case "server.instance.disposed": {
           // End any turn spans still open so they're queued before the host
-          // calls our `shutdown` hook.
-          //
-          // Do NOT call `sdk.shutdown()` here. It unregisters the global
-          // TracerProvider AND closes the BatchSpanProcessor — both
-          // observed to fire mid-await in headless `bcode run` mode, after
-          // which the sync `shutdown` hook's `processor.forceFlush()` is a
-          // no-op and turn spans are silently dropped. The sync hook is now
-          // the single drain point; this handler just ends spans.
-          const entries = Object.entries(sessionCurrentTurnSpan)
-          process.stderr.write(`[bcode-laminar] server.instance.disposed: ending ${entries.length} open turn span(s)\n`)
-          for (const [sessionId, span] of entries) {
+          // calls our `shutdown` hook. Do NOT call `sdk.shutdown()` here —
+          // it unregisters the global TracerProvider and closes the BSP,
+          // both observed to fire mid-await in headless `bcode run` mode
+          // and silently drop the just-ended turn span. The shutdown hook
+          // is the single drain point.
+          for (const [sessionId, span] of Object.entries(sessionCurrentTurnSpan)) {
             span.end()
             delete sessionCurrentTurnSpan[sessionId]
           }
@@ -210,12 +162,7 @@ export const LaminarPlugin: Plugin = ({ client }) => {
       const isSubagent = Object.values(subagentSessionIds).some((children) =>
         children.has(sessionID),
       )
-      if (isSubagent || sessionCurrentTurnSpan[sessionID]) {
-        process.stderr.write(
-          `[bcode-laminar] chat.message: skip (isSubagent=${isSubagent}, hasOpen=${!!sessionCurrentTurnSpan[sessionID]}) session=${sessionID}\n`,
-        )
-        return
-      }
+      if (isSubagent || sessionCurrentTurnSpan[sessionID]) return
 
       const span = startTurnSpan({
         name: "turn",
@@ -232,9 +179,6 @@ export const LaminarPlugin: Plugin = ({ client }) => {
         },
       })
       sessionCurrentTurnSpan[sessionID] = span
-      process.stderr.write(
-        `[bcode-laminar] chat.message: created turn span ${span.spanContext().spanId} session=${sessionID}\n`,
-      )
     },
   })
 }

packages/opencode/src/index.ts

@@ -249,52 +249,32 @@ try {
   }
   process.exitCode = 1
 } finally {
-  // Give plugins a synchronous chance to end any open OTel spans before the
-  // exporter drain below. The bus-based session.idle / server.instance.disposed
-  // events race with Effect scope teardown and don't reliably reach plugin
-  // subscribers in headless `bcode run` mode, so we expose a direct sync hook
-  // (see packages/opencode/src/plugin/index.ts pluginShutdownHooks).
-  // The import is wrapped so a module-load failure can't strand the process
-  // before forceFlush + process.exit() below.
-  // Plugin shutdown hooks are the single drain point. Each hook may return
-  // a Promise (e.g. bcode-laminar returning its BatchSpanProcessor's
-  // forceFlush) which we await with a 3s budget so a wedged exporter can't
-  // hang `process.exit()`. The previous fallback that called
-  // `trace.getTracerProvider().forceFlush()` was a no-op — the OTel API
-  // proxy provider doesn't expose forceFlush, and the bus-driven
-  // `server.instance.disposed` handler had often already called
-  // `sdk.shutdown()` and unregistered the global by the time we got here.
+  // Plugin shutdown hooks are the single drain point for OTel-based plugins
+  // (e.g. bcode-laminar). Each hook may return a Promise — bcode-laminar
+  // returns its BatchSpanProcessor's forceFlush plus any in-flight flushes
+  // kicked off by bus event handlers — which we await with a 3s budget so
+  // a wedged exporter cannot hang `process.exit()`.
   //
-  // stderr writes go to v4-worker's bcode-output-<runId>.log so cloud
-  // verification can see whether this path executed and how long it took.
-  // Will be removed once headless V4 telemetry is fully settled.
+  // The host-side fallback that called `trace.getTracerProvider().forceFlush()`
+  // was dropped: the OTel API's ProxyTracerProvider doesn't expose forceFlush,
+  // and the bus-driven `server.instance.disposed` handler used to call
+  // `sdk.shutdown()` and unregister the global before this finally ran.
+  // The plugin-owned drain (with closure ref to its own processor) is
+  // immune to both issues.
   try {
     const { pluginShutdownHooks } = await import("./plugin")
-    const hooks = Array.from(pluginShutdownHooks)
-    process.stderr.write(`[bcode] shutdown: invoking ${hooks.length} plugin shutdown hook(s)\n`)
-    const start = Date.now()
     await Promise.race([
       Promise.allSettled(
-        hooks.map((hook) =>
+        Array.from(pluginShutdownHooks).map((hook) =>
           Promise.resolve()
             .then(hook)
-            .catch((err: Error) => {
-              process.stderr.write(`[bcode] shutdown: hook threw: ${err.message}\n`)
-              Log.Default.error("plugin shutdown hook failed", { error: err })
-            }),
+            .catch((err: Error) => Log.Default.error("plugin shutdown hook failed", { error: err })),
         ),
       ),
-      new Promise<void>((resolve) =>
-        setTimeout(() => {
-          process.stderr.write(`[bcode] shutdown: timed out after 3000ms\n`)
-          resolve()
-        }, 3000),
-      ),
+      new Promise<void>((resolve) => setTimeout(resolve, 3000)),
     ])
-    process.stderr.write(`[bcode] shutdown: done in ${Date.now() - start}ms\n`)
   } catch (err) {
     Log.Default.error("plugin shutdown import failed", { error: err })
-    process.stderr.write(`[bcode] shutdown: import failed: ${(err as Error).message}\n`)
   }
   // Some subprocesses don't react properly to SIGTERM and similar signals.
   // Most notably, some docker-container-based MCP servers don't handle such signals unless