@pellux/goodvibes-tui 1.19.6 → 1.20.0

package/src/input/selection-modal-queue.ts

@@ -0,0 +1,176 @@
+/**
+ * selection-modal-queue.ts — Serializes overlapping InputHandler.openSelection() calls.
+ *
+ * openSelection (handler.ts) writes into a singleton SelectionModal plus a
+ * single callback slot. A second openSelection call while one is already
+ * showing used to silently overwrite both — the pre-empted caller's callback
+ * was never invoked, not even with null, so any caller that awaits it (see
+ * the `ask()` helper in runtime/recovery-prompt.ts, which wraps the callback
+ * in a Promise) hung forever. This is reachable in production: the
+ * `--continue` liveness-confirm modal (session-resume-liveness-confirm.ts)
+ * races the startup recovery offer, which is scheduled on a 0ms macrotask
+ * (scheduleRecoveryOffer in runtime/recovery-prompt.ts).
+ *
+ * Fix: queue overlapping requests FIFO and open each automatically once the
+ * previous one resolves, through the SAME callback the caller already
+ * supplied — openSelection's public signature never changes.
+ *
+ * Why the drain is deferred to a microtask instead of running inline inside
+ * the resolving callback: both resolution paths — the select/enter path in
+ * handler-modal-routes.ts's dispatchSelectionAction, and the Escape path in
+ * handler-modal-stack.ts's handleEscape/closeSelection — take a snapshot of
+ * the current selectionCallback before dispatch and write some form of that
+ * snapshot back into handler/context state AFTER invoking the callback (the
+ * select path re-reads via getSelectionCallback; the Escape path threads a
+ * local variable back out through handleEscapeForHandler in
+ * handler-interactions.ts). If this module opened the next queued request
+ * synchronously inside the resolving callback, those post-callback
+ * write-backs would immediately clobber the freshly-set callback for the
+ * newly-opened modal. Deferring past the end of the synchronous resolution
+ * (queueMicrotask) lets all of that settle first, then opens the next
+ * request cleanly — the same shape as the production race this fixes, which
+ * itself resolves via a deferred (macrotask) call.
+ */
+import type { SelectionItem, SelectionAction, SelectionResult, SelectionModal } from './selection-modal.ts';
+
+export type SelectionModalCallback = (result: SelectionResult | null) => void;
+
+export interface SelectionOpenOpts {
+  preSelectId?: string;
+  allowSearch?: boolean;
+  customActions?: Map<string, SelectionAction>;
+  primaryVerbLabel?: string;
+}
+
+export interface PendingSelectionRequest {
+  readonly title: string;
+  readonly items: SelectionItem[];
+  readonly opts: SelectionOpenOpts | undefined;
+  readonly callback: SelectionModalCallback;
+}
+
+/**
+ * Maximum number of openSelection() calls held while one is already showing.
+ * In practice at most two calls ever race in production (the liveness-confirm
+ * modal vs. the recovery offer's 0ms macrotask), so 8 is generous headroom
+ * for any future chained-picker sequence without letting a misbehaving
+ * caller queue without bound. Once full, the overflowing call is resolved
+ * with `null` immediately — a bounded queue must still give every caller a
+ * definite answer, never silently drop one.
+ */
+export const MAX_QUEUED_SELECTIONS = 8;
+
+/** Dependencies the queue needs from InputHandler, kept minimal and explicit. */
+export interface SelectionQueueHost {
+  readonly selectionModal: Pick<SelectionModal, 'active' | 'open'>;
+  /** Assigns InputHandler.selectionCallback (the live resolution slot). */
+  setSelectionCallback(callback: SelectionModalCallback | null): void;
+  /** Mirrors the callback into the in-flight feed context, when a feed() call is in progress (no-op otherwise). */
+  syncFeedSelectionCallback(callback: SelectionModalCallback | null): void;
+  modalOpened(name: string): void;
+  requestRender(): void;
+}
+
+/** Owns the FIFO of pending openSelection() requests for one InputHandler instance. */
+export class SelectionModalQueue {
+  private readonly pending: PendingSelectionRequest[] = [];
+
+  constructor(private readonly host: SelectionQueueHost) {}
+
+  /** Number of requests currently queued (excludes whichever modal is actively showing, if any). */
+  public get size(): number {
+    return this.pending.length;
+  }
+
+  /**
+   * Open `request` immediately if no selection modal is currently showing;
+   * otherwise queue it FIFO. If the queue is already at MAX_QUEUED_SELECTIONS,
+   * the request is resolved with `null` right away instead of being queued.
+   */
+  public request(request: PendingSelectionRequest): void {
+    if (this.host.selectionModal.active) {
+      if (this.pending.length >= MAX_QUEUED_SELECTIONS) {
+        request.callback(null);
+        return;
+      }
+      this.pending.push(request);
+      return;
+    }
+    this.openNow(request);
+  }
+
+  /**
+   * Resolve every still-queued request with `null`. Called when the handler
+   * is torn down (see the exitApp wrap in handler.ts's constructor) so no
+   * queued caller is ever left permanently pending.
+   */
+  public clear(): void {
+    while (this.pending.length > 0) {
+      const next = this.pending.shift();
+      next?.callback(null);
+    }
+  }
+
+  private openNow(request: PendingSelectionRequest): void {
+    const wrapped: SelectionModalCallback = (result) => {
+      request.callback(result);
+      // Only a terminal resolution (select/cancel/escape) actually closes
+      // the modal — dispatchSelectionAction's toggle/increment/decrement
+      // branch invokes the callback but leaves the modal open for further
+      // interaction, so only drain the queue once the modal has gone
+      // inactive, never on every callback invocation.
+      if (!this.host.selectionModal.active) {
+        queueMicrotask(() => this.drain());
+      }
+    };
+    this.host.modalOpened('selection');
+    this.host.selectionModal.open(request.title, request.items, request.opts);
+    this.host.setSelectionCallback(wrapped);
+    this.host.syncFeedSelectionCallback(wrapped);
+    this.host.requestRender();
+  }
+
+  private drain(): void {
+    // Something else already opened a modal in the meantime (e.g. a
+    // synchronously chained openSelection call from inside the resolving
+    // callback) — leave the queue alone; that modal's own resolution will
+    // drain it in turn.
+    if (this.host.selectionModal.active) return;
+    const next = this.pending.shift();
+    if (!next) return;
+    this.openNow(next);
+  }
+}
+
+/** InputHandler's actual field/method shape — satisfies this structurally, no import needed. */
+export interface SelectionQueueOwner {
+  readonly selectionModal: Pick<SelectionModal, 'active' | 'open'>;
+  selectionCallback: SelectionModalCallback | null;
+  syncFeedSelectionCallback: ((callback: SelectionModalCallback | null) => void) | null;
+  modalOpened(name: string): void;
+  requestRender(): void;
+  exitApp: () => void;
+}
+
+/**
+ * Builds the queue for one InputHandler and wires teardown: wraps
+ * `owner.exitApp` (the one path guaranteed to run when the handler is torn
+ * down) so every still-queued selection request resolves with `null`
+ * instead of being left pending. Keeps this bookkeeping out of handler.ts,
+ * which only needs `this.selectionQueue = attachSelectionModalQueue(this);`.
+ */
+export function attachSelectionModalQueue(owner: SelectionQueueOwner): SelectionModalQueue {
+  const queue = new SelectionModalQueue({
+    selectionModal: owner.selectionModal,
+    setSelectionCallback: (callback) => { owner.selectionCallback = callback; },
+    syncFeedSelectionCallback: (callback) => { owner.syncFeedSelectionCallback?.(callback); },
+    modalOpened: (name) => owner.modalOpened(name),
+    requestRender: () => owner.requestRender(),
+  });
+  const suppliedExitApp = owner.exitApp;
+  owner.exitApp = () => {
+    queue.clear();
+    suppliedExitApp();
+  };
+  return queue;
+}

