fix: address code review findings for crash trace flush

- thread.ts: re-raise signal after cleanup to restore default
  termination behavior (prevents process from hanging)
- worker.ts: replace one-shot `hasFlushed` guard with "preserve
  first reason" pattern so later flushes still run
- worker.ts: defer `sessionTraces.delete()` until `endTrace()`
  completes so crash flush can still reach in-flight traces

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: anandgupta42

packages/opencode/src/cli/cmd/tui/thread.ts

@@ -154,21 +154,30 @@ export const TuiThreadCommand = cmd({
 
       // altimate_change start — crash: flush worker traces on signals
       // Bun Workers don't receive OS signals — only the main thread does.
-      // On SIGINT/SIGTERM/SIGHUP, terminate the worker and briefly wait so
-      // its "exit" handler fires and flushes all active session traces to disk.
-      // Bun.sleepSync gives the worker thread time to process the termination
-      // before the main thread continues to process.exit().
-      const emergencyTerminate = () => {
-        try {
-          worker.terminate()
-          Bun.sleepSync(50)
-        } catch {
-          // best-effort — crash handler must never throw
+      // On SIGINT/SIGTERM/SIGHUP, terminate the worker so its "exit" handler
+      // fires and flushes all active session traces to disk.
+      // After cleanup, remove the handler and re-raise the signal to restore
+      // default behavior (process termination). This avoids swallowing signals
+      // which would leave the process running after a kill.
+      const makeSignalHandler = (signal: NodeJS.Signals) => {
+        const handler = () => {
+          try {
+            worker.terminate()
+            Bun.sleepSync(50)
+          } catch {
+            // best-effort — crash handler must never throw
+          }
+          process.off(signal, handler)
+          process.kill(process.pid, signal)
         }
+        return handler
       }
-      process.on("SIGINT", emergencyTerminate)
-      process.on("SIGTERM", emergencyTerminate)
-      process.on("SIGHUP", emergencyTerminate)
+      const onSigint = makeSignalHandler("SIGINT")
+      const onSigterm = makeSignalHandler("SIGTERM")
+      const onSighup = makeSignalHandler("SIGHUP")
+      process.on("SIGINT", onSigint)
+      process.on("SIGTERM", onSigterm)
+      process.on("SIGHUP", onSighup)
       // altimate_change end
 
       let stopped = false
@@ -179,9 +188,9 @@ export const TuiThreadCommand = cmd({
         process.off("unhandledRejection", error)
         process.off("SIGUSR2", reload)
         // altimate_change start — crash: remove emergency handlers on clean shutdown
-        process.off("SIGINT", emergencyTerminate)
-        process.off("SIGTERM", emergencyTerminate)
-        process.off("SIGHUP", emergencyTerminate)
+        process.off("SIGINT", onSigint)
+        process.off("SIGTERM", onSigterm)
+        process.off("SIGHUP", onSighup)
         // altimate_change end
         await withTimeout(client.call("shutdown", undefined), 5000).catch((error) => {
           Log.Default.warn("worker shutdown failed", {

packages/opencode/src/cli/cmd/tui/worker.ts

@@ -114,12 +114,15 @@ function getOrCreateTrace(sessionID: string): Trace | null {
 
 const startEventStream = (input: { directory: string; workspaceID?: string }) => {
   if (eventStream.abort) eventStream.abort.abort()
-  // Clear stale per-stream trace state before starting a new stream instance
+  // altimate_change start — crash: flush stale traces before clearing
+  // Flush any in-flight traces synchronously before clearing — endTrace() is
+  // async and a crash during the gap would lose trace data.
   for (const [, trace] of sessionTraces) {
     void trace.endTrace().catch(() => {})
   }
   sessionTraces.clear()
   sessionUserMsgIds.clear()
+  // altimate_change end
 
   const abort = new AbortController()
   eventStream.abort = abort
@@ -242,9 +245,15 @@ const startEventStream = (input: { directory: string; workspaceID?: string }) =>
             if (status === "idle" && sid) {
               const trace = sessionTraces.get(sid)
               if (trace) {
-                void trace.endTrace().catch(() => {})
-                sessionTraces.delete(sid)
-                sessionUserMsgIds.delete(sid)
+                // altimate_change start — crash: defer deletion until endTrace() completes
+                // Keep the trace in sessionTraces during async teardown so
+                // flushAllTracesSync() can still reach it if a crash occurs
+                // while endTrace() is in flight.
+                void trace.endTrace().catch(() => {}).finally(() => {
+                  sessionTraces.delete(sid)
+                  sessionUserMsgIds.delete(sid)
+                })
+                // altimate_change end
               }
             }
           }
@@ -338,13 +347,17 @@ Rpc.listen(rpc)
 // NOTE: Bun Workers do NOT receive OS signals (SIGINT, SIGTERM, SIGHUP) —
 // those are delivered only to the main thread. Signal-based flush is handled
 // in thread.ts by terminating the worker, which triggers the "exit" event here.
-let hasFlushed = false
+let firstFlushReason: string | undefined
 function flushAllTracesSync(reason: string) {
-  if (hasFlushed) return
-  hasFlushed = true
+  // Preserve the most specific reason from the first flush (e.g., the uncaught
+  // exception message) even if a later handler (exit) calls again with a
+  // generic reason. Subsequent calls still flush — new traces may have been
+  // created since the first call.
+  const effectiveReason = firstFlushReason ?? reason
+  firstFlushReason ??= reason
   for (const [, trace] of sessionTraces) {
     try {
-      trace.flushSync(reason)
+      trace.flushSync(effectiveReason)
     } catch {
       // flushSync is best-effort — must never throw in an exit handler
     }