@vybestack/llxprt-code 0.10.0 → 0.11.0-nightly.260728.ffaa8d5d7

package/src/ui/containers/AppContainer/hooks/useKeybindings.ts

@@ -48,6 +48,8 @@ export interface DisplayKeybindingDeps {
   setRenderMarkdown: (v: boolean) => void;
   isTodoPanelCollapsed: boolean;
   setIsTodoPanelCollapsed: (v: boolean) => void;
+  isQueuedMessagesPanelCollapsed: boolean;
+  setIsQueuedMessagesPanelCollapsed: (v: boolean) => void;
   constrainHeight: boolean;
   setConstrainHeight: (v: boolean) => void;
   refreshStatic: () => void;
@@ -195,6 +197,13 @@ function handleDisplayKeys(
     return;
   }
 
+  if (keyMatchers[Command.TOGGLE_QUEUED_MESSAGES](key)) {
+    display.setIsQueuedMessagesPanelCollapsed(
+      !display.isQueuedMessagesPanelCollapsed,
+    );
+    return;
+  }
+
   if (
     keyMatchers[Command.SHOW_MORE_LINES](key) &&
     !enteringConstrainHeightMode
@@ -253,48 +262,52 @@ function handleIdeAndShellKeys(
 }
 
 export function useKeybindings(params: UseKeybindingsParams): void {
-  const { exit, display, shell, copyMode, ideContext, mcp } = params;
+  // Keep the latest deps in a ref so the keypress handler closure below never
+  // goes stale, while keeping the callback identity stable. useKeypress
+  // registers the handler once (empty deps) — if the callback changed on every
+  // render, registration would churn or miss keys during rapid dep updates.
+  const latestParamsRef = useRef(params);
+  latestParamsRef.current = params;
 
   // Instance-local mouse state tracking for copy mode save/restore.
   const mouseStateBeforeCopyModeRef = useRef<boolean | null>(null);
 
-  const handleGlobalKeypress = useCallback(
-    (key: Key) => {
-      // Priority 1: Copy mode (highest priority - immediate exit from copy mode)
-      if (handleCopyModeKey(key, copyMode, mouseStateBeforeCopyModeRef)) {
-        return;
-      }
-
-      // Priority 2: Exit keys (Ctrl+C/D)
-      if (handleExitKeys(key, exit)) {
-        return;
-      }
-
-      // Calculate constrain height mode transition
-      let enteringConstrainHeightMode = false;
-      if (!display.constrainHeight) {
-        enteringConstrainHeightMode = true;
-        display.setConstrainHeight(true);
-      }
-
-      // Priority 3: Display toggles
-      handleDisplayKeys(key, display, mcp, enteringConstrainHeightMode);
-
-      // Priority 4: IDE and shell keys
-      handleIdeAndShellKeys(key, ideContext, shell);
-
-      // Handle IDE status command separately (needs handleSlashCommand)
-      if (
-        keyMatchers[Command.SHOW_IDE_CONTEXT_DETAIL](key) &&
-        ideContext.getIdeMode() &&
-        ideContext.ideContextState !== undefined &&
-        ideContext.ideContextState !== null
-      ) {
-        void display.handleSlashCommand('/ide status');
-      }
-    },
-    [exit, display, shell, copyMode, ideContext, mcp],
-  );
+  const handleGlobalKeypress = useCallback((key: Key) => {
+    const { exit, display, shell, copyMode, ideContext, mcp } =
+      latestParamsRef.current;
+    // Priority 1: Copy mode (highest priority - immediate exit from copy mode)
+    if (handleCopyModeKey(key, copyMode, mouseStateBeforeCopyModeRef)) {
+      return;
+    }
+
+    // Priority 2: Exit keys (Ctrl+C/D)
+    if (handleExitKeys(key, exit)) {
+      return;
+    }
+
+    // Calculate constrain height mode transition
+    let enteringConstrainHeightMode = false;
+    if (!display.constrainHeight) {
+      enteringConstrainHeightMode = true;
+      display.setConstrainHeight(true);
+    }
+
+    // Priority 3: Display toggles
+    handleDisplayKeys(key, display, mcp, enteringConstrainHeightMode);
+
+    // Priority 4: IDE and shell keys
+    handleIdeAndShellKeys(key, ideContext, shell);
+
+    // Handle IDE status command separately (needs handleSlashCommand)
+    if (
+      keyMatchers[Command.SHOW_IDE_CONTEXT_DETAIL](key) &&
+      ideContext.getIdeMode() &&
+      ideContext.ideContextState !== undefined &&
+      ideContext.ideContextState !== null
+    ) {
+      void display.handleSlashCommand('/ide status');
+    }
+  }, []);
 
   useKeypress(handleGlobalKeypress, {
     isActive: true,

package/src/ui/containers/AppContainer/hooks/useSteer.ts

@@ -0,0 +1,51 @@
+/**
+ * @license
+ * Copyright 2025 Vybestack LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useCallback } from 'react';
+import { StreamingState, type HistoryItemWithoutId } from '../../../types.js';
+import { isToolExecuting } from './useInputHandling.js';
+
+interface SteerAgent {
+  injectSteer(text: string): void;
+}
+
+interface SanitizedContent {
+  text: string;
+  blocked: boolean;
+  feedback?: string;
+}
+
+export function useSteer(
+  agent: SteerAgent,
+  streamingState: StreamingState,
+  sanitizeContent: (text: string) => SanitizedContent,
+  pendingHistoryItems: HistoryItemWithoutId[],
+  addMessage: (message: string) => void,
+): (text: string) => boolean {
+  return useCallback(
+    (text: string): boolean => {
+      if (streamingState !== StreamingState.Responding) {
+        return false;
+      }
+      let sanitized: SanitizedContent;
+      try {
+        sanitized = sanitizeContent(text);
+      } catch {
+        return false;
+      }
+      if (sanitized.blocked || sanitized.text.length === 0) {
+        return false;
+      }
+      if (!isToolExecuting(pendingHistoryItems)) {
+        addMessage(sanitized.text);
+        return true;
+      }
+      agent.injectSteer(sanitized.text);
+      return true;
+    },
+    [streamingState, sanitizeContent, pendingHistoryItems, addMessage, agent],
+  );
+}

package/src/ui/contexts/KeypressContext.tsx

@@ -263,8 +263,14 @@ function applyKeyCodeModifier(
     if (codeNumber >= 'a'.charCodeAt(0) && codeNumber <= 'z'.charCodeAt(0)) {
       return { name: String.fromCharCode(codeNumber), shift, meta, ctrl };
     }
-    if (codeNumber === '\\'.charCodeAt(0))
-      return { name: '\\', shift, meta, ctrl };
+    if (
+      codeNumber === '\\'.charCodeAt(0) ||
+      codeNumber === ']'.charCodeAt(0) ||
+      codeNumber === '^'.charCodeAt(0) ||
+      codeNumber === '_'.charCodeAt(0)
+    ) {
+      return { name: String.fromCharCode(codeNumber), shift, meta, ctrl };
+    }
   }
   return { name: 'undefined', shift, meta, ctrl };
 }
@@ -300,6 +306,11 @@ function parseNonEscapeKey(
   } else if (!escaped && ch.charCodeAt(0) <= 0x1a) {
     name = String.fromCharCode(ch.charCodeAt(0) + 'a'.charCodeAt(0) - 1);
     ctrl = true;
+  } else if (!escaped && ch.charCodeAt(0) >= 0x1c && ch.charCodeAt(0) <= 0x1f) {
+    // C0 control chars above Ctrl+Z map to the literal character on the key
+    // (ASCII offset 0x40): \x1c → \, \x1d → ], \x1e → ^, \x1f → _
+    name = String.fromCharCode(ch.charCodeAt(0) + 0x40);
+    ctrl = true;
   } else if (/^[0-9A-Za-z]$/.test(ch)) {
     name = ch.toLowerCase();
     shift = /^[A-Z]$/.test(ch);

package/src/ui/contexts/ShellCommandDisplayContext.tsx

@@ -0,0 +1,103 @@
+/**
+ * @license
+ * Copyright 2025 Vybestack LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type React from 'react';
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useMemo,
+  useState,
+} from 'react';
+import { SHELL_COMMAND_NAME, SHELL_NAME } from '../constants.js';
+import { useKeypress } from '../hooks/useKeypress.js';
+import { ToolCallStatus } from '../types.js';
+
+interface ShellCommandDisplayState {
+  getShowFullDescription: (callId: string) => boolean;
+  toggleShowFullDescription: (callId: string) => void;
+}
+
+const ShellCommandDisplayContext =
+  createContext<ShellCommandDisplayState | null>(null);
+
+interface ShellCommandDisplayProviderProps {
+  alwaysDisplayFullShellCommand: boolean;
+  children: React.ReactNode;
+}
+
+export const ShellCommandDisplayProvider: React.FC<
+  ShellCommandDisplayProviderProps
+> = ({ alwaysDisplayFullShellCommand, children }) => {
+  const [callDisplayOverrides, setCallDisplayOverrides] = useState<
+    ReadonlyMap<string, boolean>
+  >(() => new Map());
+
+  const getShowFullDescription = useCallback(
+    (callId: string): boolean =>
+      callDisplayOverrides.get(callId) ?? alwaysDisplayFullShellCommand,
+    [alwaysDisplayFullShellCommand, callDisplayOverrides],
+  );
+
+  const toggleShowFullDescription = useCallback(
+    (callId: string): void => {
+      setCallDisplayOverrides((previousOverrides) => {
+        const currentValue =
+          previousOverrides.get(callId) ?? alwaysDisplayFullShellCommand;
+        return new Map([
+          ...previousOverrides.entries(),
+          [callId, !currentValue],
+        ]);
+      });
+    },
+    [alwaysDisplayFullShellCommand],
+  );
+
+  const value = useMemo<ShellCommandDisplayState>(
+    () => ({ getShowFullDescription, toggleShowFullDescription }),
+    [getShowFullDescription, toggleShowFullDescription],
+  );
+
+  return (
+    <ShellCommandDisplayContext.Provider value={value}>
+      {children}
+    </ShellCommandDisplayContext.Provider>
+  );
+};
+
+export function useShellCommandDisplay(
+  callId: string,
+  name: string,
+  status: ToolCallStatus,
+  isFocused: boolean,
+): boolean {
+  const context = useContext(ShellCommandDisplayContext);
+  if (context === null) {
+    throw new Error(
+      'useShellCommandDisplay must be used within ShellCommandDisplayProvider',
+    );
+  }
+
+  const isShellTool = name === SHELL_COMMAND_NAME || name === SHELL_NAME;
+  const { getShowFullDescription, toggleShowFullDescription } = context;
+  const onKeypress = useCallback(
+    (key: { ctrl?: boolean; name?: string }): void => {
+      if (
+        isShellTool &&
+        key.ctrl === true &&
+        key.name === 'r' &&
+        status === ToolCallStatus.Executing
+      ) {
+        toggleShowFullDescription(callId);
+      }
+    },
+    [callId, isShellTool, status, toggleShowFullDescription],
+  );
+
+  useKeypress(onKeypress, { isActive: isFocused && isShellTool });
+
+  return isShellTool && getShowFullDescription(callId);
+}

package/src/ui/contexts/TodoContext.tsx

@@ -11,15 +11,6 @@ interface TodoContextType {
   todos: Todo[];
   updateTodos: (todos: Todo[]) => void;
   refreshTodos: () => void;
-  /**
-   * Whether task-list continuation is paused via the pause tool.
-   * Persisted across sessions to survive --continue restores.
-   */
-  paused: boolean;
-  /**
-   * Set the paused state. Persists to disk immediately.
-   */
-  setPaused: (paused: boolean) => void;
 }
 
 const defaultContextValue: TodoContextType = {
@@ -34,10 +25,6 @@ const defaultContextValue: TodoContextType = {
       'TodoContext refreshTodos not implemented - use TodoProvider',
     );
   },
-  paused: false,
-  setPaused: () => {
-    throw new Error('TodoContext setPaused not implemented - use TodoProvider');
-  },
 };
 
 export const TodoContext =

package/src/ui/contexts/TodoProvider.tsx

@@ -27,7 +27,6 @@ interface TodoProviderProps {
  */
 function useTaskState(sessionId: string, agentId: string | undefined) {
   const [todos, setTodos] = useState<Todo[]>([]);
-  const [paused, setPausedState] = useState<boolean>(false);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
 
@@ -42,16 +41,13 @@ function useTaskState(sessionId: string, agentId: string | undefined) {
         agentId,
       );
       const loadedTodos = await store.readTodos();
-      const pausedState = await store.readPausedState();
       setTodos(loadedTodos);
-      setPausedState(pausedState);
       setError(null);
     } catch (err) {
       setError(
         `Failed to load todos: ${err instanceof Error ? err.message : 'Unknown error'}`,
       );
       setTodos([]);
-      setPausedState(false);
     } finally {
       setLoading(false);
     }
@@ -60,8 +56,6 @@ function useTaskState(sessionId: string, agentId: string | undefined) {
   return {
     todos,
     setTodos,
-    paused,
-    setPausedState,
     loading,
     setLoading,
     error,
@@ -105,7 +99,6 @@ function useTaskPersistence(
   sessionId: string,
   agentId: string | undefined,
   setTodos: (todos: Todo[]) => void,
-  setPausedState: (paused: boolean) => void,
   setError: (error: string | null) => void,
 ) {
   const updateTodos = useCallback(
@@ -127,26 +120,7 @@ function useTaskPersistence(
     [agentId, sessionId, setTodos, setError],
   );
 
-  const setPaused = useCallback(
-    (newPaused: boolean) => {
-      setPausedState(newPaused);
-      const store = new TodoStore(
-        sessionId,
-        {
-          dataDirResolver: () => Storage.getGlobalDataDir(),
-        },
-        agentId,
-      );
-      store.writePausedState(newPaused).catch((err: unknown) => {
-        setError(
-          `Failed to save paused state: ${err instanceof Error ? err.message : 'Unknown error'}`,
-        );
-      });
-    },
-    [agentId, sessionId, setPausedState, setError],
-  );
-
-  return { updateTodos, setPaused };
+  return { updateTodos };
 }
 
 /**
@@ -162,7 +136,6 @@ function useTaskManagement(sessionId: string, agentId: string | undefined) {
     sessionId,
     agentId,
     state.setTodos,
-    state.setPausedState,
     state.setError,
   );
 
@@ -175,12 +148,10 @@ function useTaskManagement(sessionId: string, agentId: string | undefined) {
 
   return {
     todos: state.todos,
-    paused: state.paused,
     loading: state.loading,
     error: state.error,
     refreshTodos: state.refreshTodos,
     updateTodos: persistence.updateTodos,
-    setPaused: persistence.setPaused,
   };
 }
 
@@ -196,8 +167,6 @@ export const TodoProvider: React.FC<TodoProviderProps> = ({
       todos: management.todos,
       updateTodos: management.updateTodos,
       refreshTodos: management.refreshTodos,
-      paused: management.paused,
-      setPaused: management.setPaused,
       loading: management.loading,
       error: management.error,
     }),
@@ -205,8 +174,6 @@ export const TodoProvider: React.FC<TodoProviderProps> = ({
       management.todos,
       management.updateTodos,
       management.refreshTodos,
-      management.paused,
-      management.setPaused,
       management.loading,
       management.error,
     ],

package/src/ui/contexts/UIActionsContext.tsx

@@ -28,6 +28,7 @@ export interface UIActions {
 
   // Input actions
   handleUserInputSubmit: (value: string) => void;
+  handleSteer: (text: string) => boolean;
   handleClearScreen: () => void;
 
   // Theme dialog
@@ -95,7 +96,7 @@ export interface UIActions {
   exitToolsDialog: () => void;
 
   // Folder trust dialog
-  handleFolderTrustSelect: (choice: FolderTrustChoice) => void;
+  handleFolderTrustSelect: (choice: FolderTrustChoice) => Promise<void>;
 
   // Welcome onboarding
   welcomeActions: {

package/src/ui/contexts/UIStateContext.tsx

@@ -25,6 +25,7 @@ import type {
 } from '@vybestack/llxprt-code-core';
 import type { ToolInfo } from '@vybestack/llxprt-code-agents';
 import type { SlashCommandRuntime } from '../cliUiRuntime.js';
+import type { QueuedSubmission } from '../hooks/agentStream/types.js';
 import type { SlashCommand, CommandContext } from '../commands/types.js';
 
 import type { LoadedSettings } from '../../config/settings.js';
@@ -140,7 +141,6 @@ export interface UIState {
   ctrlCPressedOnce: boolean;
   ctrlDPressedOnce: boolean;
   showEscapePrompt: boolean;
-  showIdeRestartPrompt: boolean;
   quittingMessages: HistoryItem[] | null;
 
   // Display options
@@ -148,6 +148,8 @@ export interface UIState {
   showErrorDetails: boolean;
   showToolDescriptions: boolean;
   isTodoPanelCollapsed: boolean;
+  isQueuedMessagesPanelCollapsed: boolean;
+  queuedSubmissions: readonly QueuedSubmission[];
   isNarrow: boolean;
   vimModeEnabled: boolean;
   vimMode: string | undefined;
@@ -200,7 +202,6 @@ export interface UIState {
   currentIDE: IdeInfo | undefined;
 
   // Trust
-  isRestarting: boolean;
   isTrustedFolder: boolean;
 
   // Welcome onboarding

package/src/ui/hooks/agentStream/streamUtils.ts

@@ -342,30 +342,6 @@ export function deduplicateToolCallRequests(
   });
 }
 
-/**
- * Creates a ThinkingBlock from a thought event, deduplicating against existing blocks.
- * Returns null if the thought is empty or already present in existingBlocks.
- */
-export function buildThinkingBlock(
-  thoughtText: string,
-  existingBlocks: ThinkingBlock[],
-): ThinkingBlock | null {
-  if (!thoughtText) {
-    return null;
-  }
-  const alreadyHasThought = existingBlocks.some(
-    (tb) => tb.thought === thoughtText,
-  );
-  if (alreadyHasThought) {
-    return null;
-  }
-  return {
-    type: 'thinking',
-    thought: thoughtText,
-    sourceField: 'thought',
-  };
-}
-
 /**
  * Builds the full-split pending history item for the no-split case in
  * handleContentEvent. Preserves the existing item's type and profileName.

package/src/ui/hooks/agentStream/thoughtState.ts

@@ -15,6 +15,36 @@ import {
   type HistoryItemWithoutId,
 } from '../../types.js';
 
+function findStreamBlockIndex(
+  blocks: ThinkingBlock[],
+  streamId: string | undefined,
+): number {
+  if (streamId === undefined) {
+    return -1;
+  }
+  return blocks.findIndex((block) => block.streamId === streamId);
+}
+
+function hasDuplicateNoStreamThought(
+  blocks: ThinkingBlock[],
+  thoughtText: string,
+  streamId: string | undefined,
+): boolean {
+  return (
+    streamId === undefined &&
+    thoughtText !== '' &&
+    blocks.some(
+      (block) => block.streamId === undefined && block.thought === thoughtText,
+    )
+  );
+}
+
+function buildThoughtText(thoughtSummary: ThoughtSummary): string {
+  return [thoughtSummary.subject, thoughtSummary.description]
+    .filter(Boolean)
+    .join(': ');
+}
+
 export function applyThoughtToState(
   thoughtSummary: ThoughtSummary,
   sanitizeContent: (text: string) => {
@@ -32,52 +62,102 @@ export function applyThoughtToState(
 ): void {
   setLastAgentActivityTime(Date.now());
   setThought(thoughtSummary);
-  let thoughtText = [thoughtSummary.subject, thoughtSummary.description]
-    .filter(Boolean)
-    .join(': ');
+  let thoughtText = buildThoughtText(thoughtSummary);
   const sanitized = sanitizeContent(thoughtText);
   thoughtText = sanitized.blocked ? '' : sanitized.text;
-  const thinkingBlock = buildThinkingBlock(
-    thoughtText,
+
+  const streamBlockIndex = findStreamBlockIndex(
     thinkingBlocksRef.current,
+    thoughtSummary.streamId,
+  );
+
+  if (streamBlockIndex >= 0) {
+    const existingBlock = thinkingBlocksRef.current[streamBlockIndex];
+    const updatedThought = thoughtText || existingBlock.thought;
+    thinkingBlocksRef.current = thinkingBlocksRef.current.map((block, index) =>
+      index === streamBlockIndex
+        ? {
+            ...existingBlock,
+            thought: updatedThought,
+            ...(thoughtSummary.streamStatus !== undefined
+              ? { streamStatus: thoughtSummary.streamStatus }
+              : {}),
+          }
+        : block,
+    );
+    updatePendingWithThinking(
+      getContentPrefixIdentity,
+      thinkingBlocksRef,
+      setPendingHistoryItem,
+    );
+    return;
+  }
+
+  if (
+    hasDuplicateNoStreamThought(
+      thinkingBlocksRef.current,
+      thoughtText,
+      thoughtSummary.streamId,
+    )
+  ) {
+    return;
+  }
+
+  const thinkingBlock = createThinkingBlockFromSummary(
+    thoughtText,
+    thoughtSummary,
   );
   if (thinkingBlock) {
-    thinkingBlocksRef.current.push(thinkingBlock);
-    const rawIdentity = getContentPrefixIdentity();
-    const liveProfileName = rawIdentity === '' ? null : rawIdentity;
-    setPendingHistoryItem((item) => {
-      const existingProfileName = (
-        item as HistoryItemAi | HistoryItemAiContent | undefined
-      )?.profileName;
-      const profileName = liveProfileName ?? existingProfileName;
-      const itemType =
-        item?.type === 'gemini_content' ? 'gemini_content' : 'gemini';
-      return {
-        type: itemType,
-        text: item?.text ?? '',
-        ...(profileName != null ? { profileName } : {}),
-        thinkingBlocks: [...thinkingBlocksRef.current],
-      };
-    });
+    thinkingBlocksRef.current = [...thinkingBlocksRef.current, thinkingBlock];
+    updatePendingWithThinking(
+      getContentPrefixIdentity,
+      thinkingBlocksRef,
+      setPendingHistoryItem,
+    );
   }
 }
 
-function buildThinkingBlock(
+function updatePendingWithThinking(
+  getContentPrefixIdentity: () => string | null,
+  thinkingBlocksRef: React.MutableRefObject<ThinkingBlock[]>,
+  setPendingHistoryItem: (
+    updater: (item: HistoryItemWithoutId | null) => HistoryItemWithoutId | null,
+  ) => void,
+): void {
+  const rawIdentity = getContentPrefixIdentity();
+  const liveProfileName = rawIdentity === '' ? null : rawIdentity;
+  setPendingHistoryItem((item) => {
+    const existingProfileName = (
+      item as HistoryItemAi | HistoryItemAiContent | undefined
+    )?.profileName;
+    const profileName = liveProfileName ?? existingProfileName;
+    const itemType =
+      item?.type === 'gemini_content' ? 'gemini_content' : 'gemini';
+    return {
+      type: itemType,
+      text: item?.text ?? '',
+      ...(profileName != null ? { profileName } : {}),
+      thinkingBlocks: [...thinkingBlocksRef.current],
+    };
+  });
+}
+
+function createThinkingBlockFromSummary(
   thoughtText: string,
-  existingBlocks: ThinkingBlock[],
+  thoughtSummary: ThoughtSummary,
 ): ThinkingBlock | null {
   if (!thoughtText) {
     return null;
   }
-  const alreadyHasThought = existingBlocks.some(
-    (tb) => tb.thought === thoughtText,
-  );
-  if (alreadyHasThought) {
-    return null;
-  }
   return {
     type: 'thinking',
     thought: thoughtText,
     sourceField: 'thought',
+    ...(thoughtSummary.streamId !== undefined
+      ? { streamId: thoughtSummary.streamId }
+      : {}),
+    ...(thoughtSummary.streamStatus !== undefined
+      ? { streamStatus: thoughtSummary.streamStatus }
+      : {}),
   };
 }

package/src/ui/hooks/agentStream/types.ts

@@ -21,4 +21,5 @@ export interface QueuedSubmission {
   query: AgentRequestInput;
   options?: { isContinuation: boolean };
   promptId?: string;
+  readonly queueId?: number;
 }