package/src/main.ts

@@ -37,13 +37,16 @@ import { selfUpdateAtLaunch } from './cli/launch-auto-update.ts';
 import { buildSharedOrchestratorCoreServices, refreshMemoryRecallSnapshot } from './runtime/orchestrator-core-services.ts';
 import { createSessionContinuityHintsBuilder } from './runtime/session-continuity-hints.ts';
 import { resolveWebSurfaceUrl } from '@pellux/goodvibes-sdk/platform/runtime/feature-announcements';
-import { readLastSessionPointer, writeRecoveryFile } from '@/runtime/index.ts';
+import { readLastSessionPointer } from '@/runtime/index.ts';
+import { startRecoveryAutosave } from './runtime/recovery-autosave.ts';
+import { scheduleRecoveryOffer } from './runtime/recovery-prompt.ts';
+import { buildRecoveryOfferWiring } from './runtime/recovery-offer-wiring.ts';
 import { handleBlockingShellInput, type PendingPermissionState } from './shell/blocking-input.ts';
 import { handleErrorAffordanceKey } from './shell/recovery-input-helpers.ts';
+import { createRetryAffordanceState, disarmRetryAffordance, retryAffordanceHint, wireRetryAffordanceOnError } from './shell/retry-affordance.ts';
 import { wireShellUiOpeners } from './shell/ui-openers.ts';
 import { deriveComposerState } from './core/composer-state.ts';
 import { resolveFoldedBookmarkLine } from './core/bookmark-navigation.ts';
