@pellux/goodvibes-tui 1.19.5 → 1.20.0

package/src/input/commands/session.ts

@@ -22,6 +22,7 @@ import type { CancellationScope, CrossSessionTaskRef } from '@pellux/goodvibes-s
 import { VALID_SCOPES } from '@pellux/goodvibes-sdk/platform/sessions';
 import { handleSessionWorkflowCommand } from './session-workflow.ts';
 import { requireSessionOrchestration, requireSessionManager } from './runtime-services.ts';
+import { filterUserFacingSessions } from './session-picker-filter.ts';
 
 // ── Argument parsing helpers ──────────────────────────────────────────────────
 
@@ -316,6 +317,37 @@ function handleCancel(args: string[], context: CommandContext): void {
 
 // ── Top-level command definition ───────────────────────────────────────────────
 
+/**
+ * SESSION_SUBCOMMAND_ARG_HINTS — the single source of truth for each
+ * `/session <subcommand>` argument hint, co-located with the switch below so
+ * the two can't silently drift apart (command-args-hint.ts imports this
+ * directly instead of hand-maintaining its own copy; a drift test —
+ * src/test/input/command-args-hint.test.ts — cross-checks every key here
+ * against the default usage text's own subcommand list). Aliases (`link`,
+ * `ho`, `g`) share their canonical subcommand's hint text.
+ */
+export const SESSION_SUBCOMMAND_ARG_HINTS: Record<string, string> = {
+  list: '',
+  rename: '<name>',
+  resume: '<id|name>',
+  fork: '[name]',
+  save: '[name]',
+  info: '[id]',
+  export: '<id|.> [markdown|text]',
+  search: '<query>',
+  delete: '<id>',
+  events: '[kind]',
+  groups: '[kind]',
+  hotspots: '',
+  'link-task': '<taskId> [--session <sid>] [--depends-on <sid:taskId>] [--label <label>]',
+  link: '<taskId> [--session <sid>] [--depends-on <sid:taskId>] [--label <label>]',
+  handoff: '<taskId> --to <sid> [--session <sid>] [--reason <reason>]',
+  ho: '<taskId> --to <sid> [--session <sid>] [--reason <reason>]',
+  graph: '[--session <sid>] [--format text|json]',
+  g: '[--session <sid>] [--format text|json]',
+  cancel: '<taskId> [--scope task|subtree|session] [--session <sid>] [--reason <reason>]',
+};
+
 /**
  * sessionCommand — The `/session` slash command.
  *
@@ -446,7 +478,10 @@ export const resumeCommand: SlashCommand = {
       return;
     }
     const sm = requireSessionManager(ctx);
-    const sessions = sm.list().filter((s) => s.name !== ctx.session.runtime.sessionId);
+    // Excludes the current session and subagent-shaped transcripts (see
+    // session-picker-filter.ts) — a direct `/resume agent-xxxxxxxx` still
+    // reaches them, this only keeps the picker itself readable.
+    const sessions = filterUserFacingSessions(sm.list()).filter((s) => s.name !== ctx.session.runtime.sessionId);
     if (sessions.length === 0) {
       ctx.print('No previous sessions to resume yet. /session save [name] stores the current one explicitly.');
       return;

package/src/input/commands/shell-core.ts

@@ -71,7 +71,20 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
         ctx.openShortcutsOverlay();
         return;
       }
-      ctx.print('Use ? key or /help for shortcuts');
+      ctx.print('Use /commands for shortcuts');
+    },
+  });
+
+  registry.register({
+    name: 'find',
+    aliases: ['findtext'],
+    description: 'Search THIS conversation transcript (same as Ctrl+F) — searching the web instead? use /search',
+    handler(_args, ctx) {
+      if (ctx.openTranscriptSearch) {
+        ctx.openTranscriptSearch();
+        return;
+      }
+      ctx.print('Transcript search is not available in this context — try Ctrl+F.');
     },
   });
 
@@ -81,10 +94,18 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
     description: 'List current keyboard bindings and their config file path',
     handler(_args, ctx) {
       const km = requireKeybindingsManager(ctx);
+      // The full binding table (~45 rows) is presented via the same
+      // generated, scrollable overlay /shortcuts opens (see
+      // renderShortcutsOverlay) rather than a one-shot transcript dump —
+      // the file path (dynamic, per-user) still gets a short transcript
+      // line since the overlay itself doesn't show it.
+      ctx.print(`Keybindings config: ${km.getConfigPath()}  (create it to override any binding: { "action": { "key": "x", "ctrl": true } })`);
+      if (ctx.openShortcutsOverlay) {
+        ctx.openShortcutsOverlay();
+        return;
+      }
       const all = km.getAll();
       const lines: string[] = [
-        `Keybindings config: ${km.getConfigPath()}`,
-        '',
         `  ${'Action'.padEnd(28)}  ${'Binding'.padEnd(20)}  Description`,
         `  ${'─'.repeat(28)}  ${'─'.repeat(20)}  ${'─'.repeat(34)}`,
       ];
@@ -92,8 +113,6 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
         const label = combos.map((combo) => km.formatCombo(combo)).join(', ');
         lines.push(`  ${action.padEnd(28)}  ${label.padEnd(20)}  ${description}`);
       }
-      lines.push('');
-      lines.push('To customize: create the config file with { "action": { "key": "x", "ctrl": true } }');
       ctx.print(lines.join('\n'));
     },
   });
@@ -114,6 +133,39 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
     },
   });
 
+  registry.register({
+    name: 'pastes',
+    aliases: ['pending-pastes'],
+    description: 'Preview the actual content behind each [TEXT: pN, M lines] fold in the composer, before you submit',
+    usage: '[pN]',
+    argsHint: '[pN]',
+    handler(args, ctx) {
+      const pending = ctx.getPendingPastes?.();
+      if (!pending || pending.size === 0) {
+        ctx.print('[Pastes] No folded pastes are currently in the composer (pastes over 8 lines fold to [TEXT: pN, M lines]).');
+        return;
+      }
+      const requestedId = args[0]?.trim();
+      if (requestedId) {
+        const content = pending.get(requestedId);
+        if (!content) {
+          ctx.print(`[Pastes] No pending paste with id "${requestedId}". Pending: ${[...pending.keys()].join(', ')}`);
+          return;
+        }
+        ctx.print(`[Pastes] ${requestedId} (${content.split('\n').length} lines):\n${content}`);
+        return;
+      }
+      const lines = ['[Pastes] Folded in the composer right now:'];
+      for (const [id, content] of pending) {
+        const contentLines = content.split('\n');
+        const preview = contentLines[0].slice(0, 80);
+        lines.push(`  ${id} — ${contentLines.length} lines — ${preview}${contentLines.length > 1 || preview.length < contentLines[0].length ? '…' : ''}`);
+      }
+      lines.push('', 'Full text: /pastes <id>');
+      ctx.print(lines.join('\n'));
+    },
+  });
+
   registry.register({
     name: 'help',
     aliases: ['h', '?'],

package/src/input/commands/update-runtime.ts

@@ -82,6 +82,91 @@ async function downloadText(fetchImpl: UpdateFetchLike, url: string): Promise<st
   return await response.text();
 }
 
+/**
+ * Where cancellation stops being allowed. An update is genuinely abortable up
+ * to and including the moment BEFORE the first file is written: every fetch on
+ * the way there carries the caller's signal, and every await boundary re-checks
+ * it. From the first write onward the swap owns the installed files and always
+ * runs to completion — a half-applied swap is the one outcome worse than a slow
+ * one.
+ *
+ * This record makes that boundary readable from outside the call. The launch
+ * updater gives `applyUpdate` a budget and abandons the promise when it runs
+ * out, so it cannot learn from the return value which side of the line the work
+ * was on — it reads these flags instead, and prints the receipt that is
+ * actually true (see src/cli/launch-auto-update.ts).
+ */
+export interface UpdateSwapProgress {
+  /** True from the first file write of the swap phase; from here the swap is never interrupted. */
+  begun: boolean;
+  /** True once every target file has been swapped into place and the update is fully installed. */
+  committed: boolean;
+  /** The release tag being installed, set as soon as the target is resolved (before any download). */
+  targetTag: string | null;
+}
+
+export function createUpdateSwapProgress(): UpdateSwapProgress {
+  return { begun: false, committed: false, targetTag: null };
+}
+
+/** The failure an aborted update ends with — raised only while nothing has been written yet. */
+export const UPDATE_ABORTED_MESSAGE = 'update cancelled before any file was replaced';
+
+function throwIfAborted(signal: AbortSignal | undefined): void {
+  if (signal?.aborted) {
+    throw new Error(UPDATE_ABORTED_MESSAGE);
+  }
+}
+
+/**
+ * The shared UpdateFetchLike init shape predates cancellation, so the signal
+ * rides on a widened version of it: the real `fetch` reads it — which is what
+ * makes the DOWNLOAD itself cancellable rather than merely abandoned — and a
+ * test stub that ignores the extra field behaves exactly as it did before.
+ */
+type AbortableFetchInit = NonNullable<Parameters<UpdateFetchLike>[1]> & { signal?: AbortSignal };
+
+function abortableFetch(fetchImpl: UpdateFetchLike, signal: AbortSignal | undefined): UpdateFetchLike {
+  if (!signal) return fetchImpl;
+  const withSignal = fetchImpl as (url: string, init?: AbortableFetchInit) => ReturnType<UpdateFetchLike>;
+  return async (url, init) => {
+    throwIfAborted(signal);
+    return await withSignal(url, { ...init, signal });
+  };
+}
+
+/**
+ * Wraps the filesystem seam so the first MUTATING call flips `begun`. The swap
+ * phase is the only part of the apply path that writes anything, so that first
+ * write is exactly the point after which cancellation must no longer be
+ * honoured. Reads (the daemon-present probe, the target-exists check inside the
+ * swap) leave the flag alone.
+ */
+function trackSwapProgress(io: UpdateFileIo, progress: UpdateSwapProgress): UpdateFileIo {
+  const begin = (): void => {
+    progress.begun = true;
+  };
+  return {
+    writeFile: (path, data) => {
+      begin();
+      io.writeFile(path, data);
+    },
+    rename: (from, to) => {
+      begin();
+      io.rename(from, to);
+    },
+    chmod: (path, mode) => {
+      begin();
+      io.chmod(path, mode);
+    },
+    mkdir: (path) => {
+      begin();
+      io.mkdir(path);
+    },
+    exists: (path) => io.exists(path),
+  };
+}
+
 /**
  * Suffix under which every swap keeps the file it replaced — re-exported
  * from the SDK's canonical update policy module so rollback and swap share
@@ -153,6 +238,16 @@ export interface ApplyUpdateOptions {
   readonly runCommand?: RunCommand;
   /** Injectable filesystem seam (the SDK's UpdateFileIo) so tests observe swaps in memory. */
   readonly io?: UpdateFileIo;
+  /**
+   * Cancels the update — for real: it is passed to every fetch in the path and
+   * re-checked at every await boundary, so an abort stops the download instead
+   * of leaving it running unwatched. Honoured only up to the moment before the
+   * swap begins; from the first file write onward it is deliberately ignored
+   * (see UpdateSwapProgress).
+   */
+  readonly signal?: AbortSignal;
+  /** Shared record letting the caller tell a cancelled update apart from one whose swap had already started. */
+  readonly progress?: UpdateSwapProgress;
 }
 
 /**
@@ -178,7 +273,14 @@ export async function applyUpdate(options: ApplyUpdateOptions): Promise<void> {
     return;
   }
 
-  const latestTag = await resolveLatestReleaseTag(options.fetchImpl, REPO_RELEASES_LATEST_URL);
+  // Every network call from here carries the caller's signal, so an abort
+  // cancels the request in flight rather than orphaning it.
+  const signal = options.signal;
+  const progress = options.progress;
+  const fetchImpl = abortableFetch(options.fetchImpl, signal);
+
+  throwIfAborted(signal);
+  const latestTag = await resolveLatestReleaseTag(fetchImpl, REPO_RELEASES_LATEST_URL);
   if (compareVersions(options.currentVersion, latestTag) >= 0) {
     options.print(`Already current: running v${normalizeVersion(options.currentVersion)}, latest release is ${latestTag}.`);
     return;
@@ -190,6 +292,10 @@ export async function applyUpdate(options: ApplyUpdateOptions): Promise<void> {
     return;
   }
 
+  // Named before the first download, so a caller that gives up on a slow apply
+  // can still report WHICH version the work was installing.
+  if (progress) progress.targetTag = latestTag;
+
   options.print(`Update available: ${latestTag} (running v${normalizeVersion(options.currentVersion)}). Downloading and verifying...`);
 
   const baseUrl = releaseDownloadBaseUrl(latestTag);
@@ -209,7 +315,8 @@ export async function applyUpdate(options: ApplyUpdateOptions): Promise<void> {
   // file is refreshed for consistency even though the platform blocks extension
   // loading. This inclusion decision needs one manifest pre-read; the swap
   // itself re-verifies every included artifact inside applyVerifiedUpdate.
-  const checksumText = await downloadText(options.fetchImpl, `${baseUrl}/${CHECKSUM_MANIFEST_NAME}`);
+  throwIfAborted(signal);
+  const checksumText = await downloadText(fetchImpl, `${baseUrl}/${CHECKSUM_MANIFEST_NAME}`);
   const checksums = parseChecksumFile(checksumText);
   const addon = resolveSqliteVecAsset(options.platform, options.arch);
   const addonIncluded = addon !== null && checksums.get(addon.assetName) !== undefined;
@@ -230,13 +337,22 @@ export async function applyUpdate(options: ApplyUpdateOptions): Promise<void> {
   // One mechanism everywhere: downloads + verifies ALL targets before any
   // write, then swaps each atomically with the outgoing file kept at
   // `<path>.previous`.
+  //
+  // This is the last point at which the update can be called off. The
+  // downloads inside applyVerifiedUpdate are still cancellable (the signal
+  // rides on every request), but its swap loop is synchronous and runs to
+  // completion once its first write lands — which is precisely what
+  // `progress.begun` records, and why nothing below this call re-checks the
+  // signal.
+  throwIfAborted(signal);
   await applyVerifiedUpdate({
-    fetchImpl: options.fetchImpl,
+    fetchImpl,
     downloadBaseUrl: baseUrl,
     targets,
-    io,
+    io: progress ? trackSwapProgress(io, progress) : io,
     platform: options.platform,
   });
+  if (progress) progress.committed = true;
 
   const serviceInfo = detectDaemonServiceManaged(options.platform, options.configManager, options.runCommand);
 

package/src/input/commands/websearch-runtime.ts

@@ -35,7 +35,7 @@ function parseSearchArgs(args: string[]): ParsedSearchArgs {
 export function registerWebSearchRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'search',
-    description: 'Search the web and render ranked results with source labels',
+    description: 'Web search — ranked results with source labels (searching THIS transcript? use /find)',
     usage: '<query> [--limit <n>]',
     argsHint: '<query> [--limit <n>]',
     async handler(args, ctx) {

package/src/input/handler-content-actions.ts

@@ -1,7 +1,7 @@
 import { readFileSync, writeFileSync, existsSync } from 'node:fs';
 import { copyToClipboard, pasteFromClipboard, pasteImageFromClipboard } from '../utils/clipboard.ts';
 import type { InfiniteBuffer } from '../core/history.ts';
-import type { ConversationManager } from '../core/conversation';
+import type { BlockMeta, ConversationManager } from '../core/conversation';
 import type { PermissionCategory } from '@pellux/goodvibes-sdk/platform/permissions';
 import type { ContentPart } from '@pellux/goodvibes-sdk/platform/providers';
 import type { CommandContext } from './command-registry.ts';
@@ -243,6 +243,30 @@ export function findMarkerAtPos(prompt: string, pos: number): { start: number; e
   return null;
 }
 
+/**
+ * describeBlockForReceipt - Honest, human-readable name for a block, used by
+ * every anchor-based action's receipt (Ctrl+Y/B/S/A, Tab, block-actions menu)
+ * so the transcript always says exactly what was acted on — never just an
+ * internal collapseKey or a bare "done".
+ */
+export function describeBlockForReceipt(block: BlockMeta): string {
+  const lineText = `${block.lineCount} line${block.lineCount === 1 ? '' : 's'}`;
+  switch (block.type) {
+    case 'tool':
+      return block.toolName ? `tool result: ${block.toolName} (${lineText})` : `tool result (${lineText})`;
+    case 'tool_group':
+      return `tool result group (${lineText})`;
+    case 'diff':
+      return block.filePath ? `diff: ${block.filePath} (${lineText})` : `diff (${lineText})`;
+    case 'code':
+      return `code block (${lineText})`;
+    case 'thinking':
+      return `thinking (${lineText})`;
+    default:
+      return `${block.type} (${lineText})`;
+  }
+}
+
 export function handleCopy(
   selection: SelectionManager,
   getHistory: () => InfiniteBuffer,
@@ -256,30 +280,42 @@ export function handleCopy(
   setTimeout(() => requestRender(), 2005);
 }
 
+/**
+ * handleBlockCopy - Ctrl+Y: copy the content of the block the user is
+ * actually looking at. `getAnchorLine` resolves to the viewport's
+ * bottom-most visible line (see getViewportBottomLine in
+ * conversation-layout.ts), not the raw scroll position — the top of the
+ * viewport is off-screen-above once the transcript is longer than one page.
+ */
 export function handleBlockCopy(
   conversationManager: ConversationManager | null,
-  getScrollTop: () => number,
+  getAnchorLine: () => number,
   requestRender: () => void,
   onCopied: () => void,
 ): void {
   if (!conversationManager) return;
-  const lineIndex = getScrollTop();
-  const content = conversationManager.getBlockContentAtLine(lineIndex);
-  if (!content) return;
-  copyToClipboard(content);
+  const lineIndex = getAnchorLine();
+  const nearest = conversationManager.findNearestBlock(lineIndex);
+  if (!nearest) {
+    conversationManager.log('[Ctrl+Y: No block found nearby]', { fg: '240' });
+    requestRender();
+    return;
+  }
+  copyToClipboard(nearest.rawContent);
   onCopied();
+  conversationManager.log(`[Copied ${describeBlockForReceipt(nearest)}]`, { fg: '#22c55e' });
   requestRender();
   setTimeout(() => requestRender(), 2005);
 }
 
 export function handleBookmark(
   conversationManager: ConversationManager | null,
-  getScrollTop: () => number,
+  getAnchorLine: () => number,
   requestRender: () => void,
   bookmarkManager: BookmarkManager,
 ): void {
   if (!conversationManager) return;
-  const lineIndex = getScrollTop();
+  const lineIndex = getAnchorLine();
   const nearest = conversationManager.findNearestBlock(lineIndex);
   if (!nearest) {
     conversationManager.log('[Ctrl+B: No block found nearby]', { fg: '240' });
@@ -288,80 +324,68 @@ export function handleBookmark(
   }
   const label = `${nearest.type}: ${nearest.rawContent.slice(0, 40).replace(/\n/g, ' ')}`;
   const added = bookmarkManager.toggle(nearest.collapseKey, label);
+  const target = describeBlockForReceipt(nearest);
   const msg = added
-    ? `[Bookmarked: ${nearest.collapseKey}]`
-    : `[Bookmark removed: ${nearest.collapseKey}]`;
+    ? `[Bookmarked: ${target}]`
+    : `[Bookmark removed: ${target}]`;
   conversationManager.log(msg, { fg: added ? '#22c55e' : '244' });
   requestRender();
 }
 
 export function handleBlockSave(
   conversationManager: ConversationManager | null,
-  getScrollTop: () => number,
+  getAnchorLine: () => number,
   requestRender: () => void,
   bookmarkManager: BookmarkManager,
 ): void {
   if (!conversationManager) return;
-  const lineIndex = getScrollTop();
-  const content = conversationManager.getBlockContentAtLine(lineIndex);
-  if (!content) {
+  const lineIndex = getAnchorLine();
+  const nearest = conversationManager.findNearestBlock(lineIndex);
+  if (!nearest) {
     conversationManager.log('[Ctrl+S: No block found nearby]', { fg: '240' });
     requestRender();
     return;
   }
-  const nearest = conversationManager.findNearestBlock(lineIndex);
-  const label = nearest?.type ?? 'block';
+  const target = describeBlockForReceipt(nearest);
   try {
-    const filePath = bookmarkManager.saveToFile(content, label);
+    const filePath = bookmarkManager.saveToFile(nearest.rawContent, nearest.type);
     const homePath = process.env.HOME || process.env.USERPROFILE || '';
     const displayPath = homePath ? filePath.replace(homePath, '~') : filePath;
-    conversationManager.log(`[Saved to: ${displayPath}]`, { fg: '#22c55e' });
+    conversationManager.log(`[Saved ${target} to: ${displayPath}]`, { fg: '#22c55e' });
   } catch (err) {
     const msg = summarizeError(err);
-    conversationManager.log(`[Save failed: ${msg}]`, { fg: '#ef4444' });
-  }
-  requestRender();
-}
-
-export function handleBlockRerun(
-  conversationManager: ConversationManager | null,
-  getScrollTop: () => number,
-  requestRender: () => void,
-): void {
-  if (!conversationManager) return;
-  const lineIndex = getScrollTop();
-  const nearest = conversationManager.findNearestBlock(lineIndex, 'tool');
-  if (!nearest) {
-    conversationManager.log('[Re-run: No tool block found nearby]', { fg: '240' });
-    requestRender();
-    return;
+    conversationManager.log(`[Save failed (${target}): ${msg}]`, { fg: '#ef4444' });
   }
   requestRender();
 }
 
 export function handleBlockToggle(
   conversationManager: ConversationManager | null,
-  getScrollTop: () => number,
+  getAnchorLine: () => number,
   requestRender: () => void,
 ): void {
   if (!conversationManager) return;
-  const lineIndex = getScrollTop();
+  const lineIndex = getAnchorLine();
+  const nearest = conversationManager.findNearestBlock(lineIndex);
+  if (!nearest) return;
+  const wasCollapsed = conversationManager.isCollapsed(nearest.blockIndex);
   const blockIdx = conversationManager.toggleCollapseAtLine(lineIndex);
   if (blockIdx >= 0) {
+    conversationManager.log(`[${wasCollapsed ? 'Expanded' : 'Collapsed'} ${describeBlockForReceipt(nearest)}]`, { fg: '244' });
     requestRender();
   }
 }
 
 export function handleDiffApply(
   conversationManager: ConversationManager | null,
-  getScrollTop: () => number,
+  getAnchorLine: () => number,
   commandContext: CommandContext | undefined,
   requestRender: () => void,
   getCallId: () => string,
   category: PermissionCategory,
 ): boolean {
   if (!conversationManager) return false;
-  const lineIndex = getScrollTop();
+  const lineIndex = getAnchorLine();
   const diff = conversationManager.getDiffAtLine(lineIndex);
   if (!diff || !diff.filePath) return false;
   const projectRoot = commandContext?.workspace.shellPaths?.workingDirectory

package/src/input/handler-feed-routes.ts

@@ -344,6 +344,11 @@ export type KeyRouteState = {
   commandRegistry?: CommandRegistry | null;
   autocomplete: AutocompleteEngine | null;
   blockActionsMenu: { open: (block: BlockMeta) => void };
+  /** The absolute history line of the bottom-most visible block — the block
+   *  the user is actually looking at (see getViewportBottomLine's doc).
+   *  Anchors Enter-on-empty-composer's block-actions menu to that block
+   *  instead of an arbitrary fixed line. */
+  getBlockAnchorLine: () => number;
   /** F2 opens+focuses the Fleet panel (which subsumes the retired process modal). */
   openFleetPanel: () => void;
   modalOpened: (name: string) => void;
@@ -430,7 +435,9 @@ export function handlePromptKeyToken(state: KeyRouteState, token: InputToken): {
 
     const text = prompt.trim();
     if (!text && !commandMode) {
-      const lineIndex = 0;
+      // Target the block the user is actually reading, not the conversation's
+      // oldest block (a fixed lineIndex 0 would always resolve there).
+      const lineIndex = state.getBlockAnchorLine();
       const nearest = state.conversationManager?.findNearestBlock(lineIndex);
       if (nearest) {
         state.modalOpened('blockActions');
@@ -603,6 +610,13 @@ export function handlePromptKeyToken(state: KeyRouteState, token: InputToken): {
   }
 
   if (token.logicalName === 'down') {
+    // Announce the focus move honestly — this handoff is otherwise silent
+    // and easy to miss (the next keystrokes look like they're doing nothing,
+    // because they're now landing on the indicator, not the composer).
+    const announceIndicatorFocus = () => {
+      indicatorFocused = true;
+      state.commandContext?.print('[Down] Focus moved to the process indicator — Up or Esc returns to the composer.');
+    };
     const move = computeCursorVerticalMove(prompt, cursorPos, inputScrollTop, state.contentWidth, state.maxInputRows, 1);
     if (move.moved) {
       cursorPos = move.cursorPos;
@@ -617,10 +631,10 @@ export function handlePromptKeyToken(state: KeyRouteState, token: InputToken): {
           cursorPos = recalled.length;
           ensureLocalInputCursorVisible();
         } else {
-          indicatorFocused = true;
+          announceIndicatorFocus();
         }
       } else {
-        indicatorFocused = true;
+        announceIndicatorFocus();
       }
     }
     return { handled: true, prompt, cursorPos, inputScrollTop, commandMode, indicatorFocused };

package/src/input/handler-feed.ts

@@ -34,6 +34,7 @@ import {
 } from './handler-feed-routes.ts';
 import type { PanelBurstGuardState } from './panel-paste-flood-guard.ts';
 import type { WrappedPromptInfo } from './handler-prompt-buffer.ts';
+import { getViewportBottomLine } from '../renderer/conversation-layout.ts';
 import { handleModalTokenRoutes } from './handler-modal-token-routes.ts';
 import { handleCommandModeToken } from './handler-command-route.ts';
 import { handleGlobalShortcutToken } from './handler-shortcuts.ts';
@@ -224,6 +225,7 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
 
     const modalRoute = handleModalTokenRoutes({
       history,
+      conversationManager: context.conversationManager,
       searchShortcutMatch: token.type === 'key' && keybindings.matches('search', token),
       selectionModal: context.selectionModal,
       selectionCallback: context.selectionCallback,
@@ -477,6 +479,7 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
         submitConcealedInput: context.submitConcealedInput,
         autocomplete: context.autocomplete,
         blockActionsMenu: { open: (block: BlockMeta) => context.blockActionsMenu.open(block) },
+        getBlockAnchorLine: () => getViewportBottomLine(scrollTop, viewportHeight, lineCount),
         openFleetPanel,
         modalOpened: context.modalOpened,
         saveUndoState: context.saveUndoState,