tinker-agent 1.6.0 → 1.7.0

package/src/tui/components/background-tasks.tsx

@@ -5,7 +5,7 @@ export type BackgroundTasksProps = {
   tasks: readonly ShellTaskSnapshot[];
 };
 
-const MAX_VISIBLE_TASKS = 5;
+const MAX_VISIBLE_TASKS = 2;
 
 export function BackgroundTasks(props: BackgroundTasksProps) {
   if (props.tasks.length === 0) {
@@ -26,7 +26,8 @@ export function BackgroundTasks(props: BackgroundTasksProps) {
       {visibleTasks.map((task) => (
         <Box key={task.taskId} flexDirection="column">
           <Text color={colorForStatus(task.status)}>
-            {symbolForStatus(task.status)} {task.status} {taskDescription(task)}
+            {symbolForStatus(task.status)} {task.status}
+            {task.tty ? " tty" : ""} {taskDescription(task)}
             {taskResult(task) === undefined ? "" : ` ${taskResult(task)}`}
           </Text>
           <Text dimColor>{taskTiming(task)}</Text>

package/src/tui/components/resume-session-picker.tsx

@@ -1,9 +1,24 @@
-import { Box, Text, useInput, useWindowSize } from "ink";
-import { useState } from "react";
+import { Box, Text, useInput, usePaste, useWindowSize } from "ink";
+import { useReducer, useRef } from "react";
 import type { SessionSummary } from "../../session/session-catalog";
+import {
+  backspace,
+  createLineEditorState,
+  deleteForward,
+  deleteToLineStart,
+  insert,
+  moveLeft,
+  moveRight,
+  moveToLineEnd,
+  moveToLineStart,
+  splitAtCursor,
+  type LineEditorState,
+} from "../line-editor";
 
 const SESSION_ROWS = 3;
-const PICKER_CHROME_ROWS = 3;
+const BROWSE_CHROME_ROWS = 3;
+const SEARCH_CHROME_ROWS = 4;
+const MAX_DISPLAYED_SESSIONS = 20;
 
 export type ResumeSessionPickerProps = {
   sessions: readonly SessionSummary[];
@@ -16,11 +31,20 @@ export type ResumeSessionPickerProps = {
   onSelect: (session: SessionSummary) => void;
 };
 
-type PickerPosition = {
+type PickerState = {
+  mode: "browse" | "search";
+  editor: LineEditorState;
   selectedIndex: number;
   windowStart: number;
 };
 
+type PickerAction =
+  | { type: "enter_search" }
+  | { type: "clear_search" }
+  | { type: "move_selection"; direction: -1 | 1 }
+  | { type: "move_editor_cursor"; update: (editor: LineEditorState) => LineEditorState }
+  | { type: "change_query"; update: (editor: LineEditorState) => LineEditorState };
+
 export function ResumeSessionPicker(props: ResumeSessionPickerProps) {
   if (props.sessions.length === 0) {
     throw new Error("ResumeSessionPicker requires at least one session.");
@@ -32,37 +56,206 @@ export function ResumeSessionPicker(props: ResumeSessionPickerProps) {
 function ResumeSessionPickerContent(props: ResumeSessionPickerProps) {
   const windowSize = useWindowSize();
   const rows = props.viewportRows ?? windowSize.rows - 1;
-  const visibleItemCount = Math.min(
-    props.sessions.length,
-    Math.max(
-      1,
-      Math.floor(props.visibleItemCount ?? (rows - PICKER_CHROME_ROWS) / SESSION_ROWS),
+
+  const displayedFor = (value: string): readonly SessionSummary[] => {
+    const nextCandidates =
+      normalizeSearchText(value) === ""
+        ? props.sessions
+        : props.sessions.filter((session) => matchesSessionPreview(session, value));
+    return nextCandidates.slice(0, MAX_DISPLAYED_SESSIONS);
+  };
+
+  const visibleCountFor = (mode: PickerState["mode"], displayedCount: number) => {
+    const chromeRows = mode === "search" ? SEARCH_CHROME_ROWS : BROWSE_CHROME_ROWS;
+    return Math.min(
+      Math.max(displayedCount, 1),
+      Math.max(
+        1,
+        Math.floor(props.visibleItemCount ?? (rows - chromeRows) / SESSION_ROWS),
+      ),
+    );
+  };
+
+  const reduce = (state: PickerState, action: PickerAction): PickerState => {
+    switch (action.type) {
+      case "enter_search": {
+        if (state.mode === "search") {
+          return state;
+        }
+        return { ...state, mode: "search" };
+      }
+      case "clear_search": {
+        const displayed = displayedFor("");
+        return {
+          mode: "browse",
+          editor: createLineEditorState(),
+          selectedIndex: initialSelectedIndex(displayed),
+          windowStart: 0,
+        };
+      }
+      case "move_selection": {
+        const query = state.mode === "search" ? state.editor.value : "";
+        const displayed = displayedFor(query);
+        if (displayed.length === 0) {
+          return state;
+        }
+        const selectedIndex = clamp(
+          state.selectedIndex + action.direction,
+          0,
+          displayed.length - 1,
+        );
+        const windowStart = keepSelectionVisible(
+          state.windowStart,
+          selectedIndex,
+          visibleCountFor(state.mode, displayed.length),
+          displayed.length,
+        );
+        if (
+          selectedIndex === state.selectedIndex &&
+          windowStart === state.windowStart
+        ) {
+          return state;
+        }
+        return { ...state, selectedIndex, windowStart };
+      }
+      case "move_editor_cursor": {
+        const editor = action.update(state.editor);
+        return editor === state.editor ? state : { ...state, editor };
+      }
+      case "change_query": {
+        const editor = action.update(state.editor);
+        if (editor === state.editor) {
+          return state;
+        }
+        const displayed = displayedFor(editor.value);
+        return {
+          mode: "search",
+          editor,
+          selectedIndex: displayed.length === 0 ? 0 : initialSelectedIndex(displayed),
+          windowStart: 0,
+        };
+      }
+    }
+  };
+
+  const [state, baseDispatch] = useReducer(reduce, undefined, () => ({
+    mode: "browse" as const,
+    editor: createLineEditorState(),
+    selectedIndex: initialSelectedIndex(
+      props.sessions.slice(0, MAX_DISPLAYED_SESSIONS),
     ),
-  );
-  const [position, setPosition] = useState<PickerPosition>(() => ({
-    selectedIndex: initialSelectedIndex(props.sessions),
     windowStart: 0,
   }));
+  // Input events can arrive faster than React re-renders. Every state change
+  // goes through dispatch, which keeps this ref in sync with the exact action
+  // fold, so handlers always read and reduce the latest state instead of a
+  // stale render closure.
+  const stateRef = useRef(state);
+  const dispatch = (action: PickerAction) => {
+    stateRef.current = reduce(stateRef.current, action);
+    baseDispatch(action);
+  };
+
+  const query = state.mode === "search" ? state.editor.value : "";
+  const searching = normalizeSearchText(query) !== "";
+  const candidates = searching
+    ? props.sessions.filter((session) => matchesSessionPreview(session, query))
+    : props.sessions;
+  const matchCount = candidates.length;
+  const displayedSessions = candidates.slice(0, MAX_DISPLAYED_SESSIONS);
+  const visibleItemCount = visibleCountFor(state.mode, displayedSessions.length);
+  const selectedIndex = clamp(
+    state.selectedIndex,
+    0,
+    Math.max(displayedSessions.length - 1, 0),
+  );
   const windowStart = keepSelectionVisible(
-    position.windowStart,
-    position.selectedIndex,
+    state.windowStart,
+    selectedIndex,
     visibleItemCount,
-    props.sessions.length,
+    displayedSessions.length,
   );
-  const windowEnd = Math.min(props.sessions.length, windowStart + visibleItemCount);
-  const selectedSession = props.sessions[position.selectedIndex];
+  const windowEnd = Math.min(displayedSessions.length, windowStart + visibleItemCount);
+  const selectedSession = displayedSessions[selectedIndex];
+
+  const selectCurrent = () => {
+    const current = stateRef.current;
+    const currentQuery = current.mode === "search" ? current.editor.value : "";
+    const displayed = displayedFor(currentQuery);
+    const session =
+      displayed[clamp(current.selectedIndex, 0, Math.max(displayed.length - 1, 0))];
+    if (session !== undefined && isSessionSelectable(session)) {
+      props.onSelect(session);
+    }
+  };
 
   useInput(
     (input, key) => {
+      if (stateRef.current.mode === "search") {
+        if (key.escape) {
+          dispatch({ type: "clear_search" });
+          return;
+        }
+        if (key.return) {
+          selectCurrent();
+          return;
+        }
+        if (key.upArrow) {
+          dispatch({ type: "move_selection", direction: -1 });
+          return;
+        }
+        if (key.downArrow) {
+          dispatch({ type: "move_selection", direction: 1 });
+          return;
+        }
+        if (key.leftArrow) {
+          dispatch({ type: "move_editor_cursor", update: moveLeft });
+          return;
+        }
+        if (key.rightArrow) {
+          dispatch({ type: "move_editor_cursor", update: moveRight });
+          return;
+        }
+        if (key.backspace) {
+          dispatch({ type: "change_query", update: backspace });
+          return;
+        }
+        if (key.delete) {
+          dispatch({ type: "change_query", update: deleteForward });
+          return;
+        }
+        if (key.ctrl) {
+          if (input === "a") {
+            dispatch({ type: "move_editor_cursor", update: moveToLineStart });
+          } else if (input === "e") {
+            dispatch({ type: "move_editor_cursor", update: moveToLineEnd });
+          } else if (input === "u") {
+            dispatch({ type: "change_query", update: deleteToLineStart });
+          } else if (input === "d") {
+            dispatch({ type: "change_query", update: deleteForward });
+          }
+          return;
+        }
+        if (key.meta || key.pageUp || key.pageDown || input === "") {
+          return;
+        }
+        dispatch({
+          type: "change_query",
+          update: (editor) => insert(editor, normalizeQueryInput(input)),
+        });
+        return;
+      }
+
       if (key.escape) {
         props.onCancel();
         return;
       }
-
       if (key.return) {
-        if (selectedSession !== undefined && isSessionSelectable(selectedSession)) {
-          props.onSelect(selectedSession);
-        }
+        selectCurrent();
+        return;
+      }
+      if (input === "/" && !key.ctrl && !key.meta) {
+        dispatch({ type: "enter_search" });
         return;
       }
 
@@ -72,29 +265,21 @@ function ResumeSessionPickerContent(props: ResumeSessionPickerProps) {
           : key.downArrow || (input === "j" && !key.ctrl && !key.meta)
             ? 1
             : 0;
-      if (direction === 0) {
-        return;
+      if (direction !== 0) {
+        dispatch({ type: "move_selection", direction });
       }
+    },
+    { isActive: props.isResuming !== true },
+  );
 
-      setPosition((current) => {
-        const selectedIndex = clamp(
-          current.selectedIndex + direction,
-          0,
-          props.sessions.length - 1,
-        );
-        const nextWindowStart = keepSelectionVisible(
-          current.windowStart,
-          selectedIndex,
-          visibleItemCount,
-          props.sessions.length,
-        );
-        if (
-          selectedIndex === current.selectedIndex &&
-          nextWindowStart === current.windowStart
-        ) {
-          return current;
-        }
-        return { selectedIndex, windowStart: nextWindowStart };
+  usePaste(
+    (text) => {
+      if (stateRef.current.mode !== "search") {
+        return;
+      }
+      dispatch({
+        type: "change_query",
+        update: (editor) => insert(editor, normalizeQueryInput(text)),
       });
     },
     { isActive: props.isResuming !== true },
@@ -104,16 +289,19 @@ function ResumeSessionPickerContent(props: ResumeSessionPickerProps) {
   return (
     <Box flexDirection="column">
       <Text bold>Resume session</Text>
+      {state.mode === "search" ? <SearchLine editor={state.editor} /> : null}
       <Text dimColor>
         {props.isResuming === true
           ? `Resuming ${shortSessionId(selectedSession?.sessionId ?? "")}`
-          : "↑/↓ or j/k to move · Enter to resume · Esc to cancel"}
+          : state.mode === "search"
+            ? "↑/↓ to move · Enter to resume · Esc to clear search"
+            : "↑/↓ or j/k to move · / to search · Enter to resume · Esc to cancel"}
       </Text>
-      {props.sessions.slice(windowStart, windowEnd).map((session, offset) => (
+      {displayedSessions.slice(windowStart, windowEnd).map((session, offset) => (
         <SessionOption
           key={session.sessionId}
           session={session}
-          isSelected={windowStart + offset === position.selectedIndex}
+          isSelected={windowStart + offset === selectedIndex}
           now={now}
         />
       ))}
@@ -123,13 +311,31 @@ function ResumeSessionPickerContent(props: ResumeSessionPickerProps) {
         wrap="truncate-end"
       >
         {props.error === undefined
-          ? formatWindowStatus(windowStart, windowEnd, props.sessions.length)
+          ? formatFooter({
+              searching,
+              query,
+              matchCount,
+              windowStart,
+              windowEnd,
+              totalCount: props.sessions.length,
+            })
           : `Resume failed: ${singleLine(props.error)}`}
       </Text>
     </Box>
   );
 }
 
+function SearchLine(props: { editor: LineEditorState }) {
+  const { before, at, after } = splitAtCursor(props.editor);
+  return (
+    <Text wrap="truncate-end">
+      Search: {before}
+      <Text inverse>{at}</Text>
+      {after}
+    </Text>
+  );
+}
+
 export function ResumeSessionPickerLoading(props: { onCancel: () => void }) {
   useInput((_input, key) => {
     if (key.escape) {
@@ -145,6 +351,19 @@ export function ResumeSessionPickerLoading(props: { onCancel: () => void }) {
   );
 }
 
+export function normalizeSearchText(value: string): string {
+  return value.normalize("NFKC").replace(/\s+/g, " ").trim().toLowerCase();
+}
+
+export function matchesSessionPreview(session: SessionSummary, query: string): boolean {
+  const terms = normalizeSearchText(query).split(" ").filter(Boolean);
+  if (terms.length === 0) {
+    return true;
+  }
+  const preview = normalizeSearchText(session.firstUserPromptPreview ?? "");
+  return preview !== "" && terms.every((term) => preview.includes(term));
+}
+
 function SessionOption(props: {
   session: SessionSummary;
   isSelected: boolean;
@@ -255,6 +474,29 @@ function shortSessionId(sessionId: string): string {
   return `${sessionId.slice(0, 8)}…`;
 }
 
+function formatFooter(input: {
+  searching: boolean;
+  query: string;
+  matchCount: number;
+  windowStart: number;
+  windowEnd: number;
+  totalCount: number;
+}): string {
+  if (input.searching) {
+    if (input.matchCount === 0) {
+      return `No sessions match "${singleLine(input.query)}" · Esc to clear search`;
+    }
+    if (input.matchCount > MAX_DISPLAYED_SESSIONS) {
+      return `Showing ${input.windowStart + 1}–${input.windowEnd} / ${MAX_DISPLAYED_SESSIONS} results · ${input.matchCount} matches total`;
+    }
+    return `${input.matchCount} ${input.matchCount === 1 ? "match" : "matches"}`;
+  }
+  if (input.totalCount > MAX_DISPLAYED_SESSIONS) {
+    return `Showing ${input.windowStart + 1}–${input.windowEnd} / ${MAX_DISPLAYED_SESSIONS} recent · ${input.totalCount} sessions total`;
+  }
+  return formatWindowStatus(input.windowStart, input.windowEnd, input.totalCount);
+}
+
 function formatWindowStatus(start: number, end: number, total: number): string {
   if (start === 0 && end === total) {
     return `${total} ${total === 1 ? "session" : "sessions"}`;
@@ -262,6 +504,10 @@ function formatWindowStatus(start: number, end: number, total: number): string {
   return `Showing ${start + 1}–${end} / ${total}${start > 0 ? " · ↑ more above" : ""}${end < total ? " · ↓ more below" : ""}`;
 }
 
+function normalizeQueryInput(value: string): string {
+  return value.replace(/\s+/g, " ");
+}
+
 function clamp(value: number, minimum: number, maximum: number): number {
   return Math.min(Math.max(value, minimum), maximum);
 }

package/src/tui/event-store.ts

@@ -771,7 +771,11 @@ function toolCallSummary(input: { name: string; args: unknown }): string {
   if (input.name === "WebFetch") {
     return `WebFetch ${toolUrl(input.args) ?? ""}`.trim();
   }
-  if (input.name === "TaskOutput" || input.name === "TaskStop") {
+  if (
+    input.name === "TaskOutput" ||
+    input.name === "TaskInput" ||
+    input.name === "TaskStop"
+  ) {
     return `${input.name} ${toolTaskId(input.args) ?? ""}`.trim();
   }
   if (input.name === "TaskList") {
@@ -866,6 +870,10 @@ function toolRawResultSummary(name: string, args: unknown, raw: ToolRawResult):
         return `${base} -> ${raw.status}, ${raw.outputLines} line${raw.outputLines === 1 ? "" : "s"}`;
       }
       return base;
+    case "task_input":
+      return raw.ok
+        ? `${base} -> ${raw.status}, wrote ${raw.writtenBytes} byte${raw.writtenBytes === 1 ? "" : "s"}, ${raw.screenColumns}x${raw.screenRows}`
+        : base;
     case "task_stop": {
       if (raw.status === undefined) {
         return base;
@@ -911,6 +919,10 @@ function toolRawResultBashDetail(raw: ToolRawResult): Pick<TimelineItem, "bash">
       const detail = bashResultDetail(raw);
       return detail === undefined ? {} : { bash: detail };
     }
+    case "task_input": {
+      const detail = bashResultDetail(raw);
+      return detail === undefined ? {} : { bash: detail };
+    }
     case "read":
     case "write":
     case "edit":
@@ -954,6 +966,7 @@ function toolRawResultDiff(
     case "bash":
     case "task_list":
     case "task_output":
+    case "task_input":
     case "task_stop":
     case "web_search":
     case "web_fetch":

package/src/tui/tui-session-controller.ts

@@ -96,7 +96,7 @@ export class DefaultTuiSessionController implements TuiSessionController {
   };
 
   listSessions(): Promise<readonly SessionSummary[]> {
-    return this.catalog.list(this.binding.sessionId);
+    return this.catalog.listAll(this.binding.sessionId);
   }
 
   compact(): Promise<ContextCompactionResult> {