-import { buildPersistedSessionContext, getReturnContextMode, maybeAssistReturnContextSummary } from '@/runtime/index.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { prepareShellCliRuntime } from './cli/entrypoint.ts';
 import { applyInitialTuiCliState, reportFatalStartupError } from './cli/tui-startup.ts';
@@ -60,7 +63,7 @@ import { footerFleetCost } from './panels/fleet-read-model.ts';
 import { formatUserFacingErrorLine } from './core/format-user-error.ts';
 import { wireStreamEventMetrics, createStreamMetrics, type StreamMetrics, type WireStreamEventMetricsResult } from './core/stream-event-wiring.ts';
 import { wireTurnEventHandlers } from './core/turn-event-wiring.ts';
-import { buildContextStatusHint } from './renderer/context-status-hint.ts';
+import { resolveContextStatusHint } from './renderer/context-status-hint.ts';
 import { isEffectiveDangerMode } from './config/index.ts';
 import { createScriptableStatusline } from './core/scriptable-statusline.ts';
 import { applyComposerCapture } from './input/composer-capture.ts';
@@ -77,6 +80,7 @@ import { setPanelFrameRequester } from './panels/base-panel.ts';
 
 import { ALT_SCREEN_ENTER, ALT_SCREEN_EXIT, MOUSE_ENABLE, MOUSE_DISABLE, CURSOR_HIDE, CURSOR_SHOW, CLEAR_SCREEN, KEYBOARD_EXT_ENABLE, KEYBOARD_EXT_DISABLE, PASTE_ENABLE, PASTE_DISABLE, FOCUS_ENABLE, FOCUS_DISABLE } from './renderer/terminal-escapes.ts';
 import { installBackgroundThemeProbe } from './renderer/terminal-bg-probe.ts';
+import { VERSION } from './version.ts';
 
 async function main() {
   const stdout = process.stdout;
@@ -86,6 +90,12 @@ async function main() {
     homeDirectory: homedir(),
   }, 'goodvibes');
 
+  // Between binary start and the first frame, boot used to be silent (config
+  // load, trust manager, memory init, hooks). One honest pre-alt-screen line,
+  // placed after the help/version/completion early-exits above so those stay
+  // byte-clean.
+  stdout.write(`goodvibes v${VERSION} starting…\n`);
+
   // Launch-time self-update, before any bootstrap or terminal mode change; on
   // an installed update this restarts onto the swapped binary and never returns.
   const launchUpdateLines = await selfUpdateAtLaunch({ configManager, stdout });
