wave-code 1.3.0 → 1.5.0

package/src/components/SkillsManager.tsx

@@ -1,5 +1,5 @@
 import React, { useEffect, useMemo, useReducer } from "react";
-import { Box, Text, useInput, useStdout } from "ink";
+import { Box, Text, useInput, useWindowSize } from "ink";
 import type { SkillMetadata } from "wave-agent-sdk";
 import {
   skillsManagerReducer,
@@ -55,7 +55,7 @@ export const SkillsManager: React.FC<SkillsManagerProps> = ({
   skills,
 }) => {
   const [state, dispatch] = useReducer(skillsManagerReducer, initialState);
-  const { stdout } = useStdout();
+  const { rows } = useWindowSize();
 
   // Handle pending effects
   useEffect(() => {
@@ -114,7 +114,7 @@ export const SkillsManager: React.FC<SkillsManagerProps> = ({
   // Window slice: center the selected item within the visible area, clamping
   // to the terminal's available rows (reusable pattern from
   // AgentsManager/BackgroundTaskManager).
-  const availableRows = stdout?.rows ?? 24;
+  const availableRows = rows || 24;
   const maxVisible = Math.max(3, Math.min(15, availableRows - 12));
   const selectedFlatIndex = entries.findIndex(
     (e) => e.selectableIndex === state.selectedIndex,

package/src/components/TaskList.tsx

@@ -1,6 +1,6 @@
 import React from "react";
 import { useChat } from "../contexts/useChat.js";
-import { Box, Text, useStdout } from "ink";
+import { Box, Text, useWindowSize } from "ink";
 import { useTasks } from "../hooks/useTasks.js";
 import type { Task, TaskStatus } from "wave-agent-sdk";
 
@@ -92,7 +92,7 @@ function getDisplayLimit(rows: number | undefined): number {
 export const TaskList: React.FC = () => {
   const tasks = useTasks();
   const { isTaskListVisible, isBtwActive } = useChat();
-  const { stdout } = useStdout();
+  const { rows } = useWindowSize();
 
   const completionTimestampsRef = React.useRef<Map<string, number>>(new Map());
   const previousCompletedIdsRef = React.useRef<Set<string> | null>(null);
@@ -195,7 +195,7 @@ export const TaskList: React.FC = () => {
     return null;
   }
 
-  const displayLimit = getDisplayLimit(stdout?.rows);
+  const displayLimit = getDisplayLimit(rows);
   const needsTruncation = tasks.length > displayLimit;
   const sorted = sortTasksByPriority(
     tasks,

package/src/components/ToolDisplay.tsx

@@ -91,12 +91,7 @@ export const ToolDisplay: React.FC<ToolDisplayProps> = ({
 
       {/* Display shortResult in collapsed state */}
       {!isExpanded && shortResult && !error && (
-        <Box
-          paddingLeft={2}
-          borderLeft
-          borderColor="gray"
-          flexDirection="column"
-        >
+        <Box paddingLeft={2} flexDirection="column">
           {shortResult.split("\n").map((line, index) => (
             <Text key={index} color="gray" wrap="truncate-end">
               {line}
@@ -107,12 +102,7 @@ export const ToolDisplay: React.FC<ToolDisplayProps> = ({
 
       {/* Display complete parameters in expanded state */}
       {isExpanded && parameters && (
-        <Box
-          paddingLeft={2}
-          borderLeft
-          borderColor="gray"
-          flexDirection="column"
-        >
+        <Box paddingLeft={2} flexDirection="column">
           <Text color="cyan" bold>
             Parameters:
           </Text>
@@ -123,12 +113,7 @@ export const ToolDisplay: React.FC<ToolDisplayProps> = ({
       {/* Display complete result in expanded state */}
       {isExpanded && result && (
         <Box flexDirection="column">
-          <Box
-            paddingLeft={2}
-            borderLeft
-            borderColor="green"
-            flexDirection="column"
-          >
+          <Box paddingLeft={2} flexDirection="column">
             <Text color="cyan" bold>
               Result:
             </Text>

package/src/components/WorkflowManager.tsx

@@ -1,53 +1,34 @@
-import React, { useEffect, useReducer } from "react";
+import React, { useEffect, useReducer, useState } from "react";
 import { Box, Text, useInput } from "ink";
 import { useChat } from "../contexts/useChat.js";
-import type { WorkflowRun } from "wave-agent-sdk";
 import {
   workflowManagerReducer,
   type WorkflowManagerState,
 } from "../reducers/workflowManagerReducer.js";
+import WorkflowRunDetail, {
+  formatDuration,
+  formatTokens,
+  workflowStatusColor,
+} from "./WorkflowRunDetail.js";
 
 export interface WorkflowManagerProps {
   onCancel: () => void;
 }
 
-const statusColor = (
-  status: WorkflowRun["status"],
-): "green" | "blue" | "red" | "yellow" => {
-  switch (status) {
-    case "running":
-      return "green";
-    case "completed":
-      return "blue";
-    case "failed":
-    case "aborted":
-      return "red";
-    case "paused":
-      return "yellow";
-  }
-};
-
-const formatDuration = (ms: number): string => {
-  if (ms < 1000) return `${ms}ms`;
-  if (ms < 60000) return `${Math.round(ms / 1000)}s`;
-  const minutes = Math.floor(ms / 60000);
-  const seconds = Math.round((ms % 60000) / 1000);
-  return `${minutes}m ${seconds}s`;
-};
-
-const formatTime = (timestamp: number): string => {
-  return new Date(timestamp).toLocaleTimeString();
-};
-
-const formatTokens = (tokens: number): string => {
-  if (tokens < 1000) return `${tokens}`;
-  return `${(tokens / 1000).toFixed(1)}k`;
-};
+/** Inline save dialog state, opened from a run's detail view (spec workflow「把
+ * 脚本存进库并按名字复用」场景 2). */
+interface SaveDialogState {
+  name: string;
+  scope: "project" | "user";
+  /** Set on a conflict so the next Enter overwrites instead of failing again. */
+  overwrite: boolean;
+  error?: string;
+}
 
 export const WorkflowManager: React.FC<WorkflowManagerProps> = ({
   onCancel,
 }) => {
-  const { workflowRuns, stopWorkflowRun } = useChat();
+  const { workflowRuns, stopWorkflowRun, saveWorkflowScript } = useChat();
   const MAX_VISIBLE_ITEMS = 3;
 
   const [state, dispatch] = useReducer(workflowManagerReducer, {
@@ -57,6 +38,8 @@ export const WorkflowManager: React.FC<WorkflowManagerProps> = ({
     detailRunId: null,
     pendingEffect: null,
   } as WorkflowManagerState);
+  const [saveDialog, setSaveDialog] = useState<SaveDialogState | null>(null);
+  const [saveNotice, setSaveNotice] = useState<string | null>(null);
 
   // Handle pending effects
   useEffect(() => {
@@ -82,7 +65,93 @@ export const WorkflowManager: React.FC<WorkflowManagerProps> = ({
     dispatch({ type: "SET_RUNS", runs: workflowRuns });
   }, [workflowRuns]);
 
+  const submitSave = async () => {
+    if (!saveDialog || !state.detailRunId) return;
+    try {
+      const saved = await saveWorkflowScript(state.detailRunId, {
+        name: saveDialog.name,
+        scope: saveDialog.scope,
+        overwrite: saveDialog.overwrite,
+      });
+      setSaveDialog(null);
+      setSaveNotice(`Saved "${saved.name}" to ${saved.path}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setSaveDialog((current) =>
+        current
+          ? {
+              ...current,
+              error: message,
+              // A name conflict is the one failure the user can resolve right
+              // here: the next Enter overwrites (spec 场景 4).
+              overwrite: message.includes("already exists")
+                ? true
+                : current.overwrite,
+            }
+          : current,
+      );
+    }
+  };
+
   useInput((input, key) => {
+    // The save dialog owns the keyboard while it is open, so typing a name
+    // never triggers the list/detail shortcuts underneath.
+    if (saveDialog) {
+      if (key.escape) {
+        setSaveDialog(null);
+        return;
+      }
+      if (key.tab) {
+        setSaveDialog((current) =>
+          current
+            ? {
+                ...current,
+                scope: current.scope === "project" ? "user" : "project",
+                error: undefined,
+              }
+            : current,
+        );
+        return;
+      }
+      if (key.return) {
+        void submitSave();
+        return;
+      }
+      if (key.backspace || key.delete) {
+        setSaveDialog((current) =>
+          current
+            ? {
+                ...current,
+                name: current.name.slice(0, -1),
+                error: undefined,
+              }
+            : current,
+        );
+        return;
+      }
+      if (input && !key.ctrl && !key.meta) {
+        setSaveDialog((current) =>
+          current
+            ? { ...current, name: current.name + input, error: undefined }
+            : current,
+        );
+      }
+      return;
+    }
+
+    if (state.viewMode === "detail" && state.detailRunId && input === "s") {
+      const run = state.runs.find((r) => r.runId === state.detailRunId);
+      if (run) {
+        setSaveNotice(null);
+        setSaveDialog({
+          name: run.meta.name,
+          scope: "project",
+          overwrite: false,
+        });
+      }
+      return;
+    }
+
     dispatch({ type: "HANDLE_KEY", input, key });
   });
 
@@ -94,10 +163,6 @@ export const WorkflowManager: React.FC<WorkflowManagerProps> = ({
       return null;
     }
 
-    const elapsed = run.endTime
-      ? run.endTime - run.startTime
-      : Date.now() - run.startTime;
-
     return (
       <Box
         flexDirection="column"
@@ -115,79 +180,27 @@ export const WorkflowManager: React.FC<WorkflowManagerProps> = ({
           </Text>
         </Box>
 
-        <Box flexDirection="column" gap={0}>
-          <Box>
-            <Text>
-              <Text color="blue">Run ID:</Text> {run.runId}
-            </Text>
-          </Box>
-          {run.meta.description && (
-            <Box>
-              <Text>
-                <Text color="blue">Description:</Text> {run.meta.description}
-              </Text>
-            </Box>
-          )}
-          <Box>
-            <Text>
-              <Text color="blue">Status:</Text>{" "}
-              <Text color={statusColor(run.status)}>{run.status}</Text>
-            </Text>
-          </Box>
-          <Box>
-            <Text>
-              <Text color="blue">Started:</Text> {formatTime(run.startTime)}
-              {run.endTime && (
-                <Text>
-                  {" "}
-                  | <Text color="blue">Ended:</Text> {formatTime(run.endTime)}
-                </Text>
-              )}
-              {" | "}
-              <Text color="blue">Duration:</Text> {formatDuration(elapsed)}
-            </Text>
-          </Box>
-          <Box>
-            <Text>
-              <Text color="blue">Agents:</Text> {run.totalAgents} {" | "}
-              <Text color="blue">Tokens:</Text> {formatTokens(run.totalTokens)}
-            </Text>
-          </Box>
-          <Box>
-            <Text>
-              <Text color="blue">Script:</Text> {run.scriptPath}
-            </Text>
-          </Box>
-          {run.error && (
-            <Box>
-              <Text color="red">
-                <Text color="blue">Error:</Text> {run.error}
-              </Text>
-            </Box>
-          )}
-        </Box>
+        <WorkflowRunDetail run={run} />
 
-        {run.phases.length > 0 && (
-          <Box flexDirection="column" marginTop={1}>
-            <Text color="cyan" bold>
-              Phases:
+        {saveDialog && (
+          <Box flexDirection="column">
+            <Text color="cyan">Save dynamic workflow</Text>
+            <Text>
+              Name: {saveDialog.name}
+              <Text color="cyan">▏</Text>
             </Text>
-            {run.phases.map((phase, i) => (
-              <Box key={i} marginLeft={2}>
-                <Text>
-                  <Text color="blue">{phase.title}</Text>
-                  {" — "}
-                  {phase.agentCount} agents | {formatTokens(phase.tokens)}{" "}
-                  tokens | {formatDuration(phase.elapsed)}
-                </Text>
-              </Box>
-            ))}
+            <Text dimColor>Scope: {saveDialog.scope} · Tab to switch</Text>
+            {saveDialog.error && <Text color="red">{saveDialog.error}</Text>}
           </Box>
         )}
 
+        {saveNotice && <Text color="green">{saveNotice}</Text>}
+
         <Box marginTop={1}>
           <Text dimColor>
-            {run.status === "running" ? "k to stop · " : ""}Esc back
+            {saveDialog
+              ? "Enter save · Tab scope · Esc cancel"
+              : `${run.status === "running" ? "k to stop · " : ""}s save script · Esc back`}
           </Text>
         </Box>
       </Box>
@@ -225,6 +238,17 @@ export const WorkflowManager: React.FC<WorkflowManagerProps> = ({
   );
   const visibleRuns = runs.slice(startIndex, startIndex + MAX_VISIBLE_ITEMS);
 
+  // Header counts of the states a user acts on (a failed run is plain to see in
+  // its own row, so it needs no tally).
+  const runningCount = runs.filter((r) => r.status === "running").length;
+  const completedCount = runs.filter((r) => r.status === "completed").length;
+  const subtitle = [
+    runningCount > 0 ? `${runningCount} running` : "",
+    completedCount > 0 ? `${completedCount} completed` : "",
+  ]
+    .filter(Boolean)
+    .join(" · ");
+
   return (
     <Box
       flexDirection="column"
@@ -240,6 +264,7 @@ export const WorkflowManager: React.FC<WorkflowManagerProps> = ({
         <Text color="cyan" bold>
           Workflows
         </Text>
+        {subtitle && <Text dimColor> {subtitle}</Text>}
       </Box>
       <Text dimColor>Select a run to view details</Text>
 
@@ -250,7 +275,15 @@ export const WorkflowManager: React.FC<WorkflowManagerProps> = ({
           const elapsed = run.endTime
             ? run.endTime - run.startTime
             : Date.now() - run.startTime;
-          const phaseText = run.phases.map((p) => p.title).join(" → ");
+          // Duration always reads; the two counters are dropped at zero so an
+          // unstarted run does not claim "0 agents · 0 tokens".
+          const meta = [
+            formatDuration(elapsed),
+            run.totalAgents > 0 ? `${run.totalAgents} agents` : "",
+            run.totalTokens > 0
+              ? `${formatTokens(run.totalTokens)} tokens`
+              : "",
+          ].filter(Boolean);
 
           return (
             <Box key={run.runId} flexDirection="column">
@@ -259,43 +292,24 @@ export const WorkflowManager: React.FC<WorkflowManagerProps> = ({
                 backgroundColor={isSelected ? "cyan" : undefined}
               >
                 {isSelected ? "▶ " : "  "}
-                {actualIndex + 1}. {run.runId.slice(0, 8)} {run.meta.name}
-                <Text color={statusColor(run.status)}> ({run.status})</Text>
+                {actualIndex + 1}. {run.meta.name || run.meta.description}
+                <Text color={workflowStatusColor(run.status)}>
+                  {" "}
+                  ({run.status})
+                </Text>
+                {/* Oversized marker: the row is where a run is picked, so the
+                    "too big to leave running" signal belongs on it (spec
+                    「预算与规模硬上限」场景 7). The counts are on the meta line
+                    right below, and the stop key is in the footer. */}
+                {run.sizeWarning && <Text color="yellow"> ⚠ Large</Text>}
               </Text>
               <Text
                 color={isSelected ? "black" : "gray"}
                 backgroundColor={isSelected ? "cyan" : undefined}
               >
                 {"     "}
-                {run.totalAgents} agents · {formatTokens(run.totalTokens)}{" "}
-                tokens · {formatDuration(elapsed)}
+                {meta.join(" · ")}
               </Text>
-              {phaseText && (
-                <Text
-                  color={isSelected ? "black" : "gray"}
-                  backgroundColor={isSelected ? "cyan" : undefined}
-                >
-                  {"     "}
-                  {run.phases.map((p, pi) => (
-                    <React.Fragment key={pi}>
-                      {pi > 0 && " → "}
-                      <Text
-                        color={
-                          isSelected
-                            ? "black"
-                            : pi === run.phases.length - 1 &&
-                                run.status === "running"
-                              ? "green"
-                              : undefined
-                        }
-                        backgroundColor={isSelected ? "cyan" : undefined}
-                      >
-                        {p.title}
-                      </Text>
-                    </React.Fragment>
-                  ))}
-                </Text>
-              )}
               {isSelected && (
                 <Box marginLeft={4} flexDirection="column">
                   <Text color="gray" dimColor>

package/src/components/WorkflowRunDetail.tsx

@@ -0,0 +1,193 @@
+/**
+ * WorkflowRunDetail - one workflow run's own fields, rendered for the terminal.
+ *
+ * Shared by the two CLI panels that inspect a run: the `/workflows` detail view,
+ * and the `/tasks` detail view when the selected task is a workflow (a workflow
+ * background task's id IS its run id, so the two panels join on it). Both render
+ * this component, so they cannot disagree about what a run's progress looks like.
+ *
+ * The information set matches what the webview renders through
+ * `WorkflowRunProgress` — same fields, same order, same zero-value rules — but
+ * the carrier differs: Ink text lines instead of a DOM block, and the log lines
+ * are capped because an Ink panel does not scroll. That split is the spec's
+ * cross-renderer rule (docs/specs/multi-agent/workflow.md 边界情况).
+ */
+
+import React from "react";
+import { Box, Text } from "ink";
+import { getLastLines } from "wave-agent-sdk";
+import type { WorkflowRun } from "wave-agent-sdk";
+import {
+  WORKFLOW_SIZE_WARNING_AGENTS,
+  WORKFLOW_SIZE_WARNING_TOKENS,
+} from "wave-agent-sdk/constants";
+
+export const formatDuration = (ms: number): string => {
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${Math.round(ms / 1000)}s`;
+  const minutes = Math.floor(ms / 60000);
+  const seconds = Math.round((ms % 60000) / 1000);
+  return `${minutes}m ${seconds}s`;
+};
+
+export const formatTime = (timestamp: number): string => {
+  return new Date(timestamp).toLocaleTimeString();
+};
+
+export const formatTokens = (tokens: number): string => {
+  if (tokens < 1000) return `${tokens}`;
+  // Millions matter here: a run crosses the 1.5M size threshold already showing
+  // "1500.0k", and the marker line names that threshold.
+  if (tokens < 1_000_000) return `${(tokens / 1000).toFixed(1)}k`;
+  return `${(tokens / 1_000_000).toFixed(1)}M`;
+};
+
+export const workflowStatusColor = (
+  status: WorkflowRun["status"],
+): "green" | "blue" | "red" | "yellow" => {
+  switch (status) {
+    case "running":
+      return "green";
+    case "completed":
+      return "blue";
+    case "failed":
+    case "aborted":
+      return "red";
+    case "paused":
+      return "yellow";
+  }
+};
+
+/**
+ * Log lines rendered. Same convention as this panel's OUTPUT block ("last 10
+ * lines"): a TUI panel cannot scroll, and a workflow that logs inside a loop can
+ * hold hundreds of retained lines.
+ */
+export const MAX_RUN_LOG_LINES = 10;
+
+const WorkflowRunDetail: React.FC<{ run: WorkflowRun }> = ({ run }) => {
+  const elapsed = run.endTime
+    ? run.endTime - run.startTime
+    : Date.now() - run.startTime;
+  const logs = run.logs ?? [];
+  const failures = run.failures ?? [];
+
+  return (
+    <>
+      <Box flexDirection="column" gap={0}>
+        <Box>
+          <Text>
+            <Text color="blue">Run ID:</Text> {run.runId}
+          </Text>
+        </Box>
+        {run.meta.description && (
+          <Box>
+            <Text>
+              <Text color="blue">Description:</Text> {run.meta.description}
+            </Text>
+          </Box>
+        )}
+        <Box>
+          <Text>
+            <Text color="blue">Status:</Text>{" "}
+            <Text color={workflowStatusColor(run.status)}>{run.status}</Text>
+          </Text>
+        </Box>
+        <Box>
+          <Text>
+            <Text color="blue">Started:</Text> {formatTime(run.startTime)}
+            {run.endTime && (
+              <Text>
+                {" "}
+                | <Text color="blue">Ended:</Text> {formatTime(run.endTime)}
+              </Text>
+            )}
+            {" | "}
+            <Text color="blue">Duration:</Text> {formatDuration(elapsed)}
+          </Text>
+        </Box>
+        <Box>
+          <Text>
+            <Text color="blue">Agents:</Text> {run.totalAgents} {" | "}
+            <Text color="blue">Tokens:</Text> {formatTokens(run.totalTokens)}
+          </Text>
+        </Box>
+        {/* Oversized marker (spec「预算与规模硬上限」场景 7): the run is bigger
+            than the thresholds, which is the human's cue to stop it — the model
+            is never told, so this line has to carry the scale and the
+            thresholds itself. Stopping stays with this panel's own affordance
+            (the footer's `k`), so the line only names it when the run is still
+            running and there is something to stop. */}
+        {run.sizeWarning && (
+          <Box>
+            <Text color="yellow">
+              ⚠ Large run: {run.totalAgents} agents /{" "}
+              {formatTokens(run.totalTokens)} tokens — over the{" "}
+              {WORKFLOW_SIZE_WARNING_AGENTS} agents /{" "}
+              {formatTokens(WORKFLOW_SIZE_WARNING_TOKENS)} tokens threshold.
+              {run.status === "running" && " Press k to stop it."}
+            </Text>
+          </Box>
+        )}
+        <Box>
+          <Text>
+            <Text color="blue">Script:</Text> {run.scriptPath}
+          </Text>
+        </Box>
+        {run.error && (
+          <Box>
+            <Text color="red">
+              <Text color="blue">Error:</Text> {run.error}
+            </Text>
+          </Box>
+        )}
+      </Box>
+
+      {failures.length > 0 && (
+        <Box flexDirection="column" marginTop={1}>
+          <Text color="red" bold>
+            Failures:
+          </Text>
+          {failures.map((failure, i) => (
+            <Box key={i} marginLeft={2}>
+              <Text color="red">{failure}</Text>
+            </Box>
+          ))}
+        </Box>
+      )}
+
+      {/* Only render a section that has content: an empty "Phases:" / "Logs:"
+          block reads as missing data rather than "nothing happened yet". */}
+      {run.phases.length > 0 && (
+        <Box flexDirection="column" marginTop={1}>
+          <Text color="cyan" bold>
+            Phases:
+          </Text>
+          {run.phases.map((phase, i) => (
+            <Box key={i} marginLeft={2}>
+              <Text>
+                <Text color="blue">{phase.title}</Text>
+                {" — "}
+                {phase.agentCount} agents | {formatTokens(phase.tokens)} tokens
+                | {formatDuration(phase.elapsed)}
+              </Text>
+            </Box>
+          ))}
+        </Box>
+      )}
+
+      {logs.length > 0 && (
+        <Box flexDirection="column" marginTop={1}>
+          <Text color="cyan" bold>
+            Logs (last {MAX_RUN_LOG_LINES} lines):
+          </Text>
+          <Box marginLeft={2}>
+            <Text>{getLastLines(logs.join("\n"), MAX_RUN_LOG_LINES)}</Text>
+          </Box>
+        </Box>
+      )}
+    </>
+  );
+};
+
+export default WorkflowRunDetail;

package/src/constants/commands.ts

@@ -110,6 +110,12 @@ export const AVAILABLE_COMMANDS: SlashCommand[] = [
     description: "Set a custom title for the current conversation",
     handler: () => {}, // Handler here won't be used, actual processing is in the hook
   },
+  {
+    id: "remote-control",
+    name: "remote-control",
+    description: "Serve this terminal's session to a phone",
+    handler: () => {}, // Handler here won't be used, actual processing is in the hook
+  },
   {
     id: "clear",
     name: "clear",