refactor: remove printMode in favor of Ink-only streaming

Print Mode (direct stdout.write) conflicts with Ink's terminal control
and provides no real benefit over Ink Mode's real-time Markdown rendering.
A proper non-interactive mode (like Claude Code's -p flag) would bypass
Ink entirely rather than mixing stdout.write within the React tree.

Removed: printMode prop, stdout.write branches, printMode state.

Author: Travelguest

src/agent/__tests__/agent-streaming-progress.test.ts

@@ -1,13 +1,12 @@
 import { describe, expect, test } from "bun:test";
+import { z } from "zod";
+
+import type { AssistantMessage } from "@/foundation";
+import { Model } from "@/foundation/models/model";
+import type { ModelProvider, ModelProviderInvokeParams } from "@/foundation/models/model-provider";
+
 import { Agent } from "../agent";
 import type { AgentProgressThinkingEvent } from "../agent-event";
-import { Model } from "@/foundation/models/model";
-import type {
-  ModelProvider,
-  ModelProviderInvokeParams,
-} from "@/foundation/models/model-provider";
-import type { AssistantMessage } from "@/foundation";
-import { z } from "zod";
 
 function createTextStreamingProvider(): ModelProvider {
   const finalMessage: AssistantMessage = {
@@ -16,7 +15,9 @@ function createTextStreamingProvider(): ModelProvider {
   };
 
   return {
+    // eslint-disable-next-line no-unused-vars
     invoke: async (_params: ModelProviderInvokeParams) => finalMessage,
+    // eslint-disable-next-line no-unused-vars
     async *stream(_params: ModelProviderInvokeParams) {
       const snapshots: AssistantMessage[] = [
         {
@@ -63,7 +64,9 @@ function createToolStreamingProvider(): ModelProvider {
   };
 
   return {
+    // eslint-disable-next-line no-unused-vars
     invoke: async (_params: ModelProviderInvokeParams) => toolMessage,
+    // eslint-disable-next-line no-unused-vars
     async *stream(_params: ModelProviderInvokeParams) {
       callCount++;
       if (callCount === 1) {
@@ -82,7 +85,6 @@ function createToolStreamingProvider(): ModelProvider {
         };
         yield toolMessage;
       } else {
-        // Second call: return a text-only message to end the loop
         yield doneMessage;
       }
     },
@@ -95,28 +97,26 @@ describe("Agent streaming progress events", () => {
     const model = new Model("test-model", provider);
     const agent = new Agent({ model, prompt: "You are a test assistant.", tools: [] });
 
-    const events: any[] = [];
+    const events: AgentProgressThinkingEvent[] = [];
     for await (const event of agent.stream({
       role: "user",
       content: [{ type: "text", text: "Hi" }],
     })) {
-      events.push(event);
+      if (event.type === "progress" && event.subtype === "thinking") {
+        events.push(event);
+      }
     }
 
-    const thinkingEvents = events.filter(
-      (e) => e.type === "progress" && e.subtype === "thinking",
-    ) as AgentProgressThinkingEvent[];
+    expect(events.length).toBe(2);
 
-    expect(thinkingEvents.length).toBe(2);
-
-    expect(thinkingEvents[0]).toMatchObject({
+    expect(events[0]).toMatchObject({
       type: "progress",
       subtype: "thinking",
       text: "Hello",
       delta: "Hello",
     });
 
-    expect(thinkingEvents[1]).toMatchObject({
+    expect(events[1]).toMatchObject({
       type: "progress",
       subtype: "thinking",
       text: "Hello, world",
@@ -129,23 +129,24 @@ describe("Agent streaming progress events", () => {
     const model = new Model("test-model", provider);
     const agent = new Agent({ model, prompt: "You are a test assistant.", tools: [] });
 
-    const events: any[] = [];
+    let finalMessage: AssistantMessage | null = null;
     for await (const event of agent.stream({
       role: "user",
       content: [{ type: "text", text: "Hi" }],
     })) {
-      events.push(event);
+      if (event.type === "message" && event.message.role === "assistant") {
+        finalMessage = event.message as AssistantMessage;
+      }
     }
 
-    const messageEvent = events.find((e) => e.type === "message");
-    expect(messageEvent).toBeDefined();
-    expect(messageEvent.message.role).toBe("assistant");
+    expect(finalMessage).toBeDefined();
+    expect(finalMessage!.role).toBe("assistant");
 
-    const textBlock = messageEvent.message.content.find(
-      (block: any) => block.type === "text",
+    const textBlock = finalMessage!.content.find(
+      (block) => block.type === "text",
     );
     expect(textBlock).toBeDefined();
-    expect(textBlock.text).toBe("Hello, world!");
+    expect((textBlock as { text: string }).text).toBe("Hello, world!");
   });
 
   test("yields tool progress events without text fields", async () => {
@@ -161,18 +162,16 @@ describe("Agent streaming progress events", () => {
 
     const agent = new Agent({ model, prompt: "You are a test assistant.", tools: [bashTool] });
 
-    const events: any[] = [];
+    const toolProgressEvents: { name?: string; text?: string; delta?: string }[] = [];
     for await (const event of agent.stream({
       role: "user",
       content: [{ type: "text", text: "Hi" }],
     })) {
-      events.push(event);
+      if (event.type === "progress" && event.subtype === "tool") {
+        toolProgressEvents.push(event as unknown as { name?: string; text?: string; delta?: string });
+      }
     }
 
-    const toolProgressEvents = events.filter(
-      (e) => e.type === "progress" && e.subtype === "tool",
-    );
-
     expect(toolProgressEvents.length).toBeGreaterThanOrEqual(1);
 
     for (const toolEvent of toolProgressEvents) {

src/cli/tui/app.tsx

@@ -30,7 +30,7 @@ export function App({
   commands: SlashCommand[];
   supportProjectWideAllow?: boolean;
 }) {
-  const { streaming, messages, streamingText, printMode, onSubmit, abort } = useAgentLoop();
+  const { streaming, messages, streamingText, onSubmit, abort } = useAgentLoop();
   const { approvalRequest, respondToApproval } = useApprovalManager();
   const { askUserQuestionRequest, respondWithAnswers } = useAskUserQuestionManager();
   const { latestTodos, todoSnapshots } = useMemo(() => buildTodoViewState(messages), [messages]);
@@ -47,7 +47,7 @@ export function App({
   useFlushToScrollback(messages, flushedRef, write);
 
   // Show streaming text in Ink mode (not print mode)
-  const showStreamingText = streaming && streamingText && !printMode;
+  const showStreamingText = streaming && !!streamingText;
   // Only show the shimmer indicator when there is no streaming text to display
   const showShimmer = streaming && !streamingText && !approvalRequest && !askUserQuestionRequest;
 

src/cli/tui/components/streaming-message.tsx

@@ -1,7 +1,7 @@
 import { Box, Text } from "ink";
-import { memo, useMemo } from "react";
 import { marked } from "marked";
 import TerminalRenderer from "marked-terminal";
+import { memo, useMemo } from "react";
 
 import { currentTheme } from "../themes";
 

src/cli/tui/hooks/use-agent-loop.ts

@@ -12,7 +12,6 @@ type AgentLoopState = {
   streaming: boolean;
   messages: NonSystemMessage[];
   streamingText: string;
-  printMode: boolean;
   // eslint-disable-next-line no-unused-vars
   onSubmit: (submission: PromptSubmission) => Promise<void>;
   abort: () => void;
@@ -24,12 +23,10 @@ const AgentLoopContext = createContext<AgentLoopState | null>(null);
 export function AgentLoopProvider({
   agent,
   commands = [],
-  printMode = false,
   children,
 }: {
   agent: Agent;
   commands?: SlashCommand[];
-  printMode?: boolean;
   children: ReactNode;
 }) {
   const [streaming, setStreaming] = useState(false);
@@ -135,23 +132,11 @@ export function AgentLoopProvider({
             setStreamingText("");
             enqueueMessage(event.message);
           } else if (event.type === "progress" && event.subtype === "thinking") {
-            if (printMode) {
-              // Print Mode: write delta directly to stdout for instant output
-              if (event.delta) {
-                process.stdout.write(event.delta);
-              }
-            } else {
-              // Ink Mode: update React state for re-rendering
-              setStreamingText(event.text);
-            }
+            setStreamingText(event.text);
           }
           // tool progress events are handled by StreamingIndicator
         }
 
-        if (printMode) {
-          // Ensure a newline after print-mode streaming completes
-          process.stdout.write("\n");
-        }
       } catch (error) {
         if (isAbortError(error)) return;
         throw error;
@@ -162,7 +147,7 @@ export function AgentLoopProvider({
         setStreaming(false);
       }
     },
-    [agent, commands, enqueueMessage, flushPendingMessages, printMode],
+    [agent, commands, enqueueMessage, flushPendingMessages],
   );
 
   const value = useMemo(
@@ -171,12 +156,11 @@ export function AgentLoopProvider({
       streaming,
       messages,
       streamingText,
-      printMode,
       onSubmit,
       abort,
       tokenCount,
     }),
-    [abort, agent, messages, onSubmit, streaming, streamingText, printMode, tokenCount],
+    [abort, agent, messages, onSubmit, streaming, streamingText, tokenCount],
   );
 
   return createElement(AgentLoopContext.Provider, { value }, children);