botholomew 0.15.0 → 0.15.2

package/README.md

@@ -76,6 +76,8 @@ Requires [Bun](https://bun.sh) 1.1+.
 bun install -g botholomew
 ```
 
+The CLI installs as both `botholomew` and `bothy` — the same binary, two names.
+
 Or run the dev build from a checkout:
 
 ```bash

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "botholomew",
-  "version": "0.15.0",
+  "version": "0.15.2",
   "description": "An autonomous AI agent for knowledge work — works your task queue while you sleep.",
   "type": "module",
   "bin": {
-    "botholomew": "./src/cli.ts"
+    "botholomew": "./src/cli.ts",
+    "bothy": "./src/cli.ts"
   },
   "files": [
     "src",

package/src/chat/agent.ts

@@ -27,6 +27,11 @@ import {
   STYLE_RULES,
 } from "../worker/prompt.ts";
 import type { ChatSession } from "./session.ts";
+import {
+  type ContextUsage,
+  estimateTokens,
+  partitionMessages,
+} from "./usage.ts";
 
 registerAllTools();
 
@@ -156,6 +161,12 @@ export interface ChatTurnCallbacks {
    *  the entire tool loop to finish. Each returned message is logged + pushed
    *  to `messages` before the next `messages.stream(...)` call. */
   takeInjections?: () => string[];
+  /** Fired after each finalized assistant turn with the prompt size the
+   *  server billed for (sum of fresh, cache-read, and cache-creation input
+   *  tokens), the model's max input tokens, and a local estimate of where
+   *  the bytes went. The TUI uses this to render the tab-bar indicator and
+   *  the breakdown shown on the Help tab. */
+  onUsage?: (info: ContextUsage) => void;
 }
 
 /**
@@ -243,6 +254,14 @@ export async function runChatTurn(input: {
       config,
       hasMcpTools: mcpxClient != null,
     });
+    // Re-derive the persistent-context portion (prompts files) so the Help
+    // tab can show how much of the system prompt is user-authored prompts vs
+    // built-in instructions. Cheap — same FS read just hit by
+    // buildChatSystemPrompt is still hot.
+    const persistentContext = await loadPersistentContext(
+      projectDir,
+      keywordSource ? extractKeywords(keywordSource) : null,
+    );
 
     fitToContextWindow(messages, systemPrompt, maxInputTokens);
     const stream = client.messages.stream({
@@ -312,6 +331,27 @@ export async function runChatTurn(input: {
     const durationMs = Date.now() - startTime;
     const tokenCount =
       response.usage.input_tokens + response.usage.output_tokens;
+    const promptTokens =
+      response.usage.input_tokens +
+      (response.usage.cache_read_input_tokens ?? 0) +
+      (response.usage.cache_creation_input_tokens ?? 0);
+    if (callbacks.onUsage) {
+      const { textChars, toolIoChars } = partitionMessages(messages);
+      const promptsChars = persistentContext.length;
+      const instructionsChars = Math.max(0, systemPrompt.length - promptsChars);
+      const toolsChars = JSON.stringify(chatTools).length;
+      callbacks.onUsage({
+        used: promptTokens,
+        max: maxInputTokens,
+        breakdown: {
+          prompts: estimateTokens(promptsChars),
+          instructions: estimateTokens(instructionsChars),
+          tools: estimateTokens(toolsChars),
+          messages: estimateTokens(textChars),
+          toolIo: estimateTokens(toolIoChars),
+        },
+      });
+    }
 
     // Log assistant text
     if (assistantText) {

package/src/chat/usage.ts

@@ -0,0 +1,69 @@
+import type { MessageParam } from "@anthropic-ai/sdk/resources/messages";
+
+/** Rough Anthropic-style estimate: ~4 characters per token. */
+const CHARS_PER_TOKEN = 4;
+
+/**
+ * Estimate of where the prompt's bytes went on the most recent assistant
+ * turn. The five categories sum to roughly the server-billed input-tokens
+ * total — they're estimates derived from string length / 4, so they don't
+ * line up exactly with the API's count.
+ */
+export interface ContextBreakdown {
+  /** Persistent context files from `prompts/` (soul, beliefs, goals, capabilities, contextual). */
+  prompts: number;
+  /** Chat instructions block + MCP guidance + style rules + meta header. */
+  instructions: number;
+  /** Anthropic tool schemas (chat-allowed tools + MCP meta-tools). */
+  tools: number;
+  /** User and assistant text in the conversation history. */
+  messages: number;
+  /** `tool_use` and `tool_result` blocks accumulated during the conversation. */
+  toolIo: number;
+}
+
+export interface ContextUsage {
+  /** Prompt tokens billed by the server (input + cache_read + cache_creation). */
+  used: number;
+  /** Model's max input tokens (from the Anthropic Models API). */
+  max: number;
+  /** Local estimates per section. */
+  breakdown: ContextBreakdown;
+}
+
+export function estimateTokens(chars: number): number {
+  return Math.ceil(chars / CHARS_PER_TOKEN);
+}
+
+/** Walk a `messages` array and split chars into plain text vs. tool I/O. */
+export function partitionMessages(messages: MessageParam[]): {
+  textChars: number;
+  toolIoChars: number;
+} {
+  let textChars = 0;
+  let toolIoChars = 0;
+  for (const msg of messages) {
+    if (typeof msg.content === "string") {
+      textChars += msg.content.length;
+      continue;
+    }
+    if (!Array.isArray(msg.content)) continue;
+    for (const block of msg.content) {
+      if (!("type" in block)) continue;
+      if (block.type === "text") {
+        textChars += block.text.length;
+      } else if (block.type === "tool_use") {
+        toolIoChars += JSON.stringify(block).length;
+      } else if (block.type === "tool_result") {
+        toolIoChars +=
+          typeof block.content === "string"
+            ? block.content.length
+            : JSON.stringify(block.content).length;
+      } else {
+        // image, document, etc. — count under text for now.
+        textChars += JSON.stringify(block).length;
+      }
+    }
+  }
+  return { textChars, toolIoChars };
+}

package/src/commands/chat.ts

@@ -1,4 +1,5 @@
 import type { Command } from "commander";
+import { loadConfig } from "../config/loader.ts";
 
 export function registerChatCommand(program: Command) {
   program
@@ -7,7 +8,7 @@ export function registerChatCommand(program: Command) {
       "Open the interactive chat TUI\n\n" +
         "  Tab navigation (Ctrl+<letter> from any tab):\n" +
         "    Ctrl+a  Chat        Ctrl+t  Tasks       Ctrl+w  Workers\n" +
-        "    Ctrl+o  Tools       Ctrl+r  Threads     ?       Help (non-chat)\n" +
+        "    Ctrl+o  Tools       Ctrl+r  Threads     Ctrl+g  Help\n" +
         "    Ctrl+n  Context     Ctrl+s  Schedules   Esc     Return to Chat\n\n" +
         "  Chat input:\n" +
         "    Enter          Send message\n" +
@@ -29,6 +30,8 @@ export function registerChatCommand(program: Command) {
       const React = await import("react");
       const { App } = await import("../tui/App.tsx");
       const dir = program.opts().dir;
+      const config = await loadConfig(dir);
+      const idleTimeoutMs = config.tui_idle_timeout_seconds * 1000;
 
       // VHS/ttyd doesn't fully negotiate the Kitty Keyboard protocol, so
       // Ink's "enabled" mode drops non-text keystrokes (Tab, Escape) under
@@ -41,6 +44,7 @@ export function registerChatCommand(program: Command) {
           projectDir: dir,
           threadId: opts.threadId,
           initialPrompt: opts.prompt,
+          idleTimeoutMs,
         }),
         {
           exitOnCtrlC: false,

package/src/config/schemas.ts

@@ -14,6 +14,7 @@ export interface BotholomewConfig {
   worker_stopped_retention_seconds?: number;
   schedule_min_interval_seconds?: number;
   schedule_claim_stale_seconds?: number;
+  tui_idle_timeout_seconds?: number;
   log_level?: string;
 }
 
@@ -33,5 +34,6 @@ export const DEFAULT_CONFIG: Required<BotholomewConfig> = {
   worker_stopped_retention_seconds: 3600,
   schedule_min_interval_seconds: 60,
   schedule_claim_stale_seconds: 300,
+  tui_idle_timeout_seconds: 180,
   log_level: "",
 };

package/src/context/fetcher.ts

@@ -39,7 +39,7 @@ export interface FetchedContent {
   /**
    * MCP server that produced the content (e.g. "google-docs", "github",
    * "firecrawl"), or null when we fell back to a plain HTTP fetch. Useful
-   * for `bothy context import` to pick a default destination subdirectory.
+   * for `botholomew context import` to pick a default destination subdirectory.
    */
   source: string | null;
 }

package/src/context/store.ts

@@ -171,14 +171,17 @@ export function normalizeContextPath(path: string): string {
  * or attempts to resolve into a protected area.
  *
  * `allowSymlinks` is the opt-in for read-side callers (read, list, tree,
- * info, reindex, delete). Mutating callers (write, edit, mv, cp, mkdir)
- * leave it `false` so user-placed symlinks under `context/` cannot be
- * traversed to modify external content.
+ * info, reindex). Mutating callers (write, edit, mv, cp, mkdir) leave it
+ * `false` so user-placed symlinks under `context/` cannot be traversed to
+ * modify external content. `allowSymlinkLeaf` is the narrower opt-in for
+ * `delete`: the leaf may be a symlink (so the agent can unlink it) but
+ * parent components may not, so a delete cannot reach external content
+ * through a symlinked parent directory.
  */
 async function resolveContext(
   projectDir: string,
   path: string,
-  opts: { allowSymlinks?: boolean } = {},
+  opts: { allowSymlinks?: boolean; allowSymlinkLeaf?: boolean } = {},
 ): Promise<string> {
   const normalized = normalizeContextPath(path);
   if (PROTECTED_AREAS.has(normalized)) {
@@ -190,6 +193,7 @@ async function resolveContext(
   return resolveInRoot(projectDir, fromPosix(normalized), {
     area: CONTEXT_DIR,
     allowSymlinks: opts.allowSymlinks,
+    allowSymlinkLeaf: opts.allowSymlinkLeaf,
   });
 }
 
@@ -343,7 +347,9 @@ export async function deleteContextPath(
   path: string,
   opts: { recursive?: boolean } = {},
 ): Promise<{ removed: number; was_directory: boolean; was_symlink: boolean }> {
-  const abs = await resolveContext(projectDir, path, { allowSymlinks: true });
+  const abs = await resolveContext(projectDir, path, {
+    allowSymlinkLeaf: true,
+  });
   const normalized = normalizeContextPath(path);
   if (normalized === "") {
     throw new PathEscapeError("refusing to delete the context root", path);

package/src/db/embeddings.ts

@@ -94,6 +94,23 @@ export async function deleteIndexedPath(
   return result.changes;
 }
 
+/**
+ * Remove every indexed entry whose path equals `prefix` or lives beneath
+ * `prefix/`. Used when a folder is deleted from `context/` and we need to
+ * drop all child entries in one shot.
+ */
+export async function deleteIndexedPathsUnder(
+  conn: DbConnection,
+  prefix: string,
+): Promise<number> {
+  const result = await conn.queryRun(
+    "DELETE FROM context_index WHERE path = ?1 OR path LIKE ?2",
+    prefix,
+    `${prefix}/%`,
+  );
+  return result.changes;
+}
+
 export interface IndexedPathSummary {
   path: string;
   content_hash: string;

package/src/fs/sandbox.ts

@@ -36,6 +36,15 @@ export interface SandboxOptions {
    * content.
    */
   allowSymlinks?: boolean;
+  /**
+   * Permit a symlink only as the final path component. Parent components
+   * are still lstat-walked and rejected if any is a symlink. This is the
+   * mode for mutating callers that intentionally operate on a symlink
+   * leaf (e.g., `deleteContextPath` unlinking a user-placed symlink) but
+   * must not be coaxed into reaching outside content via a symlinked
+   * parent directory.
+   */
+  allowSymlinkLeaf?: boolean;
 }
 
 let cachedCanonicalRoot: string | null = null;
@@ -97,7 +106,11 @@ export async function resolveInRoot(
   ensureContainment(resolved, boundary, opts.allowRoot ?? true, userPath);
 
   if (!opts.allowSymlinks) {
-    await assertNoSymlinkComponents(resolved, canonicalRoot);
+    await assertNoSymlinkComponents(
+      resolved,
+      canonicalRoot,
+      opts.allowSymlinkLeaf ?? false,
+    );
   }
   return resolved;
 }
@@ -122,7 +135,11 @@ export function resolveInRootSync(
   ensureContainment(resolved, boundary, opts.allowRoot ?? true, userPath);
 
   if (!opts.allowSymlinks) {
-    assertNoSymlinkComponentsSync(resolved, canonicalRoot);
+    assertNoSymlinkComponentsSync(
+      resolved,
+      canonicalRoot,
+      opts.allowSymlinkLeaf ?? false,
+    );
   }
   return resolved;
 }
@@ -181,19 +198,24 @@ function ensureContainment(
 async function assertNoSymlinkComponents(
   resolved: string,
   canonicalRoot: string,
+  allowLeaf: boolean,
 ): Promise<void> {
   // Walk from canonical root toward the leaf, lstat'ing each existing
   // component. The root itself is canonical (already realpath'd) so we skip
   // it; we only care that nothing the agent writes goes through a symlink.
+  // When `allowLeaf` is true, the final component may itself be a symlink
+  // (e.g., delete unlinking a user-placed symlink) — only parents are checked.
   const rel = resolved.slice(canonicalRoot.length);
   if (!rel || rel === sep) return;
   const parts = rel.split(sep).filter((p) => p.length > 0);
   let current = canonicalRoot;
-  for (const part of parts) {
-    current = current + sep + part;
+  for (let i = 0; i < parts.length; i++) {
+    current = current + sep + parts[i];
+    const isLeaf = i === parts.length - 1;
     try {
       const st = await lstat(current);
       if (st.isSymbolicLink()) {
+        if (isLeaf && allowLeaf) continue;
         throw new PathEscapeError(
           `path traverses a symlink: ${current}`,
           resolved,
@@ -214,16 +236,19 @@ async function assertNoSymlinkComponents(
 function assertNoSymlinkComponentsSync(
   resolved: string,
   canonicalRoot: string,
+  allowLeaf: boolean,
 ): void {
   const rel = resolved.slice(canonicalRoot.length);
   if (!rel || rel === sep) return;
   const parts = rel.split(sep).filter((p) => p.length > 0);
   let current = canonicalRoot;
-  for (const part of parts) {
-    current = current + sep + part;
+  for (let i = 0; i < parts.length; i++) {
+    current = current + sep + parts[i];
+    const isLeaf = i === parts.length - 1;
     try {
       const st = lstatSync(current);
       if (st.isSymbolicLink()) {
+        if (isLeaf && allowLeaf) continue;
         throw new PathEscapeError(
           `path traverses a symlink: ${current}`,
           resolved,

package/src/tui/App.tsx

@@ -8,6 +8,7 @@ import {
   sendMessage,
   startChatSession,
 } from "../chat/session.ts";
+import type { ContextUsage } from "../chat/usage.ts";
 import {
   BUILTIN_SLASH_COMMANDS,
   handleSlashCommand,
@@ -33,6 +34,7 @@ import { ThreadPanel } from "./components/ThreadPanel.tsx";
 import type { ToolCallData } from "./components/ToolCall.tsx";
 import { ToolPanel } from "./components/ToolPanel.tsx";
 import { WorkerPanel } from "./components/WorkerPanel.tsx";
+import { IdleProvider, useIdle } from "./idle.tsx";
 import { buildSlashCommands, getSlashMatches } from "./slashCompletion.ts";
 import { ansi } from "./theme.ts";
 
@@ -40,6 +42,7 @@ interface AppProps {
   projectDir: string;
   threadId?: string;
   initialPrompt?: string;
+  idleTimeoutMs: number;
 }
 
 let nextMsgId = 0;
@@ -49,9 +52,14 @@ function msgId(): string {
 
 // Tab routing: Ctrl+<letter> jumps to a tab. Chosen for memorability — first
 // available letter that doesn't collide with other Ctrl bindings (Ctrl+C exit,
-// Ctrl+J/K/X/E queue ops on Chat). Help is bound to `?` instead of Ctrl+H
-// because most terminals send Ctrl+H as ASCII 0x08 (backspace), which Ink
-// reports as `key.backspace=true`, not `input='h'`.
+// Ctrl+J/K/X/E queue ops on Chat).
+//
+// Help is bound to Ctrl+G rather than Ctrl+H because most terminals deliver
+// Ctrl+H as ASCII 0x08 (backspace). Bonus: macOS Terminal.app and several
+// other terminals map Ctrl+/ to BEL (0x07), the same byte as Ctrl+G — so this
+// binding also catches the Ctrl+/ keystroke on those terminals "for free".
+// We also accept "/" and "_" as fallbacks for terminals that deliver Ctrl+/
+// as 0x1F or as the literal "/" with ctrl=true (Kitty keyboard protocol).
 const TAB_BY_CTRL_KEY: Record<string, TabId> = {
   a: 1, // ch[a]t
   o: 2, // t[o]ols
@@ -60,6 +68,9 @@ const TAB_BY_CTRL_KEY: Record<string, TabId> = {
   r: 5, // th[r]eads
   s: 6, // [s]chedules
   w: 7, // [w]orkers
+  g: 8, // help (also catches Ctrl+/ on terminals that map it to BEL)
+  "/": 8, // help (Kitty keyboard protocol)
+  _: 8, // help (terminals that send Ctrl+/ as 0x1F)
 };
 
 function detectToolError(output: string | undefined): boolean {
@@ -138,10 +149,35 @@ export function App({
   projectDir,
   threadId: resumeThreadId,
   initialPrompt,
+  idleTimeoutMs,
 }: AppProps) {
+  return (
+    <IdleProvider timeoutMs={idleTimeoutMs}>
+      <AppInner
+        projectDir={projectDir}
+        threadId={resumeThreadId}
+        initialPrompt={initialPrompt}
+      />
+    </IdleProvider>
+  );
+}
+
+interface AppInnerProps {
+  projectDir: string;
+  threadId?: string;
+  initialPrompt?: string;
+}
+
+function AppInner({
+  projectDir,
+  threadId: resumeThreadId,
+  initialPrompt,
+}: AppInnerProps) {
   const { exit } = useApp();
+  const { markActivity } = useIdle();
   const [messages, setMessages] = useState<ChatMessage[]>([]);
   const [messagesEpoch, setMessagesEpoch] = useState(0);
+  const [usage, setUsage] = useState<ContextUsage | null>(null);
   const [inputValue, setInputValue] = useState("");
   const [inputHistory, setInputHistory] = useState<string[]>([]);
   const [isLoading, setIsLoading] = useState(false);
@@ -265,9 +301,14 @@ export function App({
   const slashCommandsRef = useRef<SlashCommand[]>([]);
   const inputValueRef = useRef("");
 
+  const markActivityRef = useRef(markActivity);
+  markActivityRef.current = markActivity;
+
   const stableAppHandler = useCallback(
     // biome-ignore lint/suspicious/noExplicitAny: Ink's Key type is not exported
     (input: string, key: any) => {
+      markActivityRef.current();
+
       // Ctrl+C exits
       if (input === "c" && key.ctrl) {
         exit();
@@ -293,14 +334,6 @@ export function App({
         }
       }
 
-      // `?` jumps to the Help tab from any non-chat tab (on Chat, `?` is
-      // a regular character). Acts as the Help shortcut since Ctrl+H is
-      // unusable — most terminals send it as backspace.
-      if (input === "?" && activeTabRef.current !== 1) {
-        setActiveTab(8);
-        return;
-      }
-
       const tab = activeTabRef.current;
 
       // Esc on Chat tab while a turn is in flight: steer / interrupt.
@@ -407,12 +440,15 @@ export function App({
             if (now - lastStreamFlush >= 50) {
               setStreamingText(currentText);
               lastStreamFlush = now;
+              markActivityRef.current();
             }
           },
           onToolPreparing: (id, name) => {
+            markActivityRef.current();
             setPreparingTool({ id, name });
           },
           onToolStart: (id, name, input) => {
+            markActivityRef.current();
             if (currentText) {
               finalizeSegment();
             }
@@ -428,6 +464,7 @@ export function App({
             setPreparingTool(null);
           },
           onToolEnd: (id, _name, output, isError, meta) => {
+            markActivityRef.current();
             const tc = pendingToolCalls.find((t) => t.id === id);
             if (tc) {
               tc.running = false;
@@ -439,6 +476,9 @@ export function App({
             }
             setActiveToolCalls([...pendingToolCalls]);
           },
+          onUsage: (info) => {
+            setUsage(info);
+          },
           takeInjections: () => {
             // Drain queued messages into the running turn so the agent sees
             // them on the next LLM call instead of after the whole tool loop.
@@ -535,7 +575,7 @@ export function App({
       if (trimmed === "/help") {
         const skills = sessionRef.current.skills;
         const lines: string[] = [
-          "For the full keyboard reference, switch to the Help tab (`?` from any non-chat tab) — this message lists chat commands only.",
+          "For the full keyboard reference, switch to the Help tab (`Ctrl+g`) — this message lists chat commands only.",
           "",
           "Slash commands:",
           "  /help           Show this message",
@@ -628,6 +668,7 @@ export function App({
                 setStreamingText("");
                 setActiveToolCalls([]);
                 setPreparingTool(null);
+                setUsage(null);
               } catch (err) {
                 setMessages((prev) => [
                   ...prev,
@@ -796,6 +837,7 @@ export function App({
           projectDir={projectDir}
           threadId={threadId}
           workerRunning={workerRunning}
+          usage={usage}
         />
       </Box>
 
@@ -817,7 +859,7 @@ export function App({
         header={inputBarHeader}
         slashCommands={slashCommands}
       />
-      <TabBar activeTab={activeTab} />
+      <TabBar activeTab={activeTab} usage={usage} />
     </Box>
   );
 }

package/src/tui/components/ContextPanel.tsx

@@ -3,13 +3,17 @@ import { memo, useCallback, useEffect, useMemo, useState } from "react";
 import { getDbPath } from "../../constants.ts";
 import {
   type ContextEntry,
+  deleteContextPath,
   listContextDir,
   readContextFile,
 } from "../../context/store.ts";
 import { withDb } from "../../db/connection.ts";
 import {
+  deleteIndexedPath,
+  deleteIndexedPathsUnder,
   getIndexedPath,
   type IndexedPathSummary,
+  rebuildSearchIndex,
 } from "../../db/embeddings.ts";
 import {
   detailPaneBorderProps,
@@ -18,7 +22,9 @@ import {
 } from "../listDetailKeys.ts";
 import { isMarkdownPath, renderMarkdown } from "../markdown.ts";
 import { theme } from "../theme.ts";
+import { useDeleteConfirm } from "../useDeleteConfirm.ts";
 import { useLatestRef } from "../useLatestRef.ts";
+import { DeleteArmedBanner } from "./DeleteArmedBanner.tsx";
 import { Scrollbar } from "./Scrollbar.tsx";
 
 interface ContextPanelProps {
@@ -163,8 +169,33 @@ export const ContextPanel = memo(function ContextPanel({
   const currentPathRef = useLatestRef(currentPath);
   const focusRef = useLatestRef(focus);
 
+  const deleteConfirm = useDeleteConfirm(() => {
+    const entry = selectedEntryRef.current;
+    if (!entry) return;
+    const path = entry.path;
+    const isDirectory = entry.is_directory;
+    (async () => {
+      try {
+        await deleteContextPath(projectDir, path, { recursive: isDirectory });
+        await withDb(getDbPath(projectDir), async (conn) => {
+          if (isDirectory) {
+            await deleteIndexedPathsUnder(conn, path);
+          } else {
+            await deleteIndexedPath(conn, path);
+          }
+          await rebuildSearchIndex(conn);
+        });
+      } catch {
+        // ignore — refresh will reflect any partial state
+      }
+      refresh(currentPathRef.current);
+    })();
+  });
+
   useInput(
     (input, key) => {
+      if (input !== "d") deleteConfirm.cancel();
+
       if (
         handleListDetailKey(input, key, {
           focusRef,
@@ -199,6 +230,12 @@ export const ContextPanel = memo(function ContextPanel({
         return;
       }
 
+      if (input === "d") {
+        const entry = selectedEntryRef.current;
+        if (!entry) return;
+        deleteConfirm.pressDelete(entry.path);
+        return;
+      }
       if (input === "r") {
         refresh(currentPathRef.current);
       }
@@ -322,11 +359,15 @@ export const ContextPanel = memo(function ContextPanel({
         ) : (
           <Text dimColor>(no item selected)</Text>
         )}
+        <DeleteArmedBanner
+          armed={deleteConfirm.armed}
+          label={deleteConfirm.armedLabel}
+        />
         <Box>
           <Text dimColor>
             {focus === "detail"
               ? "↑↓ scroll · ⇧↑↓ page · g/G top/bot · ← back to list"
-              : "↑↓ select · → drill in/enter detail · ← up · r refresh"}
+              : "↑↓ select · → drill in/enter detail · ← up · d delete (×2) · r refresh"}
           </Text>
         </Box>
       </Box>

package/src/tui/components/DeleteArmedBanner.tsx

@@ -0,0 +1,18 @@
+import { Box, Text } from "ink";
+import { theme } from "../theme.ts";
+
+interface DeleteArmedBannerProps {
+  armed: boolean;
+  label: string | null;
+}
+
+export function DeleteArmedBanner({ armed, label }: DeleteArmedBannerProps) {
+  if (!armed) return null;
+  return (
+    <Box>
+      <Text color={theme.error} bold>
+        ⚠ Press d again to delete {label ?? ""} (any other key cancels)
+      </Text>
+    </Box>
+  );
+}