botholomew 0.15.1 → 0.15.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botholomew",
-  "version": "0.15.1",
+  "version": "0.15.2",
   "description": "An autonomous AI agent for knowledge work — works your task queue while you sleep.",
   "type": "module",
   "bin": {

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

@@ -8,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" +

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,
@@ -51,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
@@ -62,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 {
@@ -168,6 +177,7 @@ function AppInner({
   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);
@@ -324,14 +334,6 @@ function AppInner({
         }
       }
 
-      // `?` 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.
@@ -474,6 +476,9 @@ function AppInner({
             }
             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.
@@ -570,7 +575,7 @@ function AppInner({
       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",
@@ -663,6 +668,7 @@ function AppInner({
                 setStreamingText("");
                 setActiveToolCalls([]);
                 setPreparingTool(null);
+                setUsage(null);
               } catch (err) {
                 setMessages((prev) => [
                   ...prev,
@@ -831,6 +837,7 @@ function AppInner({
           projectDir={projectDir}
           threadId={threadId}
           workerRunning={workerRunning}
+          usage={usage}
         />
       </Box>
 
@@ -852,7 +859,7 @@ function AppInner({
         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>
+  );
+}

package/src/tui/components/HelpPanel.tsx

@@ -1,17 +1,42 @@
 import { Box, Text } from "ink";
 import { memo } from "react";
+import type { ContextUsage } from "../../chat/usage.ts";
 
 interface HelpPanelProps {
   projectDir: string;
   threadId: string;
   workerRunning: boolean;
+  usage?: ContextUsage | null;
+}
+
+function formatK(n: number): string {
+  return n >= 1000 ? `${Math.round(n / 1000)}k` : String(n);
+}
+
+function usageColorFor(pct: number): "red" | "yellow" | "green" {
+  if (pct >= 90) return "red";
+  if (pct >= 70) return "yellow";
+  return "green";
 }
 
 export const HelpPanel = memo(function HelpPanel({
   projectDir,
   threadId,
   workerRunning,
+  usage,
 }: HelpPanelProps) {
+  const pct =
+    usage && usage.max > 0 ? Math.round((usage.used / usage.max) * 100) : null;
+  const breakdownRows: { label: string; tokens: number }[] = usage
+    ? [
+        { label: "Prompts (files)", tokens: usage.breakdown.prompts },
+        { label: "Instructions   ", tokens: usage.breakdown.instructions },
+        { label: "Tools          ", tokens: usage.breakdown.tools },
+        { label: "Messages       ", tokens: usage.breakdown.messages },
+        { label: "Tool I/O       ", tokens: usage.breakdown.toolIo },
+      ]
+    : [];
+  const breakdownTotal = breakdownRows.reduce((s, r) => s + r.tokens, 0);
   return (
     <Box flexDirection="column" flexGrow={1} paddingX={1} overflow="hidden">
       <Box marginTop={1} flexDirection="column">
@@ -40,7 +65,7 @@ export const HelpPanel = memo(function HelpPanel({
           {"  "}Ctrl+w{"         "}Workers
         </Text>
         <Text>
-          {"  "}?{"              "}Help (from any non-chat tab)
+          {"  "}Ctrl+g{"        "}Help (Ctrl+/ also works in most terminals)
         </Text>
         <Text>
           {"  "}Escape{"         "}Return to Chat
@@ -112,18 +137,28 @@ export const HelpPanel = memo(function HelpPanel({
         <Text bold color="cyan">
           Per-panel actions
         </Text>
+        <Text dimColor>
+          {"  "}d delete needs two presses — arms first, confirms second
+          (cancels on any other key or after 3s)
+        </Text>
         <Text>
-          {"  "}Tasks{"          "}f filter · p priority · d delete · r refresh
+          {"  "}Tasks{"          "}f filter · p priority · d delete (×2) · r
+          refresh
         </Text>
         <Text>
-          {"  "}Threads{"        "}f filter · s/ search · w follow · d delete ·
-          r refresh
+          {"  "}Threads{"        "}f filter · s/ search · w follow · d delete
+          (×2) · r refresh
         </Text>
         <Text>
-          {"  "}Schedules{"      "}f filter · e toggle · d delete · r refresh
+          {"  "}Schedules{"      "}f filter · e toggle · d delete (×2) · r
+          refresh
         </Text>
         <Text>
-          {"  "}Workers{"        "}f filter · l toggle log/detail
+          {"  "}Context{"        "}d delete (×2) · r refresh
+        </Text>
+        <Text>
+          {"  "}Workers{"        "}f filter · l toggle log/detail · d delete log
+          (×2, log view)
         </Text>
       </Box>
 
@@ -139,6 +174,38 @@ export const HelpPanel = memo(function HelpPanel({
         </Text>
       </Box>
 
+      <Box marginTop={1} flexDirection="column">
+        <Text bold color="cyan">
+          Context usage
+        </Text>
+        {usage && pct !== null ? (
+          <>
+            <Text>
+              {"  "}Total{"     "}
+              <Text color={usageColorFor(pct)}>
+                {formatK(usage.used)}/{formatK(usage.max)} ({pct}%)
+              </Text>
+            </Text>
+            <Text dimColor>
+              {"  "}Estimate (~4 chars/token, sums to ~{formatK(breakdownTotal)}
+              ):
+            </Text>
+            {breakdownRows.map((row) => (
+              <Text key={row.label}>
+                {"    "}
+                {row.label}
+                {"  "}
+                {formatK(row.tokens)}
+              </Text>
+            ))}
+          </>
+        ) : (
+          <Text dimColor>
+            {"  "}Send a message to see token usage for the next turn.
+          </Text>
+        )}
+      </Box>
+
       <Box marginTop={1} flexDirection="column">
         <Text bold color="cyan">
           System Info

package/src/tui/components/SchedulePanel.tsx

@@ -12,7 +12,9 @@ import {
   handleListDetailKey,
 } from "../listDetailKeys.ts";
 import { ansi, 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 SchedulePanelProps {
@@ -94,7 +96,6 @@ export const SchedulePanel = memo(function SchedulePanel({
   const [focus, setFocus] = useState<FocusState>("list");
   const [enabledFilter, setEnabledFilter] = useState<boolean | null>(null);
   const [refreshTick, setRefreshTick] = useState(0);
-  const [confirmDelete, setConfirmDelete] = useState(false);
 
   // biome-ignore lint/correctness/useExhaustiveDependencies: refreshTick triggers manual refresh
   useEffect(() => {
@@ -159,25 +160,19 @@ export const SchedulePanel = memo(function SchedulePanel({
   const itemCountRef = useLatestRef(schedules.length);
   const maxDetailScrollRef = useLatestRef(maxDetailScroll);
   const selectedScheduleRef = useLatestRef(selectedSchedule);
-  const confirmDeleteRef = useLatestRef(confirmDelete);
   const focusRef = useLatestRef(focus);
 
+  const deleteConfirm = useDeleteConfirm(() => {
+    const s = selectedScheduleRef.current;
+    if (!s) return;
+    deleteSchedule(projectDir, s.id).then(() => {
+      forceRefresh();
+    });
+  });
+
   useInput(
     (input, key) => {
-      if (confirmDeleteRef.current) {
-        if (input === "y" || input === "d") {
-          const s = selectedScheduleRef.current;
-          if (s) {
-            deleteSchedule(projectDir, s.id).then(() => {
-              forceRefresh();
-            });
-          }
-          setConfirmDelete(false);
-        } else {
-          setConfirmDelete(false);
-        }
-        return;
-      }
+      if (input !== "d") deleteConfirm.cancel();
 
       if (
         handleListDetailKey(input, key, {
@@ -208,7 +203,8 @@ export const SchedulePanel = memo(function SchedulePanel({
         return;
       }
       if (input === "d" && selectedScheduleRef.current) {
-        setConfirmDelete(true);
+        const s = selectedScheduleRef.current;
+        deleteConfirm.pressDelete(s.name);
         return;
       }
       if (input === "r") {
@@ -273,13 +269,6 @@ export const SchedulePanel = memo(function SchedulePanel({
             </Text>
           )}
         </Box>
-        {confirmDelete && selectedSchedule && (
-          <Box paddingX={1}>
-            <Text color="red" bold>
-              Delete schedule? (y/n)
-            </Text>
-          </Box>
-        )}
         {sidebarVisible.map((schedule, vi) => {
           const i = vi + sidebarScrollOffset;
           const isSelected = i === selectedIndex;
@@ -342,10 +331,14 @@ export const SchedulePanel = memo(function SchedulePanel({
             focused={focus === "detail"}
           />
         </Box>
+        <DeleteArmedBanner
+          armed={deleteConfirm.armed}
+          label={deleteConfirm.armedLabel}
+        />
         <Text dimColor>
           {focus === "detail"
             ? "↑↓ scroll · ⇧↑↓ page · g/G top/bot · ← back to list"
-            : "↑↓ select · → enter detail · f filter · e toggle · d delete · r refresh"}
+            : "↑↓ select · → enter detail · f filter · e toggle · d delete (×2) · r refresh"}
         </Text>
       </Box>
     </Box>

package/src/tui/components/TabBar.tsx

@@ -2,8 +2,9 @@ import { Box, Text } from "ink";
 
 export type TabId = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
 
-// Help uses "?" (no Ctrl) because Ctrl+H is delivered as backspace by most
-// terminals. The other panels use Ctrl+<letter>.
+// Help uses Ctrl+G rather than Ctrl+H because most terminals deliver Ctrl+H
+// as backspace. Ctrl+G also catches the Ctrl+/ keystroke on terminals that
+// map it to BEL (0x07) — most macOS terminals do.
 const TABS: { id: TabId; label: string; key: string }[] = [
   { id: 1, label: "Chat", key: "^a" },
   { id: 2, label: "Tools", key: "^o" },
@@ -12,14 +13,30 @@ const TABS: { id: TabId; label: string; key: string }[] = [
   { id: 5, label: "Threads", key: "^r" },
   { id: 6, label: "Schedules", key: "^s" },
   { id: 7, label: "Workers", key: "^w" },
-  { id: 8, label: "Help", key: "?" },
+  { id: 8, label: "Help", key: "^g" },
 ];
 
 interface TabBarProps {
   activeTab: TabId;
+  usage?: { used: number; max: number } | null;
 }
 
-export function TabBar({ activeTab }: TabBarProps) {
+function formatK(n: number): string {
+  return n >= 1000 ? `${Math.round(n / 1000)}k` : String(n);
+}
+
+export function TabBar({ activeTab, usage }: TabBarProps) {
+  const pct =
+    usage && usage.max > 0 ? Math.round((usage.used / usage.max) * 100) : null;
+  const usageColor =
+    pct === null
+      ? undefined
+      : pct >= 90
+        ? "red"
+        : pct >= 70
+          ? "yellow"
+          : "green";
+
   return (
     <Box paddingX={1} gap={1}>
       {TABS.map(({ id, label, key: shortcut }) => {
@@ -37,6 +54,14 @@ export function TabBar({ activeTab }: TabBarProps) {
           </Box>
         );
       })}
+      <Box flexGrow={1} />
+      {usage && (
+        <Box>
+          <Text color={usageColor}>
+            {formatK(usage.used)}/{formatK(usage.max)}
+          </Text>
+        </Box>
+      )}
     </Box>
   );
 }

package/src/tui/components/TaskPanel.tsx

@@ -12,7 +12,9 @@ import {
   handleListDetailKey,
 } from "../listDetailKeys.ts";
 import { ansi, 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 TaskPanelProps {
@@ -199,8 +201,18 @@ export const TaskPanel = memo(function TaskPanel({
   const selectedTaskRef = useLatestRef(selectedTask);
   const focusRef = useLatestRef(focus);
 
+  const deleteConfirm = useDeleteConfirm(() => {
+    const t = selectedTaskRef.current;
+    if (!t) return;
+    deleteTask(projectDir, t.id).then(() => {
+      forceRefresh();
+    });
+  });
+
   useInput(
     (input, key) => {
+      if (input !== "d") deleteConfirm.cancel();
+
       if (
         handleListDetailKey(input, key, {
           focusRef,
@@ -226,9 +238,7 @@ export const TaskPanel = memo(function TaskPanel({
       if (input === "d") {
         const t = selectedTaskRef.current;
         if (!t) return;
-        deleteTask(projectDir, t.id).then(() => {
-          forceRefresh();
-        });
+        deleteConfirm.pressDelete(t.name || t.id);
         return;
       }
       if (input === "r") {
@@ -359,10 +369,14 @@ export const TaskPanel = memo(function TaskPanel({
             focused={focus === "detail"}
           />
         </Box>
+        <DeleteArmedBanner
+          armed={deleteConfirm.armed}
+          label={deleteConfirm.armedLabel}
+        />
         <Text dimColor>
           {focus === "detail"
             ? "↑↓ scroll · ⇧↑↓ page · g/G top/bot · ← back to list"
-            : "↑↓ select · → enter detail · f filter · p priority · d delete · r refresh"}
+            : "↑↓ select · → enter detail · f filter · p priority · d delete (×2) · r refresh"}
         </Text>
       </Box>
     </Box>

package/src/tui/components/ThreadPanel.tsx

@@ -15,7 +15,9 @@ import {
   handleListDetailKey,
 } from "../listDetailKeys.ts";
 import { ansi, 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 ThreadPanelProps {
@@ -168,7 +170,6 @@ export const ThreadPanel = memo(function ThreadPanel({
   const [focus, setFocus] = useState<FocusState>("list");
   const [typeFilter, setTypeFilter] = useState<Thread["type"] | null>(null);
   const [refreshTick, setRefreshTick] = useState(0);
-  const [confirmDelete, setConfirmDelete] = useState(false);
   const [searching, setSearching] = useState(false);
   const [searchQuery, setSearchQuery] = useState("");
   const [selectedDetail, setSelectedDetail] = useState<{
@@ -329,11 +330,18 @@ export const ThreadPanel = memo(function ThreadPanel({
   const selectedThreadRef = useLatestRef(selectedThread);
   const selectedDetailRef = useLatestRef(selectedDetail);
   const searchingRef = useLatestRef(searching);
-  const confirmDeleteRef = useLatestRef(confirmDelete);
   const isActiveSelectedRef = useLatestRef(isActiveSelected);
   const followingRef = useLatestRef(following);
   const focusRef = useLatestRef(focus);
 
+  const deleteConfirm = useDeleteConfirm(() => {
+    const t = selectedThreadRef.current;
+    if (!t || isActiveSelectedRef.current) return;
+    deleteThread(projectDir, t.id).then(() => {
+      forceRefresh();
+    });
+  });
+
   useInput(
     (input, key) => {
       // Search mode: capture typed characters
@@ -360,21 +368,7 @@ export const ThreadPanel = memo(function ThreadPanel({
         return;
       }
 
-      // Delete confirmation mode
-      if (confirmDeleteRef.current) {
-        if (input === "y" || input === "d") {
-          const t = selectedThreadRef.current;
-          if (t && !isActiveSelectedRef.current) {
-            deleteThread(projectDir, t.id).then(() => {
-              forceRefresh();
-            });
-          }
-          setConfirmDelete(false);
-        } else {
-          setConfirmDelete(false);
-        }
-        return;
-      }
+      if (input !== "d") deleteConfirm.cancel();
 
       if (
         handleListDetailKey(input, key, {
@@ -396,7 +390,8 @@ export const ThreadPanel = memo(function ThreadPanel({
       }
       if (input === "d" && selectedThreadRef.current) {
         if (isActiveSelectedRef.current) return; // Can't delete active thread
-        setConfirmDelete(true);
+        const t = selectedThreadRef.current;
+        deleteConfirm.pressDelete(t.title || "(untitled)");
         return;
       }
       if (input === "r") {
@@ -490,13 +485,6 @@ export const ThreadPanel = memo(function ThreadPanel({
             <Text color={theme.info}>▌</Text>
           </Box>
         )}
-        {confirmDelete && selectedThread && (
-          <Box paddingX={1}>
-            <Text color="red" bold>
-              Delete thread? (y/n)
-            </Text>
-          </Box>
-        )}
         {sidebarVisible.map((thread, vi) => {
           const i = vi + sidebarScrollOffset;
           const isSelected = i === selectedIndex;
@@ -573,6 +561,10 @@ export const ThreadPanel = memo(function ThreadPanel({
             focused={focus === "detail"}
           />
         </Box>
+        <DeleteArmedBanner
+          armed={deleteConfirm.armed}
+          label={deleteConfirm.armedLabel}
+        />
         <Box>
           {following && (
             <Text color={theme.success} bold>
@@ -583,7 +575,7 @@ export const ThreadPanel = memo(function ThreadPanel({
           <Text dimColor>
             {focus === "detail"
               ? "↑↓ scroll · ⇧↑↓ page · g/G top/bot · ← back to list"
-              : `↑↓ select · → enter detail · s search · f filter · d delete${selectedThread && !selectedThread.ended_at ? " · w follow" : ""} · r refresh`}
+              : `↑↓ select · → enter detail · s search · f filter · d delete (×2)${selectedThread && !selectedThread.ended_at ? " · w follow" : ""} · r refresh`}
           </Text>
         </Box>
       </Box>

package/src/tui/components/WorkerPanel.tsx

@@ -1,13 +1,20 @@
+import { basename } from "node:path";
 import { Box, Text, useInput, useStdout } from "ink";
 import { memo, useEffect, useMemo, useState } from "react";
 import { readLogTail } from "../../worker/log-reader.ts";
-import { listWorkers, type Worker } from "../../workers/store.ts";
+import {
+  deleteWorkerLog,
+  listWorkers,
+  type Worker,
+} from "../../workers/store.ts";
 import {
   detailPaneBorderProps,
   type FocusState,
   handleListDetailKey,
 } from "../listDetailKeys.ts";
+import { useDeleteConfirm } from "../useDeleteConfirm.ts";
 import { useLatestRef } from "../useLatestRef.ts";
+import { DeleteArmedBanner } from "./DeleteArmedBanner.tsx";
 import { Scrollbar } from "./Scrollbar.tsx";
 
 interface WorkerPanelProps {
@@ -161,6 +168,21 @@ export const WorkerPanel = memo(function WorkerPanel({
   const itemCountRef = useLatestRef(workers.length);
   const maxLogScrollRef = useLatestRef(maxLogScroll);
   const focusRef = useLatestRef(focus);
+  const viewModeRef = useLatestRef(viewMode);
+  const selectedLogPathRef = useLatestRef(selectedLogPath);
+
+  const deleteConfirm = useDeleteConfirm(() => {
+    const path = selectedLogPathRef.current;
+    if (!path) return;
+    deleteWorkerLog(projectDir, path)
+      .catch(() => {})
+      .finally(() => {
+        setLogContent("");
+        setLogSize(0);
+        setLogTruncated(false);
+        setLogScroll(0);
+      });
+  });
 
   // The right pane scrolls with arrows when focused. Tee the log scroll into
   // the follow-state so reaching the bottom resumes follow mode (and any
@@ -181,6 +203,8 @@ export const WorkerPanel = memo(function WorkerPanel({
     (input, key) => {
       if (!isActive) return;
 
+      if (input !== "d") deleteConfirm.cancel();
+
       // `l` toggles between detail (worker info) and log (tail) view in the
       // right pane.
       if (input === "l") {
@@ -206,6 +230,14 @@ export const WorkerPanel = memo(function WorkerPanel({
         setFilterIdx((i) => (i + 1) % STATUS_FILTERS.length);
         return;
       }
+
+      if (input === "d") {
+        if (viewModeRef.current !== "log") return;
+        const path = selectedLogPathRef.current;
+        if (!path) return;
+        deleteConfirm.pressDelete(`worker log: ${basename(path)}`);
+        return;
+      }
     },
     { isActive },
   );
@@ -225,10 +257,14 @@ export const WorkerPanel = memo(function WorkerPanel({
           {focus === "detail"
             ? "  · ↑↓ scroll  ⇧↑↓ page  g/G top/bot  ← back to list  l toggle"
             : viewMode === "log"
-              ? "  · ↑↓ select  → enter log  l detail  f filter"
+              ? "  · ↑↓ select  → enter log  l detail  f filter  d delete log (×2)"
               : "  · ↑↓ select  → enter detail  l view log  f filter"}
         </Text>
       </Box>
+      <DeleteArmedBanner
+        armed={deleteConfirm.armed}
+        label={deleteConfirm.armedLabel}
+      />
 
       {workers.length === 0 ? (
         <Text dimColor>

package/src/tui/useDeleteConfirm.ts

@@ -0,0 +1,115 @@
+import { useEffect, useRef, useState } from "react";
+
+/**
+ * Two-press delete confirmation. First press arms; second press within
+ * `ttlMs` confirms. Any non-`d` keystroke should call `cancel()`. The TTL
+ * is a safety net for idle/escape.
+ */
+
+export interface DeleteConfirmController {
+  isArmed(): boolean;
+  armedLabel(): string | null;
+  pressDelete: (label: string) => void;
+  cancel: () => void;
+  dispose: () => void;
+}
+
+export function createDeleteConfirmController(
+  onConfirm: () => void,
+  opts: { ttlMs?: number; onChange?: () => void } = {},
+): DeleteConfirmController {
+  const ttlMs = opts.ttlMs ?? 3000;
+  let armed = false;
+  let label: string | null = null;
+  let timer: ReturnType<typeof setTimeout> | null = null;
+
+  const clearTimer = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  };
+
+  const notify = () => {
+    opts.onChange?.();
+  };
+
+  const pressDelete = (next: string) => {
+    if (armed) {
+      clearTimer();
+      armed = false;
+      label = null;
+      notify();
+      onConfirm();
+      return;
+    }
+    armed = true;
+    label = next;
+    timer = setTimeout(() => {
+      armed = false;
+      label = null;
+      timer = null;
+      notify();
+    }, ttlMs);
+    notify();
+  };
+
+  const cancel = () => {
+    if (!armed && !timer) return;
+    clearTimer();
+    armed = false;
+    label = null;
+    notify();
+  };
+
+  const dispose = () => {
+    clearTimer();
+  };
+
+  return {
+    isArmed: () => armed,
+    armedLabel: () => label,
+    pressDelete,
+    cancel,
+    dispose,
+  };
+}
+
+export interface UseDeleteConfirmResult {
+  armed: boolean;
+  armedLabel: string | null;
+  pressDelete: (label: string) => void;
+  cancel: () => void;
+}
+
+export function useDeleteConfirm(
+  onConfirm: () => void,
+  opts: { ttlMs?: number } = {},
+): UseDeleteConfirmResult {
+  const [, setTick] = useState(0);
+
+  const onConfirmRef = useRef(onConfirm);
+  onConfirmRef.current = onConfirm;
+
+  const controllerRef = useRef<DeleteConfirmController | null>(null);
+  if (!controllerRef.current) {
+    controllerRef.current = createDeleteConfirmController(
+      () => onConfirmRef.current(),
+      { ttlMs: opts.ttlMs, onChange: () => setTick((t) => t + 1) },
+    );
+  }
+
+  useEffect(() => {
+    return () => {
+      controllerRef.current?.dispose();
+    };
+  }, []);
+
+  const c = controllerRef.current;
+  return {
+    armed: c.isArmed(),
+    armedLabel: c.armedLabel(),
+    pressDelete: c.pressDelete,
+    cancel: c.cancel,
+  };
+}

package/src/workers/store.ts

@@ -1,6 +1,6 @@
 import { readdir, stat, unlink } from "node:fs/promises";
-import { join } from "node:path";
-import { getWorkersDir } from "../constants.ts";
+import { join, resolve } from "node:path";
+import { getWorkerLogsDir, getWorkersDir } from "../constants.ts";
 import { atomicWrite, readWithMtime } from "../fs/atomic.ts";
 
 export const WORKER_MODES = ["persist", "once"] as const;
@@ -217,6 +217,28 @@ export async function deleteWorker(
   }
 }
 
+/**
+ * Delete a worker's on-disk log file. Refuses to touch anything outside
+ * `<projectDir>/logs/`. ENOENT is treated as success (idempotent).
+ */
+export async function deleteWorkerLog(
+  projectDir: string,
+  logPath: string,
+): Promise<boolean> {
+  const logsDir = resolve(getWorkerLogsDir(projectDir));
+  const target = resolve(logPath);
+  if (target !== logsDir && !target.startsWith(`${logsDir}/`)) {
+    throw new Error(`refusing to delete log outside ${logsDir}: ${logPath}`);
+  }
+  try {
+    await unlink(target);
+    return true;
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") return false;
+    throw err;
+  }
+}
+
 async function listWorkerIds(projectDir: string): Promise<string[]> {
   const dir = getWorkersDir(projectDir);
   try {