wave-code 0.17.0 → 0.17.2

package/src/acp/agent.ts

@@ -17,6 +17,10 @@ import {
   ASK_USER_QUESTION_TOOL_NAME,
   AskUserQuestion,
   AskUserQuestionOption,
+  type Message,
+  type TextBlock,
+  type ReasoningBlock,
+  type ToolBlock,
 } from "wave-agent-sdk";
 import { logger } from "../utils/logger.js";
 import {
@@ -98,7 +102,7 @@ export class WaveAcpAgent implements AcpAgent {
 
   private getSessionConfigOptions(agent: WaveAgent): SessionConfigOption[] {
     const configuredModels = agent.getConfiguredModels();
-    const currentModel = agent.getModelConfig().model;
+    const currentModel = agent.getModelConfig().model || "";
 
     return [
       {
@@ -262,6 +266,9 @@ export class WaveAcpAgent implements AcpAgent {
     logger.info(`Loading session: ${sessionId} in ${cwd}`);
     const agent = await this.createAgent(sessionId, cwd, mcpServers);
 
+    // Replay conversation history via session/update notifications per ACP spec
+    await this.replayConversationHistory(agent);
+
     return {
       modes: this.getSessionModeState(agent),
       configOptions: this.getSessionConfigOptions(agent),
@@ -799,6 +806,135 @@ export class WaveAcpAgent implements AcpAgent {
     }
   }
 
+  private async replayConversationHistory(agent: WaveAgent): Promise<void> {
+    const sessionId = agent.sessionId as AcpSessionId;
+
+    let history: Message[];
+    try {
+      const thread = await agent.getFullMessageThread();
+      history = thread.messages;
+    } catch {
+      // Fallback to in-memory messages if full thread fails
+      history = agent.messages;
+    }
+
+    for (const message of history) {
+      if (message.isMeta) continue;
+
+      const messageId = message.id;
+
+      for (const block of message.blocks) {
+        if (block.type === "text") {
+          const textBlock = block as TextBlock;
+          const update =
+            message.role === "user"
+              ? {
+                  sessionUpdate: "user_message_chunk" as const,
+                  content: { type: "text" as const, text: textBlock.content },
+                  messageId,
+                }
+              : {
+                  sessionUpdate: "agent_message_chunk" as const,
+                  content: { type: "text" as const, text: textBlock.content },
+                  messageId,
+                };
+          this.connection.sessionUpdate({ sessionId, update });
+        } else if (block.type === "reasoning") {
+          const reasoningBlock = block as ReasoningBlock;
+          this.connection.sessionUpdate({
+            sessionId,
+            update: {
+              sessionUpdate: "agent_thought_chunk",
+              content: { type: "text", text: reasoningBlock.content },
+              messageId,
+            },
+          });
+        } else if (block.type === "tool") {
+          const toolBlock = block as ToolBlock;
+          const toolCallId =
+            toolBlock.id ||
+            "replay-" + Math.random().toString(36).substring(2, 9);
+          const effectiveName = toolBlock.name || "Tool";
+          const effectiveCompactParams = toolBlock.compactParams;
+
+          const displayTitle =
+            effectiveName && effectiveCompactParams
+              ? `${effectiveName}: ${effectiveCompactParams}`
+              : effectiveName;
+
+          let parsedParameters: Record<string, unknown> | undefined;
+          if (toolBlock.parameters) {
+            try {
+              const parsed = JSON.parse(toolBlock.parameters);
+              parsedParameters = Array.isArray(parsed)
+                ? { args: parsed }
+                : parsed;
+            } catch {
+              // Ignore parse errors
+            }
+          }
+
+          const content =
+            effectiveName && (parsedParameters || toolBlock.shortResult)
+              ? this.getToolContent(
+                  effectiveName,
+                  parsedParameters,
+                  toolBlock.shortResult,
+                )
+              : undefined;
+          const locations =
+            effectiveName && parsedParameters
+              ? this.getToolLocations(effectiveName, parsedParameters)
+              : undefined;
+          const kind = effectiveName
+            ? this.getToolKind(effectiveName)
+            : undefined;
+
+          // Emit tool_call (creation)
+          this.connection.sessionUpdate({
+            sessionId,
+            update: {
+              sessionUpdate: "tool_call",
+              toolCallId,
+              title: displayTitle,
+              status: "pending",
+              content,
+              locations,
+              kind,
+              rawInput: parsedParameters,
+            },
+          });
+
+          // Emit tool_call_update with final status
+          const status: ToolCallStatus =
+            toolBlock.stage === "end"
+              ? toolBlock.success
+                ? "completed"
+                : "failed"
+              : toolBlock.stage === "running"
+                ? "in_progress"
+                : "pending";
+
+          this.connection.sessionUpdate({
+            sessionId,
+            update: {
+              sessionUpdate: "tool_call_update",
+              toolCallId,
+              status,
+              title: displayTitle,
+              rawOutput: toolBlock.result || toolBlock.error,
+              content,
+              locations,
+              kind,
+              rawInput: parsedParameters,
+            },
+          });
+        }
+        // Skip: image, bang, compact, error, file_history, task_notification blocks
+      }
+    }
+  }
+
   private createCallbacks(sessionId: string): AgentOptions["callbacks"] {
     const getAgent = () => this.agents.get(sessionId);
     const toolStates = new Map<

package/src/components/ChatInterface.tsx

@@ -37,6 +37,9 @@ export const ChatInterface: React.FC = () => {
     workdir,
     remountKey,
     requestRemount,
+    isGoalActive,
+    goalElapsed,
+    isGoalEvaluating,
   } = useChat();
 
   const displayMessages = messages;
@@ -80,11 +83,15 @@ export const ChatInterface: React.FC = () => {
 
       {!isConfirmationVisible && !isExpanded && (
         <>
-          {(isLoading || isCommandRunning || isCompacting) && (
+          {(isLoading ||
+            isCommandRunning ||
+            isCompacting ||
+            isGoalEvaluating) && (
             <LoadingIndicator
               isLoading={isLoading}
               isCommandRunning={isCommandRunning}
               isCompacting={isCompacting}
+              isGoalEvaluating={isGoalEvaluating}
               latestTotalTokens={latestTotalTokens}
             />
           )}
@@ -102,6 +109,8 @@ export const ChatInterface: React.FC = () => {
             hasSlashCommand={hasSlashCommand}
             latestTotalTokens={latestTotalTokens}
             maxInputTokens={maxInputTokens}
+            isGoalActive={isGoalActive}
+            goalElapsed={goalElapsed}
           />
         </>
       )}

package/src/components/InputBox.tsx

@@ -1,4 +1,4 @@
-import React, { useEffect } from "react";
+import React, { useEffect, useRef, useCallback } from "react";
 import { Box, Text } from "ink";
 import { useInput } from "ink";
 import { FileSelector } from "./FileSelector.js";
@@ -12,6 +12,7 @@ import { StatusCommand } from "./StatusCommand.js";
 import { LoginCommand } from "./LoginCommand.js";
 import { PluginManagerShell } from "./PluginManagerShell.js";
 import { ModelSelector } from "./ModelSelector.js";
+import { WorkflowManager } from "./WorkflowManager.js";
 import { StatusLine } from "./StatusLine.js";
 import { BtwDisplay } from "./BtwDisplay.js";
 import { useInputManager } from "../hooks/useInputManager.js";
@@ -47,6 +48,9 @@ export interface InputBoxProps {
   // Token usage
   latestTotalTokens?: number;
   maxInputTokens?: number;
+  // Goal state
+  isGoalActive?: boolean;
+  goalElapsed?: string;
 }
 
 export const InputBox: React.FC<InputBoxProps> = ({
@@ -59,6 +63,8 @@ export const InputBox: React.FC<InputBoxProps> = ({
   hasSlashCommand = () => false,
   latestTotalTokens = 0,
   maxInputTokens = 128000,
+  isGoalActive,
+  goalElapsed,
 }) => {
   const {
     permissionMode: chatPermissionMode,
@@ -74,8 +80,23 @@ export const InputBox: React.FC<InputBoxProps> = ({
     configuredModels,
     setModel,
     recreateAgent,
+    recallQueuedMessage,
+    queuedMessages,
   } = useChat();
 
+  // Ref to hold setInputText so queue callbacks can access it before useInputManager returns
+  const setInputTextRef = useRef<(text: string) => void>(() => {});
+
+  const hasQueuedMessages = (queuedMessages?.length ?? 0) > 0;
+
+  const onRecallQueuedMessage = useCallback(() => {
+    const msg = recallQueuedMessage();
+    if (msg) {
+      const prefix = msg.type === "bang" ? "!" : "";
+      setInputTextRef.current(prefix + msg.content);
+    }
+  }, [recallQueuedMessage]);
+
   // Input manager with all input state and functionality (including images)
   const {
     inputText,
@@ -110,6 +131,7 @@ export const InputBox: React.FC<InputBoxProps> = ({
     showLoginCommand,
     showPluginManager,
     showModelSelector,
+    showWorkflowManager,
     setShowBackgroundTaskManager,
     setShowMcpManager,
     setShowRewindManager,
@@ -118,6 +140,7 @@ export const InputBox: React.FC<InputBoxProps> = ({
     setShowLoginCommand,
     setShowPluginManager,
     setShowModelSelector,
+    setShowWorkflowManager,
     // Permission mode
     permissionMode,
     setPermissionMode,
@@ -127,6 +150,8 @@ export const InputBox: React.FC<InputBoxProps> = ({
     handleInput,
     // Manager ready state
     isManagerReady,
+    // Direct state setters
+    setInputText,
   } = useInputManager({
     onSendMessage: sendMessage,
     onAskBtw: askBtw,
@@ -137,8 +162,15 @@ export const InputBox: React.FC<InputBoxProps> = ({
     sessionId,
     workdir: workingDirectory,
     getFullMessageThread,
+    hasQueuedMessages,
+    onRecallQueuedMessage,
   });
 
+  // Keep setInputText ref updated for queue callbacks
+  useEffect(() => {
+    setInputTextRef.current = setInputText;
+  }, [setInputText]);
+
   // Sync permission mode from useChat to InputManager
   useEffect(() => {
     setPermissionMode(chatPermissionMode);
@@ -157,7 +189,8 @@ export const InputBox: React.FC<InputBoxProps> = ({
       showPluginManager ||
       showModelSelector ||
       showBackgroundTaskManager ||
-      showMcpManager
+      showMcpManager ||
+      showWorkflowManager
     ) {
       return;
     }
@@ -291,13 +324,18 @@ export const InputBox: React.FC<InputBoxProps> = ({
         />
       )}
 
+      {showWorkflowManager && (
+        <WorkflowManager onCancel={() => setShowWorkflowManager(false)} />
+      )}
+
       {showBackgroundTaskManager ||
         showMcpManager ||
         showRewindManager ||
         showHelp ||
         showStatusCommand ||
         showLoginCommand ||
-        showPluginManager || (
+        showPluginManager ||
+        showWorkflowManager || (
           <Box flexDirection="column">
             <Box
               borderStyle="single"
@@ -330,6 +368,8 @@ export const InputBox: React.FC<InputBoxProps> = ({
               permissionMode={permissionMode}
               isShellCommand={isShellCommand}
               isBtwActive={btwState.isActive}
+              isGoalActive={isGoalActive}
+              goalElapsed={goalElapsed}
               latestTotalTokens={latestTotalTokens}
               maxInputTokens={maxInputTokens}
             />

package/src/components/LoadingIndicator.tsx

@@ -5,6 +5,7 @@ export interface LoadingIndicatorProps {
   isLoading?: boolean;
   isCommandRunning?: boolean;
   isCompacting?: boolean;
+  isGoalEvaluating?: boolean;
   latestTotalTokens?: number;
 }
 
@@ -12,11 +13,12 @@ export const LoadingIndicator = ({
   isLoading = false,
   isCommandRunning = false,
   isCompacting = false,
+  isGoalEvaluating = false,
   latestTotalTokens = 0,
 }: LoadingIndicatorProps) => {
   return (
     <Box flexDirection="column">
-      {isLoading && !isCompacting && (
+      {isLoading && !isCompacting && !isGoalEvaluating && (
         <Box>
           <Text color="yellow">✻ AI is thinking... </Text>
           {latestTotalTokens > 0 && (
@@ -49,6 +51,7 @@ export const LoadingIndicator = ({
       {isCompacting && (
         <Text color="magenta">✻ Compacting message history...</Text>
       )}
+      {isGoalEvaluating && <Text color="cyan">✻ Evaluating goal...</Text>}
     </Box>
   );
 };

package/src/components/QueuedMessageList.tsx

@@ -18,15 +18,19 @@ export const QueuedMessageList: React.FC = () => {
         const displayText = prefix + (content || (hasImages ? "[Images]" : ""));
 
         return (
-          <Box key={index}>
+          <Box key={msg.id ?? index}>
+            <Text color="gray">[{index + 1}] </Text>
             <Text color="gray" italic>
-              {displayText.length > 60
-                ? `${displayText.substring(0, 57)}...`
+              {displayText.length > 55
+                ? `${displayText.substring(0, 52)}...`
                 : displayText}
             </Text>
           </Box>
         );
       })}
+      <Text color="gray" dimColor>
+        {"  "}↑ recall
+      </Text>
     </Box>
   );
 };

package/src/components/StatusLine.tsx

@@ -5,6 +5,8 @@ export interface StatusLineProps {
   permissionMode: string;
   isShellCommand: boolean;
   isBtwActive: boolean;
+  isGoalActive?: boolean;
+  goalElapsed?: string;
   latestTotalTokens?: number;
   maxInputTokens?: number;
 }
@@ -13,6 +15,8 @@ export const StatusLine: React.FC<StatusLineProps> = ({
   permissionMode,
   isShellCommand,
   isBtwActive,
+  isGoalActive,
+  goalElapsed,
   latestTotalTokens = 0,
   maxInputTokens = 128000,
 }) => {
@@ -35,22 +39,30 @@ export const StatusLine: React.FC<StatusLineProps> = ({
           Shell: <Text color="yellow">Run shell command</Text>
         </Text>
       ) : (
-        <Text color="gray">
-          Mode:{" "}
-          <Text
-            color={
-              permissionMode === "plan"
-                ? "yellow"
-                : permissionMode === "bypassPermissions"
-                  ? "red"
-                  : "cyan"
-            }
-            bold={permissionMode === "bypassPermissions"}
-          >
-            {permissionMode}
-          </Text>{" "}
-          (Shift+Tab to cycle)
-        </Text>
+        <Box>
+          {isGoalActive && (
+            <Text color="gray">
+              <Text color="cyan">◎ /goal</Text> active{" "}
+              {goalElapsed && <Text>({goalElapsed})</Text>} |{" "}
+            </Text>
+          )}
+          <Text color="gray">
+            Mode:{" "}
+            <Text
+              color={
+                permissionMode === "plan"
+                  ? "yellow"
+                  : permissionMode === "bypassPermissions"
+                    ? "red"
+                    : "cyan"
+              }
+              bold={permissionMode === "bypassPermissions"}
+            >
+              {permissionMode}
+            </Text>{" "}
+            (Shift+Tab to cycle)
+          </Text>
+        </Box>
       )}
       {percentage > 0 && (
         <Text color={contextColor}>{percentage}% context</Text>