fix: preserve opencode thinking status in live stream updates

Only update OpenCode status line when the parsed phase is a detailed Thinking message and pass provider context through runtime and harness renderers to keep replay behavior consistent. Also include CLI version in ode status output for easier diagnostics.

Author: LIU9293

packages/agents/test/session-inspector.test.ts

@@ -117,6 +117,69 @@ describe("session inspector", () => {
     expect(state.phaseStatus).toBe("Thinking: Planning repo exploration strategy");
   });
 
+  it("only updates opencode phase when thinking details are present", () => {
+    const now = Date.now();
+    const state = buildSessionMessageState([
+      {
+        timestamp: now,
+        type: "message.part.updated",
+        data: {
+          payload: {
+            type: "message.part.updated",
+            properties: {
+              part: {
+                id: "tool_1",
+                sessionID: "ses_1",
+                type: "tool",
+                tool: "Read",
+                state: {
+                  status: "running",
+                  input: { filePath: "/tmp/repo/README.md" },
+                },
+              },
+            },
+          },
+        },
+      },
+      {
+        timestamp: now + 1,
+        type: "message.part.updated",
+        data: {
+          payload: {
+            type: "message.part.updated",
+            properties: {
+              part: {
+                id: "reasoning_1",
+                sessionID: "ses_1",
+                type: "reasoning",
+                text: "Planning response sections",
+              },
+            },
+          },
+        },
+      },
+      {
+        timestamp: now + 2,
+        type: "message.part.updated",
+        data: {
+          payload: {
+            type: "message.part.updated",
+            properties: {
+              part: {
+                id: "text_1",
+                sessionID: "ses_1",
+                type: "text",
+                text: "Draft message body",
+              },
+            },
+          },
+        },
+      },
+    ], { provider: "opencode" });
+
+    expect(state.phaseStatus).toBe("Thinking: Planning response sections");
+  });
+
   it("renders non-empty preview details from wrapped events", () => {
     const startedAt = Date.now();
     const state = buildSessionMessageState([

packages/core/cli.ts

@@ -340,6 +340,7 @@ function showLogs(commandArgs: string[]): void {
 async function showStatus(): Promise<void> {
   const state = daemonState();
   const daemonIsRunning = managerRunning(state);
+  console.log(`Version: ${CURRENT_VERSION}`);
   console.log(`Daemon: ${daemonIsRunning ? "running" : "stopped"}`);
   if (state.pendingUpgradeRestart) {
     console.log(

packages/core/runtime/event-stream.ts

@@ -69,6 +69,7 @@ export async function startEventStreamWatcher(
     const existingState = liveParsedState.get(messageKey);
     const parsedState = buildSessionMessageState(eventHistory, {
       workingDirectory: workingPath,
+      provider: providerId,
       baseState: {
         startedAt: request.startedAt,
         sessionTitle: existingState?.sessionTitle,

packages/live-status-harness/renderer.ts

@@ -39,6 +39,7 @@ export function renderStatusesFromRun(meta: HarnessRunMeta, events: HarnessCaptu
     const state = buildSessionMessageState(sessionEvents, {
       endIndex: index,
       workingDirectory: meta.cwd,
+      provider: meta.provider,
       baseState: { startedAt: meta.startedAt },
     });
     const text = buildStatusMessageByProvider(meta.provider, request, meta.cwd, state, "medium");

packages/live-status-harness/scripts/generate-report.ts

@@ -258,6 +258,7 @@ async function runProvider(
       }),
     {
       workingDirectory: options.cwd,
+      provider: meta.provider,
       baseState: { startedAt: meta.startedAt },
     }
   );

packages/utils/session-inspector.ts

@@ -14,6 +14,7 @@ import {
   type StreamStateMaps,
   type StreamToolState,
 } from "@/agents/session-state/shared";
+import type { AgentProviderId } from "@/shared/agent-provider";
 
 export type SessionEvent = {
   timestamp: number;
@@ -64,6 +65,7 @@ export type SessionStateOptions = {
   workingDirectory?: string;
   endIndex?: number;
   baseState?: Partial<SessionMessageState>;
+  provider?: AgentProviderId;
 };
 
 type ProviderParser = {
@@ -305,7 +307,31 @@ function applyMessageUpdatedEvent(state: SessionMessageState, eventProps: Record
   applyMetadataFromRecord(state, info);
 }
 
-function applySessionStatusEvent(state: SessionMessageState, eventProps: Record<string, unknown>): void {
+function isOpencodeThinkingStatusWithContent(status: string): boolean {
+  if (!status.startsWith("Thinking:")) return false;
+  return status.slice("Thinking:".length).trim().length > 0;
+}
+
+function updatePhaseStatus(
+  state: SessionMessageState,
+  nextStatus: string | undefined,
+  provider?: AgentProviderId
+): void {
+  if (!nextStatus) return;
+  if (provider === "opencode") {
+    if (isOpencodeThinkingStatusWithContent(nextStatus)) {
+      state.phaseStatus = nextStatus;
+    }
+    return;
+  }
+  state.phaseStatus = nextStatus;
+}
+
+function applySessionStatusEvent(
+  state: SessionMessageState,
+  eventProps: Record<string, unknown>,
+  provider?: AgentProviderId
+): void {
   const statusValue = (eventProps as { status?: unknown }).status;
   const formattedStatus = formatSessionStatus(statusValue);
   if (!formattedStatus) return;
@@ -317,7 +343,7 @@ function applySessionStatusEvent(state: SessionMessageState, eventProps: Record<
   ) {
     return;
   }
-  state.phaseStatus = formattedStatus;
+  updatePhaseStatus(state, formattedStatus, provider);
 }
 
 function normalizeReasoningStatus(text: string): string {
@@ -331,7 +357,11 @@ function normalizeReasoningStatus(text: string): string {
   return `Thinking: ${truncated}`;
 }
 
-function applyMessagePartUpdatedEvent(state: SessionMessageState, eventProps: Record<string, unknown>): void {
+function applyMessagePartUpdatedEvent(
+  state: SessionMessageState,
+  eventProps: Record<string, unknown>,
+  provider?: AgentProviderId
+): void {
   const part = (eventProps as { part?: Record<string, unknown> }).part;
   if (!part) return;
   const isSessionScopedPart = typeof part.sessionID === "string";
@@ -363,35 +393,35 @@ function applyMessagePartUpdatedEvent(state: SessionMessageState, eventProps: Re
     }
 
     if (toolInfo.status === "running" || toolInfo.status === "pending") {
-      state.phaseStatus = `Running tool: ${toolInfo.name}`;
+      updatePhaseStatus(state, `Running tool: ${toolInfo.name}`, provider);
     } else if (toolInfo.status === "completed") {
-      state.phaseStatus = `Finished tool: ${toolInfo.name}`;
+      updatePhaseStatus(state, `Finished tool: ${toolInfo.name}`, provider);
     } else if (toolInfo.status === "error") {
-      state.phaseStatus = `Tool failed: ${toolInfo.name}`;
+      updatePhaseStatus(state, `Tool failed: ${toolInfo.name}`, provider);
     }
     return;
   }
 
   if (part.type === "text" && typeof part.text === "string") {
     state.currentText = part.text;
     if (isSessionScopedPart) {
-      state.phaseStatus = "Drafting response";
+      updatePhaseStatus(state, "Drafting response", provider);
     }
     return;
   }
 
   if (part.type === "reasoning" && typeof part.text === "string") {
     state.thinkingText = part.text;
     if (isSessionScopedPart) {
-      state.phaseStatus = normalizeReasoningStatus(part.text);
+      updatePhaseStatus(state, normalizeReasoningStatus(part.text), provider);
     }
     return;
   }
 
   if (part.type === "thinking" && typeof part.text === "string") {
     state.thinkingText = part.text;
     if (isSessionScopedPart) {
-      state.phaseStatus = normalizeReasoningStatus(part.text);
+      updatePhaseStatus(state, normalizeReasoningStatus(part.text), provider);
     }
   }
 }
@@ -472,7 +502,7 @@ export function buildSessionMessageState(
   events: SessionEvent[],
   options: SessionStateOptions = {}
 ): SessionMessageState {
-  const { endIndex, baseState } = options;
+  const { endIndex, baseState, provider } = options;
   const startTime = events[0]?.timestamp ?? Date.now();
   const state: SessionMessageState = {
     sessionTitle: baseState?.sessionTitle,
@@ -606,11 +636,11 @@ export function buildSessionMessageState(
     }
 
     if (type === "session.status") {
-      applySessionStatusEvent(state, eventProps);
+      applySessionStatusEvent(state, eventProps, provider);
     }
 
     if (type === "message.part.updated") {
-      applyMessagePartUpdatedEvent(state, eventProps);
+      applyMessagePartUpdatedEvent(state, eventProps, provider);
     }
 
     if (type === "todo.updated") {

packages/web-ui/src/lib/session-inspector/IMPreview.svelte

@@ -32,6 +32,7 @@
     ...buildSessionMessageState(events, {
       endIndex: selectedEventIndex,
       workingDirectory,
+      provider,
     }),
     currentStatus: "Starting",
     currentStep: undefined,
@@ -40,6 +41,7 @@
   const finalState = $derived(({
     ...buildSessionMessageState(events, {
       workingDirectory,
+      provider,
     }),
     currentStatus: "Completed",
     currentStep: undefined,