tinker-agent 1.5.1 → 1.7.0

package/src/tui/components/context-status.tsx

@@ -1,8 +1,12 @@
 import { Box, Text } from "ink";
+import type { BashGuardSnapshot } from "../../agent/runtime-session";
 import type { TuiProjectionState } from "../event-store";
 import { formatContextUsageLine, formatTokenCount } from "../context-format";
 
-export function ContextStatus(props: { state: TuiProjectionState }) {
+export function ContextStatus(props: {
+  state: TuiProjectionState;
+  bashGuard: BashGuardSnapshot;
+}) {
   const usage = props.state.contextUsage;
   const profile = props.state.contextProfile;
   const budget = props.state.contextBudget;
@@ -14,6 +18,12 @@ export function ContextStatus(props: { state: TuiProjectionState }) {
       <Text> model: {props.state.modelName}</Text>
       <Text> workspace: {props.state.workspaceRoot}</Text>
       <Text> </Text>
+      <Text bold>Bash guard</Text>
+      <Text>
+        {" mode: "}
+        {props.bashGuard.mode} (source: {props.bashGuard.source})
+      </Text>
+      <Text> </Text>
       <Text bold>Context</Text>
       {usage === undefined || profile === undefined || budget === undefined ? (
         <Text color="yellow"> measurement unavailable</Text>

package/src/tui/components/footer.tsx

@@ -3,9 +3,11 @@ import { Spinner, StatusMessage } from "@inkjs/ui";
 export type FooterProps = {
   status: "idle" | "running" | "cancelling" | "cancelled" | "done" | "failed";
   workedForMs?: number;
+  yolo?: boolean;
 };
 
 export function Footer(props: FooterProps) {
+  const suffix = props.yolo ? " · yolo" : "";
   if (props.status === "done") {
     if (props.workedForMs === undefined) {
       throw new Error("Done footer requires workedForMs");
@@ -14,27 +16,28 @@ export function Footer(props: FooterProps) {
     return (
       <StatusMessage variant="success">
         Worked for {formatDuration(props.workedForMs)}
+        {suffix}
       </StatusMessage>
     );
   }
 
   if (props.status === "failed") {
-    return <StatusMessage variant="error">failed</StatusMessage>;
+    return <StatusMessage variant="error">failed{suffix}</StatusMessage>;
   }
 
   if (props.status === "running") {
-    return <Spinner label="Running" />;
+    return <Spinner label={`Running${suffix}`} />;
   }
 
   if (props.status === "cancelling") {
-    return <StatusMessage variant="info">cancelling</StatusMessage>;
+    return <StatusMessage variant="info">cancelling{suffix}</StatusMessage>;
   }
 
   if (props.status === "cancelled") {
-    return <StatusMessage variant="info">cancelled</StatusMessage>;
+    return <StatusMessage variant="info">cancelled{suffix}</StatusMessage>;
   }
 
-  return <StatusMessage variant="info">idle</StatusMessage>;
+  return <StatusMessage variant="info">idle{suffix}</StatusMessage>;
 }
 
 function formatDuration(durationMs: number): string {

package/src/tui/components/prompt-input.tsx

@@ -9,7 +9,10 @@ import { ImageNotRecognizedError } from "../../image/image-probe";
 import type { ImportedImageAsset } from "../../image/image-asset-store";
 import type { ImageAssetRef } from "../../image/image-types";
 import { runtimeIdFactory, type RuntimeIdFactory } from "../../ids/runtime-id";
-import { formatContextUsageLine } from "../context-format";
+import {
+  formatContextUsageLine,
+  formatLatestProviderCacheRate,
+} from "../context-format";
 import {
   type FileMentionMatch,
   findFileMention,
@@ -722,6 +725,9 @@ export function PromptInput(props: PromptInputProps) {
   const showFileSuggestions = filePopupActive;
   const showSlashSuggestions = suggestions.length > 0 && !locked;
   const showSuggestions = showFileSuggestions || showSlashSuggestions;
+  const cacheRate = formatLatestProviderCacheRate(
+    props.contextUsage?.lastProviderUsage,
+  );
   return (
     <Box flexDirection="column">
       <Box width="100%" borderStyle="single" borderLeft={false} borderRight={false}>
@@ -745,6 +751,12 @@ export function PromptInput(props: PromptInputProps) {
               </Text>
             </>
           )}
+          {cacheRate === undefined ? null : (
+            <>
+              <Text dimColor> · </Text>
+              <Text dimColor>{cacheRate}</Text>
+            </>
+          )}
         </Box>
       )}
       {showFileSuggestions ? (

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/components/timeline.tsx

@@ -1,6 +1,7 @@
 import { Box, Text } from "ink";
 import { Fragment } from "react";
 import type { TimelineItem } from "../event-store";
+import type { AssistantStreamSectionItem } from "../tui-projection-store";
 import { AssistantMarkdown } from "./assistant-markdown";
 import { BashResultView } from "./bash-result-view";
 import { DiffView } from "./diff-view";
@@ -54,6 +55,15 @@ export function TimelineRow(props: { item: TimelineItem }) {
   );
 }
 
+export function AssistantStreamSectionRow(props: { item: AssistantStreamSectionItem }) {
+  return (
+    <Fragment>
+      {props.item.showAssistantLabel ? <Text color="gray">- assistant</Text> : null}
+      <AssistantMarkdown text={props.item.markdown} />
+    </Fragment>
+  );
+}
+
 function renderUserPrompt(prompt: NonNullable<TimelineItem["userPrompt"]>) {
   const chars = [...prompt.text];
   const fragments: React.ReactNode[] = [];

package/src/tui/context-format.ts

@@ -1,4 +1,21 @@
 import type { ContextUsageSnapshot } from "../agent/context-meter";
+import type { ModelUsage } from "../model/model-client";
+
+export function formatLatestProviderCacheRate(
+  usage: ModelUsage | undefined,
+): string | undefined {
+  const hit = usage?.promptCacheHitTokens;
+  const miss = usage?.promptCacheMissTokens;
+  if (hit === undefined || miss === undefined || hit + miss === 0) {
+    return undefined;
+  }
+  // Floor instead of round: an append turn is never a true 100% hit, and
+  // rounding would display 99.5%+ as a misleading "cache 100%". A genuine
+  // full hit (miss === 0, e.g. an identical resent request) still floors to
+  // exactly 100. The min() guards against float rounding when miss > 0.
+  const percent = Math.min(99, Math.floor((hit / (hit + miss)) * 100));
+  return `cache ${miss === 0 ? 100 : percent}%`;
+}
 
 export function formatContextUsageLine(
   usage: Pick<