@@ -135,8 +145,11 @@ async function main() {
   applyConfiguredHitlMode(configManager, modeManager);
   applyTuiRuntimeConfigDefaults(configManager);
 
-  // Re-surface pre-TUI launch-update lines in-session (the alt screen wipes stdout).
-  for (const line of launchUpdateLines) systemMessageRouter.high(`[Update] ${line}`);
+  // Re-surface pre-TUI launch-update lines in-session (the alt screen wipes
+  // stdout). Launch-time update mechanics are routine, not urgent — low
+  // priority, not high (a skipped/deferred check is not the kind of thing
+  // that should compete with real session alerts for attention).
+  for (const line of launchUpdateLines) systemMessageRouter.low(`[Update] ${line}`);
 
   const panelManager = ctx.services.panelManager;
   const buildSessionContinuityHints = createSessionContinuityHintsBuilder({ readModels: uiServices.readModels, panelManager });
@@ -324,6 +337,9 @@ async function main() {
   commandContext.submitInput = submitInput;
   commandContext.submitSpokenInput = (text, content) => submitInput(text, content, { spokenOutput: true });
   commandContext.stopSpokenOutput = () => spokenTurns.stop(); commandContext.pasteFromClipboard = () => input.handlePaste();
+  // Read-only view of pending [TEXT: pN, M lines] fold markers, so /pastes
+  // can preview a folded paste's actual content before the user submits it.
+  commandContext.getPendingPastes = () => input.pasteRegistry;
   commandContext.executeCommand = (name, args) => commandRegistry.execute(name, args, commandContext);
   // Late-patched: bootstrap.ts populates uiServices.platform.externalServices AFTER commandContext is built.
   commandContext.platform.externalServices = uiServices.platform.externalServices;
@@ -423,7 +439,7 @@ async function main() {
     model: runtime.model,
     provider: runtime.provider,
     toolCount,
-    lastSessionId: readLastSessionPointer({ workingDirectory: workingDir, homeDirectory, surfaceRoot: 'tui' }) ?? undefined,
+    lastSessionId: readLastSessionPointer({ surface: ctx.services.surface }) ?? undefined,
   };
 
   const renderNow = () => {
@@ -457,16 +473,10 @@ async function main() {
       hasAttachments: input.getImageAttachments().size > 0,
       turnState: sessionSnapshot.turnState,
     });
-    const maintenanceStatus = evaluateSessionMaintenance({
-      configManager,
+    const contextStatusHint = resolveContextStatusHint({
+      evaluate: (args) => evaluateSessionMaintenance({ configManager, ...args, sessionMemoryCount: ctx.services.sessionMemoryStore.list().length }),
       currentTokens: orchestrator.lastInputTokens,
       contextWindow,
-      sessionMemoryCount: ctx.services.sessionMemoryStore.list().length,
-    });
-    const contextStatusHint = buildContextStatusHint({
-      level: maintenanceStatus.level,
-      autoCompactEnabled: maintenanceStatus.autoCompactEnabled,
-      usagePct: maintenanceStatus.usagePct,
     });
     const footerLines = buildShellFooter({
       width,
@@ -486,6 +496,7 @@ async function main() {
       provider: runtime.provider,
       contextWindow,
       contextStatusHint,
+      retryHint: retryAffordanceHint(retryAffordance),
       scriptableStatusLine: scriptableStatusline.current(),
       // Compact footer posture on short terminals so the shell stays usable.
       compact: height < 30,
@@ -680,9 +691,7 @@ async function main() {
     providerRegistry,
     systemMessageRouter,
     hookDispatcher,
-    workingDir,
-    homeDirectory,
-    sessionManager: ctx.services.sessionManager,
+    surface: ctx.services.surface,
     gitStatusProvider,
     lastGitInfoRef,
     buildSessionContinuityHints,
@@ -696,7 +705,10 @@ async function main() {
   let retryCtx: { count: number; text: string; content?: ContentPart[]; opts?: Parameters<typeof orchestrator.handleUserInput>[2] } | null = null;
   // One-key retry affordance, active right after a user-visible TURN_ERROR: 'r' re-submits on the
   // current provider, 'm' opens the model picker, any other character clears it and routes normally.
-  let errorAffordanceActive = false;
+  // Surfaced as a transient FOOTER hint (see retryAffordanceHint below), not a transcript message.
+  // Time-bounded: onExpire repaints once the 60s disarm timer fires, so a stray keypress hours
+  // later can never trigger a real retry — see retry-affordance.ts.
+  const retryAffordance = createRetryAffordanceState({ onExpire: render });
   const retryTurn = (): void => {
     if (!retryCtx) return;
     const { count, text, content: rContent, opts: rOpts } = retryCtx;
@@ -712,13 +724,7 @@ async function main() {
   });
   unsubs.push(...streamResult.unsubs);
   // Activate one-key retry affordance when a user-visible error surfaces.
-  streamResult.onErrorSurfaced((exhausted) => {
-    if (retryCtx) {
-      errorAffordanceActive = true;
-      systemMessageRouter.low(exhausted ? '[Retry] r retry same provider · m switch model' : '[Retry] r retry · m switch model');
-      render();
-    }
-  });
+  wireRetryAffordanceOnError(streamResult.onErrorSurfaced, retryAffordance, () => retryCtx !== null, render);
 
   // Register terminal-restoring crash/termination handlers BEFORE entering raw mode so a throw
   // during setup or the initial render still restores the terminal; 'exit' is the final safety net.
@@ -736,7 +742,8 @@ async function main() {
   // OSC 11 probe and repaints once if light wins. filterInput strips the reply from stdin.
   const themeProbe = installBackgroundThemeProbe({ configManager, isTTY: Boolean(stdout.isTTY), env: process.env, writeQuery: (b) => allowTerminalWrite(() => stdout.write(b)), requestRepaint: () => { compositor.resetDiff(); render(); } });
 
-  applyInitialTuiCliState({ cli, input, commandRegistry, commandContext, shellPaths: ctx.services.shellPaths, render });
+  // continueRecovery lets --continue/bare --resume check the target session for a live crash snapshot newer than its store before resuming (see tui-startup.ts).
+  applyInitialTuiCliState({ cli, input, commandRegistry, commandContext, shellPaths: ctx.services.shellPaths, surface: ctx.services.surface, render, continueRecovery: { sessionManager: ctx.services.sessionManager, runtime, conversation, writeLastSessionPointer, receipt: (line) => systemMessageRouter.high(line) } });
 
   stdin.on('data', (raw: string) => {
     const data = themeProbe.filterInput(raw); if (data.length === 0) return;
@@ -749,9 +756,10 @@ async function main() {
       return;
     }
     // One-key retry affordance: armed after a user-visible TURN_ERROR; any key other than r/m dismisses it and routes normally.
-    if (errorAffordanceActive) {
-      errorAffordanceActive = false;
+    if (retryAffordance.armed) {
+      disarmRetryAffordance(retryAffordance);
       if (handleErrorAffordanceKey(data, { retryArmed: retryCtx !== null, retry: retryTurn, openModelPicker: () => commandContext.openModelPicker?.(), render })) return;
+      render(); // disarm must repaint immediately so the footer hint clears even when the key fell through
     }
     // One-key jump to a spawned CI fix-session: 'j' attaches, any other key dismisses and routes normally.
     if (fixSessionAttachArmed !== null) {
@@ -768,28 +776,24 @@ async function main() {
 
   // State restores happen ONLY when the user explicitly asks — a CLI flag
   // (--continue/--resume/--fork), a slash command (/session resume,
-  // /checkpoints, /rewind), or the boot resume notice's advertised command.
-  // There is deliberately no unconditional auto-restore here: a bare launch
-  // never loads a saved conversation on its own (owner ruling). Any live
-  // recovery snapshot is surfaced (never applied) by the boot resume
-  // notice — see announceResumeState in runtime/resume-notice.ts.
+  // /checkpoints, /rewind), or the startup recovery offer's modal. There is
+  // deliberately no unconditional auto-restore here: a bare launch never
+  // loads a saved conversation on its own (owner ruling).
 
   // Initial render
   conversation.rebuildHistory();
   render();
 
-  // --- Auto-save to recovery file every 60s ---
-  recoveryInterval = setInterval(() => {
-    const snapshot = conversation.toJSON() as { messages: Array<import('./core/conversation.ts').ConversationMessageSnapshot> };
-    const persisted = buildPersistedSessionContext(snapshot.messages, conversation.getTitleSource(), buildSessionContinuityHints());
-    writeRecoveryFile(
-      { ...snapshot, ...persisted },
-      runtime.sessionId,
-      conversation.title ?? '',
-      { workingDirectory: workingDir, homeDirectory },
-    );
-  }, 60_000);
+  // Crash-recovery snapshot: asked, never assumed. Scheduled after the first
+  // frame so the question is drawn rather than posed at a blank terminal.
+  scheduleRecoveryOffer(buildRecoveryOfferWiring({
+    surface: ctx.services.surface, sessionManager: ctx.services.sessionManager, runtime, conversation, commandContext,
+    writeLastSessionPointer, receipt: (line) => systemMessageRouter.high(line), render,
+  }));
 
+  // Auto-save to recovery file every 60s + multi-instance liveness-marker
+  // refresh — see runtime/recovery-autosave.ts.
+  recoveryInterval = startRecoveryAutosave({ conversation, runtime, surface: ctx.services.surface, buildSessionContinuityHints });
 }
 
 main().catch(reportFatalStartupError);

package/src/panels/builtin/operations.ts

@@ -9,6 +9,7 @@ import { LocalAuthPanel } from '../local-auth-panel.ts';
 import { NotificationsPanel } from '../notifications-panel.ts';
 import type { ResolvedBuiltinPanelDeps } from './shared.ts';
 import { requireUiServices } from './shared.ts';
+import { GOODVIBES_TUI_SURFACE_ROOT } from '../../config/surface.ts';
 
 // the former single 'monitoring' category (33 panels pre-merge) is
 // split into five operator domains, applied per-registration below. Kept in
@@ -113,7 +114,7 @@ export function registerOperationsPanels(manager: PanelManager, deps: ResolvedBu
       // (AgentManager's bounded retention ring), empty once evicted (the
       // panel degrades to the on-disk ledger fallback in that case).
       getConversationSnapshot: (agentId: string) => ui.agents.agentManager.getConversationSnapshot(agentId),
-      resolveSessionLogPath: (agentId: string) => ui.environment.shellPaths.resolveProjectPath('tui', 'sessions', `${agentId}.jsonl`),
+      resolveSessionLogPath: (agentId: string) => ui.environment.shellPaths.resolveProjectPath(GOODVIBES_TUI_SURFACE_ROOT, 'sessions', `${agentId}.jsonl`),
       // Queue a message for a live in-process agent/wrfc-subtask member.
       steer: (id: string, text: string) => fleetReadModel.steer(id, text),
     }, deps.configManager, fleetActs, fleetSpawn),

package/src/panels/provider-health-domains.ts

@@ -181,14 +181,14 @@ export function buildProviderHealthDomainSummaries(
     summary: continuity.recoveryFilePresent
       ? `recovery file present for ${continuity.sessionId || '(unknown session)'}`
       : continuity.lastSessionPointer ? `last session pointer ${continuity.lastSessionPointer}` : 'no last-session pointer',
-    next: continuity.recoveryFilePresent ? '/session resume <id>' : '/session list',
+    next: continuity.recoveryFilePresent ? '/resume <id>' : '/session list',
     details: [
       continuity.returnContext ? `last activity: ${continuity.returnContext.activityLabel}` : '',
       continuity.returnContext ? `resume posture: ${continuity.returnContext.statusLabel}` : '',
       !continuity.lastSessionPointer ? 'no persisted last-session pointer recorded' : '',
     ].filter(Boolean),
     nextSteps: continuity.recoveryFilePresent
-      ? ['/session list', '/session resume <id>', '/health continuity']
+      ? ['/session list', '/resume <id>', '/health continuity']
       : ['/session list'],
   });
 

package/src/renderer/block-actions-overlay.ts

@@ -0,0 +1,59 @@
+/**
+ * renderBlockActionsMenu — renders the BlockActionsMenu (src/renderer/block-actions.ts)
+ * as a docked overlay, so opening it via Enter-on-an-empty-composer actually
+ * shows something. Follows the established docked-overlay pattern (see
+ * selection-modal-overlay.ts / bookmark-modal.ts): ModalFactory sizes the box
+ * to its content, and every text section wraps rather than clips, so the
+ * block summary and action list are always shown in full.
+ */
+
+import { type Line } from '../types/grid.ts';
+import { ModalFactory, type ModalSection } from './modal-factory.ts';
+import type { BlockActionsMenu } from './block-actions.ts';
+import { describeBlockForReceipt } from '../input/handler-content-actions.ts';
+import { getOverlaySurfaceMetrics } from './overlay-viewport.ts';
+import { formatHints } from './hint-grammar.ts';
+
+export function renderBlockActionsMenu(
+  menu: BlockActionsMenu,
+  width: number,
+  viewportHeight = 24,
+): Line[] {
+  if (!menu.active || !menu.block) return [];
+
+  const summary = describeBlockForReceipt(menu.block);
+  const metrics = getOverlaySurfaceMetrics(width, viewportHeight, {
+    margin: 4,
+    maxWidth: 64,
+    chromeRows: 5,
+    minContentRows: 3,
+    maxContentRows: Math.max(6, viewportHeight - 8),
+  });
+
+  const sections: ModalSection[] = [
+    { type: 'text', content: `Target: ${summary}`, style: { dim: true } },
+    { type: 'separator' },
+    {
+      type: 'list',
+      items: menu.actions.map((action, i) => ({
+        label: `[${action.key}] ${action.label}`,
+        selected: i === menu.selectedIndex,
+      })),
+    },
+  ];
+
+  return ModalFactory.createModal(
+    {
+      title: 'Block Actions',
+      width: metrics.boxWidth,
+      margin: metrics.margin,
+      sections,
+      hints: [formatHints([
+        { key: 'Up/Down', verb: 'Navigate' },
+        { key: 'Enter', verb: 'Select' },
+        { key: 'Esc', verb: 'Close' },
+      ])],
+    },
+    width,
+  );
+}

package/src/renderer/block-actions.ts

@@ -1,6 +1,6 @@
 import type { BlockMeta } from '../core/conversation';
 
-export type BlockActionId = 'copy' | 'bookmark' | 'toggle' | 'apply' | 'rerun';
+export type BlockActionId = 'copy' | 'bookmark' | 'toggle' | 'apply';
 
 export interface BlockAction {
   id: BlockActionId;
@@ -13,7 +13,6 @@ const ALL_ACTIONS: BlockAction[] = [
   { id: 'bookmark', label: 'Bookmark',       key: 'b' },
   { id: 'toggle',   label: 'Collapse/Expand',key: 'Tab' },
   { id: 'apply',    label: 'Apply diff',     key: 'a' },
-  { id: 'rerun',    label: 'Re-run tool',    key: 'r' },
 ];
 
 /**
@@ -37,7 +36,6 @@ export class BlockActionsMenu {
     this.block = block;
     this.actions = ALL_ACTIONS.filter(a => {
       if (a.id === 'apply') return block.type === 'diff';
-      if (a.id === 'rerun') return block.type === 'tool';
       return true;
     });
     this.selectedIndex = 0;

package/src/renderer/context-status-hint.ts

@@ -12,34 +12,77 @@
  *  - compacting      → shows in-progress text so the user knows something is running
  *  - watch           → no hint (not yet actionable)
  *  - stable/unknown  → no hint
+ *
+ * Evidence policy (why the guards below exist)
+ * ────────────────────────────────────────────
+ * A fresh boot printed "Context high (0% used) — auto-compact will run before
+ * the next turn." before a single token had been counted. The evaluator was
+ * not at fault: `evaluateSessionMaintenance` reaches 'suggest-compact' when
+ * `remainingTokens <= 15_000`, and at boot the resolved window is still the
+ * SDK's DEFAULT_CONTEXT_WINDOW fallback (8,192 — the "8.2k" the footer meter
+ * shows before the real window arrives), so 8,192 free tokens tripped that
+ * rule instantly. Arithmetically consistent; factually false. No context had
+ * been consumed and no auto-compact was imminent.
+ *
+ * So a pressure claim here has to be backed by evidence, not merely by a
+ * level:
+ *   1. Usage has actually been measured. At zero tokens consumed there is no
+ *      pressure to report, whatever the window says.
+ *   2. The window is one the provider vouched for, not the fallback constant.
+ *      A model whose real window happens to equal the fallback is
+ *      indistinguishable from "not resolved yet", and in that ambiguity
+ *      staying quiet is the honest choice — the Tokens panel and /context
+ *      still show the real numbers either way.
+ * Neither guard touches 'compacting', which reports work that is provably
+ * running rather than a prediction about headroom.
  */
 
+import { DEFAULT_CONTEXT_WINDOW } from '@pellux/goodvibes-sdk/platform/providers';
 import type { PanelSessionMaintenanceLevel } from '../panels/session-maintenance.ts';
 
-export interface ContextStatusHintOptions {
+interface ContextStatusHintOptions {
   /** Maintenance level from evaluateSessionMaintenance. */
   readonly level: PanelSessionMaintenanceLevel;
   /** Whether auto-compaction is active (threshold > 0 in config). */
   readonly autoCompactEnabled: boolean;
   /** Current usage percent 0–100. */
   readonly usagePct: number;
+  /** Tokens actually counted so far this session (orchestrator.lastInputTokens). */
+  readonly currentTokens: number;
+  /** The resolved context window the usage percent was computed against. */
+  readonly contextWindow: number;
+}
+
+/**
+ * Whether the numbers backing a pressure claim are real yet: usage has been
+ * counted, and the window is not the provider fallback the app boots with.
+ */
+function hasRealContextNumbers(
+  options: Pick<ContextStatusHintOptions, 'currentTokens' | 'contextWindow' | 'usagePct'>,
+): boolean {
+  if (options.currentTokens <= 0 || options.usagePct <= 0) return false;
+  if (options.contextWindow <= 0 || options.contextWindow === DEFAULT_CONTEXT_WINDOW) return false;
+  return true;
 }
 
 /**
  * Build the passive status-line hint text for context pressure.
  *
- * Returns null when no hint is warranted (stable / watch / unknown).
- * The caller renders this as a dim informational line — no prompts, no
- * blocking, no confirmation required.
+ * Returns null when no hint is warranted (stable / watch / unknown), and also
+ * when a pressure level is not yet backed by real numbers — see the evidence
+ * policy above. The caller renders this as a dim informational line — no
+ * prompts, no blocking, no confirmation required.
  */
-export function buildContextStatusHint(options: ContextStatusHintOptions): string | null {
+function buildContextStatusHint(options: ContextStatusHintOptions): string | null {
   const { level, autoCompactEnabled, usagePct } = options;
 
   switch (level) {
     case 'needs-repair':
+      if (!hasRealContextNumbers(options)) return null;
       return `  Context pressure critical (${usagePct}% used) — compaction needs attention. Run /compact or /health review.`;
 
     case 'suggest-compact':
+      if (!hasRealContextNumbers(options)) return null;
       if (autoCompactEnabled) {
         return `  Context high (${usagePct}% used) — auto-compact will run before the next turn.`;
       }
@@ -52,3 +95,28 @@ export function buildContextStatusHint(options: ContextStatusHintOptions): strin
       return null;
   }
 }
+
+/**
+ * Evaluate session maintenance and turn it into the footer hint in one call.
+ * The ONE public seam of this module, deliberately: the guards above need the
+ * exact `currentTokens` / `contextWindow` the evaluator was handed, and a
+ * caller free to pass different values to each half is how they drift apart.
+ */
+export function resolveContextStatusHint(input: {
+  readonly evaluate: (args: { readonly currentTokens: number; readonly contextWindow: number }) => {
+    readonly level: PanelSessionMaintenanceLevel;
+    readonly autoCompactEnabled: boolean;
+    readonly usagePct: number;
+  };
+  readonly currentTokens: number;
+  readonly contextWindow: number;
+}): string | null {
+  const status = input.evaluate({ currentTokens: input.currentTokens, contextWindow: input.contextWindow });
+  return buildContextStatusHint({
+    level: status.level,
+    autoCompactEnabled: status.autoCompactEnabled,
+    usagePct: status.usagePct,
+    currentTokens: input.currentTokens,
+    contextWindow: input.contextWindow,
+  });
+}

package/src/renderer/conversation-layout.ts

@@ -38,6 +38,22 @@ export function buildConversationViewport(
   };
 }
 
+/**
+ * Absolute history-line index of the bottom-most visible row of the
+ * conversation viewport. The buffer bottom-aligns content shorter than the
+ * viewport (InfiniteBuffer.getSnapshot pads with blank lines at the TOP, not
+ * the bottom — see history.ts), so the naive `scrollTop + viewportHeight - 1`
+ * overshoots past the real last line whenever the whole transcript already
+ * fits on screen. Clamping to `lineCount - 1` handles both cases with one
+ * formula: when scrollLocked at the true bottom (the common case), this is
+ * exactly the last rendered content line — the block the user is actually
+ * looking at, not whatever sits at the TOP of the viewport (scrollTop alone).
+ */
+export function getViewportBottomLine(scrollTop: number, viewportHeight: number, lineCount: number): number {
+  if (lineCount <= 0) return 0;
+  return Math.max(0, Math.min(scrollTop + viewportHeight - 1, lineCount - 1));
+}
+
 export function overlayViewportBottom(
   viewport: readonly Line[],
   overlay: readonly Line[],

package/src/renderer/conversation-overlays.ts

@@ -16,6 +16,7 @@ import { renderSessionPickerModal } from './session-picker-modal.ts';
 import { renderProfilePickerModal } from './profile-picker-modal.ts';
 import { renderBookmarkModal } from './bookmark-modal.ts';
 import { renderHelpOverlay, renderShortcutsOverlay } from './help-overlay.ts';
+import { renderBlockActionsMenu } from './block-actions-overlay.ts';
 import { renderAutocompleteOverlay } from './autocomplete-overlay.ts';
 import { renderOnboardingWizard } from './onboarding/onboarding-wizard.ts';
 import { overlayViewportBottom, replaceViewportWithOverlay } from './conversation-layout.ts';
@@ -118,6 +119,11 @@ export function applyConversationOverlays(
     next = overlayViewportBottom(next, lines, conversationWidth, viewportHeight, bottomDockInset);
   }
 
+  if (!fullscreenClaimed && input.blockActionsMenu.active) {
+    const lines = renderBlockActionsMenu(input.blockActionsMenu, conversationWidth, viewportHeight);
+    next = overlayViewportBottom(next, lines, conversationWidth, viewportHeight, bottomDockInset);
+  }
+
   if (input.helpOverlayActive) {
     const lines = renderHelpOverlay(conversationWidth, keybindingsManager, commandRegistry.getAll(), input.helpScrollOffset, viewportHeight);
     next = replaceViewportWithOverlay(lines, conversationWidth, viewportHeight);