killeros 2.0.0 → 2.0.2

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 All notable changes to KillerOS are documented here.
 
+## [Unreleased]
+
+## [2.0.2] - 2026-08-08
+
+### Changed
+
+- Replaced the static activity Spark with a 12-frame orange glyph loop at 120 ms per frame.
+- Styled activity verbs orange and added the gray `(esc to interrupt · thinking)` status with bold `esc`.
+
+## [2.0.1] - 2026-08-08
+
+### Added
+
+- Added a height-bounded question viewport with configured Pi controls, progress labels, and compact expandable history.
+- Added an interactive `/goal` status and actions panel in TUI mode.
+- Added live command-blue highlighting for recognized slash command prefixes in the prompt editor.
+
+### Changed
+
+- Made reasoning colors contrast-safe, moved commands and links to the themed command-blue role, and changed activity to a static Spark with shuffled 2.5-second verb updates.
+- Reserved footer goal status for active, paused, and blocked work; completed goals remain in history and `/goal` status.
+- Made startup Git lookup asynchronous, cached footer session cost between content changes, and aligned the browser visual reference with v2.0.1 runtime behavior.
+
 ## [2.0.0] - 2026-08-07
 
 ### Changed

package/README.md

@@ -31,7 +31,7 @@ pi install git:github.com/KyrosHendrix/pi-KillerOS
 Pin an install to a release:
 
 ```bash
-pi install git:github.com/KyrosHendrix/pi-KillerOS@v2.0.0
+pi install git:github.com/KyrosHendrix/pi-KillerOS@v2.0.2
 ```
 
 Add `-l` to either command for a project-only install. Restart Pi after installing.
@@ -40,15 +40,15 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 
 - 52-column Compact startup card with inline version, polished model/provider identity, adjacent `/model`, directory, conditional Git branch, and a shuffled session-stable tip
 - Cohesive dark theme with coral accents and neutral tool-call containers across pending, success, and error states
-- Coral Spark activity indicator with Claude-adjacent verbs that advance between agent runs and a quiet hidden-thinking label
-- Framed multiline editor with Shift+Enter support
+- Animated orange 12-frame activity glyph loop at 120 ms per frame, with orange shuffled Claude-adjacent verbs changing every 2.5 seconds, a gray `(esc to interrupt · thinking)` status with bold `esc`, and a quiet hidden-thinking label
+- Framed multiline editor with Shift+Enter support and live command-blue highlighting for recognized slash command prefixes
 - Responsive footer with polished model/provider identity, plain-language context, and active goal state remaining; reasoning, Git branch, elapsed time, cost, and path cut down by available width
 - Automatic model-backed context compaction at 40% remaining; active goals continue after the saved summary
 - `/variants` selector and direct reasoning-level arguments
-- Codex-style `/goal` for durable long-running objectives with pause, resume, edit, clear, automatic continuation, and explicit completion
+- Codex-style `/goal` with an interactive status/action panel, durable objectives, pause, resume, edit, confirmed panel clearing, automatic continuation, and explicit completion
 - Claude Code-style `/init` that scans the repository and generates a concise root `AGENTS.md` without setup questions
-- `question` tool with filtering, proposal previews, keyboard selection, custom answers, history, cancellation, and resize-safe rendering
-- Mid-prompt slash completion with current Pi `0.82.1` commands, extensions, prompts, and skills
+- `question` tool with height-bounded option windows, configured Pi keybindings, live option/input progress, proposal previews, custom answers, history, cancellation, and compact expandable transcript rendering
+- Mid-prompt slash completion with current Pi `0.82.1` commands, extensions, prompts, and skills; paths, URLs, and invalid commands remain plain text
 - `/clear` for a confirmed new session, plus `/exit` for graceful shutdown
 - Concise system-prompt guidance without modifying completed assistant messages
 
@@ -56,7 +56,7 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 
 ```text
 /init                     Generate root AGENTS.md from repository evidence
-/goal                     View the current long-running goal
+/goal                     Open current goal status and valid actions
 /goal <objective>         Set an objective and start working
 /goal edit                Edit and reactivate the current goal
 /goal pause               Stop automatic continuation
@@ -78,7 +78,7 @@ Supported reasoning levels are `off`, `minimal`, `low`, `medium`, `high`, `xhigh
 
 KillerOS activates its packaged `killeros` theme when a TUI session starts. Tool-call backgrounds stay neutral across pending, successful, and failed states; restrained text and icons preserve status visibility.
 
-KillerOS displays session costs in USD. The footer uses Pi's human-readable model name when available, keeps the provider visually secondary, and renders context as `percent left (tokens)` without a progress bar. When a goal exists, the footer adds its active time or terminal state; at narrow widths, context pressure and goal state take priority.
+KillerOS displays session costs in USD. The footer uses Pi's human-readable model name when available, keeps the provider visually secondary, and renders context as `percent left (tokens)` without a progress bar. Active, paused, and blocked goals remain visible; completed goals remain in transcript history and `/goal` status rather than the footer. At narrow widths, context pressure and actionable goal state take priority.
 
 KillerOS checks context after each agent turn. At 40% remaining, it starts Pi's model-backed compaction after the current run settles, so the active turn is not aborted. Manual `/compact` uses the same model path and keeps custom focus instructions. If model compaction is unavailable or exhausts its retries, KillerOS uses the disclosed deterministic fallback and warns that repeated compaction can reduce accuracy.
 

package/killeros/bounded-text.ts

@@ -0,0 +1,25 @@
+import { Text, truncateToWidth, visibleWidth, type Component } from "@earendil-works/pi-tui";
+
+export class BoundedText implements Component {
+  private readonly text: string;
+  private readonly maxRows?: number;
+
+  constructor(text: string, maxRows?: number) {
+    this.text = text;
+    this.maxRows = maxRows;
+  }
+
+  render(width: number): string[] {
+    if (width <= 0) return [];
+    const lines = new Text(this.text, 0, 0).render(width);
+    if (this.maxRows === undefined || lines.length <= this.maxRows) return lines;
+    const rowLimit = Math.max(1, this.maxRows);
+    const visible = lines.slice(0, rowLimit);
+    const suffix = " …";
+    const last = visible.at(-1) ?? "";
+    visible[rowLimit - 1] = `${truncateToWidth(last, Math.max(0, width - visibleWidth(suffix)), "")}${suffix}`;
+    return visible.map((line) => truncateToWidth(line, width, ""));
+  }
+
+  invalidate(): void {}
+}

package/killeros/commands.ts

@@ -54,6 +54,13 @@ const BUILTIN_COMMANDS: ReadonlyArray<{ name: string; description: string }> = [
   { name: "quit", description: "Quit Pi" },
 ];
 
+export function availableCommandNames(pi: ExtensionAPI): ReadonlySet<string> {
+  return new Set([
+    ...BUILTIN_COMMANDS.map((command) => command.name),
+    ...pi.getCommands().map((command) => command.name),
+  ]);
+}
+
 const COMMAND_SYNTAX_HINTS: Readonly<Record<string, string>> = {
   goal: "/goal [objective|clear|edit|pause|resume]",
   variants: "/variants [level]",

package/killeros/footer.ts

@@ -116,16 +116,34 @@ function formatGoalFooter(state: GoalState | undefined, theme: Theme): string {
   if (state.status === "active") return theme.fg("accent", `✻ goal · ${formatTime(goalElapsedMilliseconds(state))}`);
   if (state.status === "paused") return theme.fg("warning", "Ⅱ goal paused");
   if (state.status === "blocked") return theme.fg("error", "! goal blocked");
-  return theme.fg("success", "✓ goal complete");
+  return "";
 }
 
 export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void {
   let currentModel: ExtensionContext["model"];
   let thinkingLevel: ThinkingLevel = "off";
   let activeTui: TUI | undefined;
+  let cachedSessionCost = 0;
+  let sessionCostDirty = true;
+  const resetSessionCost = (): void => {
+    cachedSessionCost = 0;
+    sessionCostDirty = true;
+  };
+  const invalidateSessionCost = (): void => {
+    sessionCostDirty = true;
+    activeTui?.requestRender();
+  };
+  const getSessionCost = (ctx: ExtensionContext): number => {
+    if (sessionCostDirty) {
+      cachedSessionCost = sumSessionCost(ctx);
+      sessionCostDirty = false;
+    }
+    return cachedSessionCost;
+  };
   goalRuntime.requestRender = () => activeTui?.requestRender();
 
   pi.on("session_start", (_event, ctx) => {
+    resetSessionCost();
     if (ctx.mode !== "tui") return;
     const sessionStart = Date.now();
     currentModel = ctx.model;
@@ -170,7 +188,7 @@ export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void
             goal,
             branch ? theme.fg("dim", branch) : "",
             theme.fg("dim", formatTime(Date.now() - sessionStart)),
-            theme.fg("dim", formatCost(sumSessionCost(ctx))),
+            theme.fg("dim", formatCost(getSessionCost(ctx))),
           ], theme);
           const focused = joinFooterParts([signature, context, goal], theme);
 
@@ -207,7 +225,14 @@ export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void
     thinkingLevel = event.level;
     activeTui?.requestRender();
   });
+  pi.on("turn_end", invalidateSessionCost);
+  pi.on("session_compact", invalidateSessionCost);
+  pi.on("session_tree", () => {
+    resetSessionCost();
+    activeTui?.requestRender();
+  });
   pi.on("session_shutdown", () => {
+    resetSessionCost();
     activeTui = undefined;
     goalRuntime.requestRender = undefined;
   });

package/killeros/goals.ts

@@ -1,7 +1,8 @@
-import { type ExtensionAPI, type ExtensionContext, type ThemeColor } from "@earendil-works/pi-coding-agent";
+import { type ExtensionAPI, type ExtensionCommandContext, type ExtensionContext, type ThemeColor } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { MAX_NODE_TIMER_MS } from "./limits.ts";
+import { BoundedText } from "./bounded-text.ts";
 import { CONCISE_SYSTEM_PROMPT } from "./concise.ts";
 import { formatTime, formatTokens } from "./display.ts";
 import { reportError } from "./errors.ts";
@@ -175,6 +176,18 @@ function goalStatusLabel(status: GoalStatus): string {
   return `${status.charAt(0).toLocaleUpperCase()}${status.slice(1)}`;
 }
 
+function goalPanelActions(status: GoalStatus): Array<{ label: string; control: "pause" | "resume" | "edit" | "clear" }> {
+  const terminal = [
+    { label: "Edit objective", control: "edit" as const },
+    { label: "Clear goal", control: "clear" as const },
+  ];
+  if (status === "active") return [{ label: "Pause automatic continuation", control: "pause" }, ...terminal];
+  if (status === "paused" || status === "blocked") {
+    return [{ label: "Resume automatic continuation", control: "resume" }, ...terminal];
+  }
+  return terminal;
+}
+
 function goalStatusSummary(state: GoalState, ctx: ExtensionContext): string {
   const usedTokens = Math.max(0, sumGoalTokens(ctx) - state.baselineTokens);
   const lines = [
@@ -293,7 +306,7 @@ export function registerGoal(
   runtime: GoalRuntime,
   initState: InitRuntime,
 ): void {
-  pi.registerEntryRenderer<GoalEntryData>(GOAL_ENTRY_TYPE, (entry, _options, theme) => {
+  pi.registerEntryRenderer<GoalEntryData>(GOAL_ENTRY_TYPE, (entry, options, theme) => {
     const data = entry.data;
     if (!data || data.version !== GOAL_VERSION || data.event === "turn" || data.event === "checkpoint") return undefined;
     if (data.event === "clear" || data.state === null) return new Text(theme.fg("dim", "Goal cleared"), 0, 0);
@@ -301,7 +314,11 @@ export function registerGoal(
     if (!state) return undefined;
     const icon = state.status === "active" ? "✻" : state.status === "paused" ? "Ⅱ" : state.status === "blocked" ? "!" : "✓";
     const color: ThemeColor = state.status === "active" ? "accent" : state.status === "paused" ? "warning" : state.status === "blocked" ? "error" : "success";
-    return new Text(`${theme.fg(color, `${icon} Goal ${state.status}`)}${theme.fg("dim", ` · ${state.objective}`)}`, 0, 0);
+    const status = theme.fg(color, `${icon} Goal ${state.status}`);
+    if (!options.expanded) return new BoundedText(`${status}${theme.fg("dim", ` · ${state.objective}`)}`, 3);
+    const lines = [status, theme.fg("dim", state.objective)];
+    if (state.result) lines.push(theme.fg("muted", state.result));
+    return new BoundedText(lines.join("\n"));
   });
 
   pi.registerTool<typeof GoalUpdateParams, GoalUpdateDetails>({
@@ -329,11 +346,11 @@ export function registerGoal(
     renderCall(args, theme) {
       return new Text(`${theme.fg("toolTitle", theme.bold("goal "))}${theme.fg("muted", args.status)}`, 0, 0);
     },
-    renderResult(result, _options, theme) {
+    renderResult(result, options, theme) {
       const details = result.details;
-      return new Text(details
-        ? `${theme.fg(details.status === "complete" ? "success" : "warning", details.status === "complete" ? "✓ Complete" : "! Blocked")}${theme.fg("dim", ` · ${details.evidence}`)}`
-        : theme.fg("dim", "Goal updated"), 0, 0);
+      if (!details) return new BoundedText(theme.fg("dim", "Goal updated"));
+      const text = `${theme.fg(details.status === "complete" ? "success" : "warning", details.status === "complete" ? "✓ Complete" : "! Blocked")}${theme.fg("dim", ` · ${details.evidence}`)}`;
+      return new BoundedText(text, options.expanded ? undefined : 3);
     },
   });
 
@@ -428,22 +445,7 @@ export function registerGoal(
     runtime.lastError = finalAssistant?.errorMessage;
   });
 
-  pi.registerCommand("goal", {
-    description: "Set or view the goal for a long-running task",
-    getArgumentCompletions: (prefix) => {
-      const normalized = prefix.trimStart().toLocaleLowerCase();
-      if (normalized.includes(" ")) return null;
-      const actions = [
-        { value: "clear", description: "Remove the current goal" },
-        { value: "edit", description: "Edit and reactivate the current goal" },
-        { value: "pause", description: "Stop automatic continuation" },
-        { value: "resume", description: "Resume automatic continuation" },
-      ];
-      return actions
-        .filter((action) => action.value.startsWith(normalized))
-        .map((action) => ({ ...action, label: action.value }));
-    },
-    handler: async (args, ctx) => {
+  const handleGoalCommand = async (args: string, ctx: ExtensionCommandContext): Promise<void> => {
       if (ctx.mode === "print" || ctx.mode === "json") {
         ctx.ui.notify("/goal requires TUI or RPC mode", "error");
         return;
@@ -461,7 +463,16 @@ export function registerGoal(
           ctx.ui.notify("No goal is set. Use /goal <objective> to start a long-running task.", "info");
           return;
         }
-        ctx.ui.notify(goalStatusSummary(runtime.state, ctx), "info");
+        if (ctx.mode !== "tui") {
+          ctx.ui.notify(goalStatusSummary(runtime.state, ctx), "info");
+          return;
+        }
+        const actions = goalPanelActions(runtime.state.status);
+        const selected = await ctx.ui.select(goalStatusSummary(runtime.state, ctx), actions.map((action) => action.label));
+        const action = actions.find((candidate) => candidate.label === selected);
+        if (!action) return;
+        if (action.control === "clear" && !await ctx.ui.confirm("Clear goal?", runtime.state.objective)) return;
+        await handleGoalCommand(action.control, ctx);
         return;
       }
 
@@ -684,7 +695,24 @@ export function registerGoal(
         reportError(ctx, "Goal could not be started", error);
         scheduleGoalContinuation(pi, runtime, initState, ctx);
       }
+  };
+
+  pi.registerCommand("goal", {
+    description: "Set or view the goal for a long-running task",
+    getArgumentCompletions: (prefix) => {
+      const normalized = prefix.trimStart().toLocaleLowerCase();
+      if (normalized.includes(" ")) return null;
+      const actions = [
+        { value: "clear", description: "Remove the current goal" },
+        { value: "edit", description: "Edit and reactivate the current goal" },
+        { value: "pause", description: "Stop automatic continuation" },
+        { value: "resume", description: "Resume automatic continuation" },
+      ];
+      return actions
+        .filter((action) => action.value.startsWith(normalized))
+        .map((action) => ({ ...action, label: action.value }));
     },
+    handler: handleGoalCommand,
   });
 }
 

package/killeros/question.ts

@@ -1,19 +1,14 @@
-import { type ExtensionAPI, type ThemeColor } from "@earendil-works/pi-coding-agent";
+import { keyHint, type ExtensionAPI, type ThemeColor } from "@earendil-works/pi-coding-agent";
 import {
-  Container,
   decodeKittyPrintable,
   Editor,
-  Key,
   Markdown,
-  matchesKey,
-  SelectList,
-  Text,
   truncateToWidth,
-  visibleWidth,
   wrapTextWithAnsi,
   type EditorTheme,
 } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
+import { BoundedText } from "./bounded-text.ts";
 
 const OptionSchema = Type.Object({
   label: Type.String({ minLength: 1, maxLength: 200, description: "Display label for the option" }),
@@ -90,6 +85,16 @@ function removeLastGrapheme(value: string): string {
   return last ? value.slice(0, last.index) : "";
 }
 
+function oneLine(value: string): string {
+  return value.replace(/\s+/gu, " ").trim();
+}
+
+function visibleOptionRange(total: number, selected: number, capacity: number): { start: number; end: number } {
+  const size = Math.max(1, Math.min(total, capacity));
+  const start = Math.max(0, Math.min(selected - Math.floor(size / 2), total - size));
+  return { start, end: Math.min(total, start + size) };
+}
+
 export function registerQuestionTool(pi: ExtensionAPI): void {
   const customInputHistory: string[] = [];
   let customInputHistoryBytes = 0;
@@ -153,11 +158,12 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
       ];
 
       let finishFromAbort: (() => void) | undefined;
-      const resultPromise = ctx.ui.custom<QuestionSelection>((tui, theme, _keybindings, done) => {
+      const resultPromise = ctx.ui.custom<QuestionSelection>((tui, theme, keybindings, done) => {
         let optionIndex = 0;
         let editMode = false;
         let filterQuery = "";
         let cachedWidth: number | undefined;
+        let cachedRows: number | undefined;
         let cachedLines: string[] | undefined;
         let completed = false;
 
@@ -191,6 +197,7 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
 
         const invalidate = (): void => {
           cachedWidth = undefined;
+          cachedRows = undefined;
           cachedLines = undefined;
           editor.invalidate();
         };
@@ -241,7 +248,7 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
 
         const handleInput = (data: string): void => {
           if (editMode) {
-            if (matchesKey(data, Key.escape)) {
+            if (keybindings.matches(data, "tui.select.cancel")) {
               editMode = false;
               editor.setText("");
               refresh();
@@ -260,24 +267,35 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
 
           const visibleOptions = filteredOptions();
           if (optionIndex >= visibleOptions.length) optionIndex = Math.max(0, visibleOptions.length - 1);
-          if (matchesKey(data, Key.up)) {
+          const pageSize = Math.max(1, Math.min(5, Math.ceil(Math.max(1, tui.terminal.rows - 5) / 2)));
+          if (keybindings.matches(data, "tui.select.up")) {
             optionIndex = Math.max(0, optionIndex - 1);
             refresh();
             return;
           }
-          if (matchesKey(data, Key.down)) {
+          if (keybindings.matches(data, "tui.select.down")) {
             optionIndex = Math.min(visibleOptions.length - 1, optionIndex + 1);
             refresh();
             return;
           }
-          if (matchesKey(data, Key.enter)) {
+          if (keybindings.matches(data, "tui.select.pageUp")) {
+            optionIndex = Math.max(0, optionIndex - pageSize);
+            refresh();
+            return;
+          }
+          if (keybindings.matches(data, "tui.select.pageDown")) {
+            optionIndex = Math.min(visibleOptions.length - 1, optionIndex + pageSize);
+            refresh();
+            return;
+          }
+          if (keybindings.matches(data, "tui.select.confirm")) {
             const selected = visibleOptions[optionIndex];
             if (!selected) return;
             if (selected.isOther) enterCustomMode();
             else finish({ kind: "selected", answer: selected.label, originalIndex: selected.originalIndex });
             return;
           }
-          if (matchesKey(data, Key.escape)) {
+          if (keybindings.matches(data, "tui.select.cancel")) {
             if (filterQuery) {
               filterQuery = "";
               optionIndex = 0;
@@ -287,7 +305,7 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
             }
             return;
           }
-          if (matchesKey(data, Key.backspace)) {
+          if (keybindings.matches(data, "tui.editor.deleteCharBackward")) {
             if (filterQuery) {
               filterQuery = removeLastGrapheme(filterQuery);
               optionIndex = 0;
@@ -304,60 +322,94 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
             else finish({ kind: "selected", answer: selected.label, originalIndex: selected.originalIndex });
             return;
           }
-          if (printableInput) {
-            appendFilterInput(printableInput);
-          }
+          if (printableInput) appendFilterInput(printableInput);
         };
 
         const render = (width: number): string[] => {
-          const renderWidth = Math.max(1, width);
-          if (cachedLines && cachedWidth === renderWidth) return cachedLines;
-          const lines: string[] = [];
-          const addWrapped = (text: string): void => {
-            lines.push(...wrapTextWithAnsi(text, renderWidth));
-          };
-          const addWrappedWithPrefix = (prefix: string, text: string): void => {
-            const prefixWidth = visibleWidth(prefix);
-            if (prefixWidth >= renderWidth) {
-              addWrapped(prefix + text);
-              return;
-            }
-            const wrapped = wrapTextWithAnsi(text, renderWidth - prefixWidth);
-            const continuation = " ".repeat(prefixWidth);
-            wrapped.forEach((line, index) => lines.push(`${index === 0 ? prefix : continuation}${line}`));
-          };
+          if (width <= 0) return [];
+          const renderWidth = width;
+          const rowBudget = Math.max(1, tui.terminal.rows);
+          if (cachedLines && cachedWidth === renderWidth && cachedRows === rowBudget) return cachedLines;
+          const visibleOptions = filteredOptions();
+          if (optionIndex >= visibleOptions.length) optionIndex = Math.max(0, visibleOptions.length - 1);
+          const selected = visibleOptions[optionIndex];
+          const position = `Option ${Math.min(optionIndex + 1, visibleOptions.length)}/${visibleOptions.length}`;
+          const answerCount = inputCharacterCount(editor.getExpandedText()).toLocaleString();
+          const filterCount = inputCharacterCount(filterQuery).toLocaleString();
+
+          if (rowBudget <= 2) {
+            const compact = editMode
+              ? [`Answer ${answerCount}/${CUSTOM_INPUT_MAX_CHARACTERS.toLocaleString()}`, editor.getExpandedText() || "Type an answer"]
+              : [`${selected ? `> ${selected.label}` : "No matching options"} · ${position}`];
+            cachedWidth = renderWidth;
+            cachedRows = rowBudget;
+            cachedLines = compact.slice(0, rowBudget).map((line) => truncateToWidth(line, renderWidth, "…"));
+            return cachedLines;
+          }
 
-          lines.push(theme.fg("accent", "─".repeat(renderWidth)));
-          addWrappedWithPrefix(" ", theme.fg("text", params.question));
-          lines.push("");
-          if (!editMode && filterQuery) {
-            addWrappedWithPrefix(" ", `${theme.fg("muted", "Filter: ")}${theme.fg("accent", filterQuery)}`);
-            lines.push("");
+          if (rowBudget <= 5) {
+            const compact = [
+              truncateToWidth(params.question.replace(/\s+/gu, " "), renderWidth, "…"),
+              editMode
+                ? `Answer ${answerCount}/${CUSTOM_INPUT_MAX_CHARACTERS.toLocaleString()}`
+                : `${selected ? `> ${selected.label}` : "No matching options"} · ${position}`,
+              editMode
+                ? editor.getExpandedText() || "Type an answer"
+                : filterQuery
+                  ? `Filter ${filterCount}/${FILTER_QUERY_MAX_CHARACTERS.toLocaleString()}`
+                  : position,
+              editMode
+                ? `${keyHint("tui.input.submit", "submit")} • ${keyHint("tui.select.cancel", "options")}`
+                : `${keyHint("tui.select.confirm", "select")} • ${keyHint("tui.select.cancel", "cancel")}`,
+            ];
+            cachedWidth = renderWidth;
+            cachedRows = rowBudget;
+            cachedLines = compact.slice(0, rowBudget).map((line) => truncateToWidth(line, renderWidth, "…"));
+            return cachedLines;
           }
 
-          const visibleOptions = filteredOptions();
-          if (optionIndex >= visibleOptions.length) optionIndex = Math.max(0, visibleOptions.length - 1);
-          visibleOptions.forEach((option, index) => {
-            const selected = index === optionIndex;
-            const prefix = selected ? theme.fg("accent", "> ") : "  ";
-            const color: ThemeColor = selected ? "accent" : "text";
-            addWrappedWithPrefix(prefix, theme.fg(color, `${index + 1}. ${option.label}`));
-            if (selected && option.description) {
-              addWrappedWithPrefix("    ", theme.fg("muted", option.description));
+          const contentRows = rowBudget - 5;
+          const optionCapacity = Math.max(1, Math.min(5, Math.ceil(contentRows / 2)));
+          const detailCapacity = Math.max(0, contentRows - optionCapacity);
+          const { start, end } = visibleOptionRange(visibleOptions.length, optionIndex, optionCapacity);
+          const hiddenAbove = start > 0 ? `↑ ${start}` : "";
+          const hiddenBelowCount = visibleOptions.length - end;
+          const hiddenBelow = hiddenBelowCount > 0 ? `↓ ${hiddenBelowCount}` : "";
+          const hiddenStatus = [hiddenAbove, hiddenBelow].filter(Boolean).join(" · ");
+          const progress = editMode
+            ? `Answer ${answerCount}/${CUSTOM_INPUT_MAX_CHARACTERS.toLocaleString()}`
+            : filterQuery
+              ? `Filter ${filterCount}/${FILTER_QUERY_MAX_CHARACTERS.toLocaleString()} · ${position}`
+              : `${position}${hiddenStatus ? ` · ${hiddenStatus}` : ""}`;
+          const hint = editMode
+            ? `${keyHint("tui.input.submit", "submit")} • ${keyHint("tui.select.cancel", "options")}`
+            : `${keyHint("tui.select.up", "up")} • ${keyHint("tui.select.down", "down")} • ${keyHint("tui.select.confirm", "select")} • ${keyHint("tui.select.cancel", filterQuery ? "clear filter" : "cancel")}`;
+          const lines: string[] = [
+            theme.fg("accent", "─".repeat(renderWidth)),
+            theme.fg("text", truncateToWidth(` ${params.question.replace(/\s+/gu, " ")}`, renderWidth, "…")),
+            theme.fg("muted", truncateToWidth(` ${progress}`, renderWidth, "…")),
+          ];
+
+          if (editMode) {
+            const editorLines = editor.render(renderWidth);
+            const draftLines = editorLines.length > 2 ? editorLines.slice(1, -1) : editorLines;
+            lines.push(...(draftLines.length > 0 ? draftLines : ["Type an answer"]).slice(-contentRows));
+          } else {
+            for (let index = start; index < end; index += 1) {
+              const option = visibleOptions[index]!;
+              const isSelected = index === optionIndex;
+              const prefix = isSelected ? "> " : "  ";
+              const color: ThemeColor = isSelected ? "accent" : "text";
+              lines.push(theme.fg(color, truncateToWidth(`${prefix}${index + 1}. ${option.label}`, renderWidth, "…")));
             }
-          });
-
-          const selectedPreview = visibleOptions[optionIndex]?.preview;
-          if (!editMode && selectedPreview) {
-            const footerRows = 3;
-            const previewChromeRows = 2;
-            const availableRows = tui.terminal.rows - lines.length - footerRows;
-            if (availableRows > previewChromeRows) {
-              lines.push("");
-              addWrappedWithPrefix(" ", theme.fg("accent", theme.bold("Proposal preview")));
-              const markdownLines = new Markdown(
-                selectedPreview,
-                1,
+
+            const detailLines: string[] = [];
+            if (selected?.description) detailLines.push(...wrapTextWithAnsi(theme.fg("muted", selected.description), renderWidth));
+            if (selected?.preview) {
+              detailLines.push(theme.fg("accent", theme.bold("Proposal preview")));
+              detailLines.push(...new Markdown(
+                selected.preview,
+                0,
                 0,
                 {
                   heading: (text) => theme.fg("accent", theme.bold(text)),
@@ -376,35 +428,23 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
                   underline: (text) => theme.underline(text),
                 },
                 { color: (text) => theme.fg("muted", text) },
-              ).render(renderWidth);
-              const maxPreviewRows = Math.min(12, availableRows - previewChromeRows);
-              if (markdownLines.length <= maxPreviewRows) {
-                lines.push(...markdownLines);
-              } else {
-                const visiblePreviewRows = Math.max(0, maxPreviewRows - 1);
-                lines.push(...markdownLines.slice(0, visiblePreviewRows));
-                const hiddenRows = markdownLines.length - visiblePreviewRows;
-                lines.push(theme.fg("dim", ` … ${hiddenRows} more line${hiddenRows === 1 ? "" : "s"}`));
-              }
+              ).render(renderWidth));
+            }
+            if (detailCapacity > 0 && detailLines.length > detailCapacity) {
+              const visibleDetailRows = Math.max(0, detailCapacity - 1);
+              lines.push(...detailLines.slice(0, visibleDetailRows));
+              const hiddenRows = detailLines.length - visibleDetailRows;
+              lines.push(theme.fg("dim", `… ${hiddenRows} more line${hiddenRows === 1 ? "" : "s"}`));
+            } else {
+              lines.push(...detailLines.slice(0, detailCapacity));
             }
           }
 
-          if (editMode) {
-            lines.push("");
-            addWrappedWithPrefix(" ", theme.fg("muted", "Your answer:"));
-            editor.render(Math.max(1, renderWidth - 2)).forEach((line) => lines.push(` ${line}`));
-          }
-
-          lines.push("");
-          const hint = editMode
-            ? `Enter submit • Esc options${customInputHistory.length ? " • ↑↓ history" : ""}`
-            : filterQuery
-              ? "1-9 select • ↑↓ navigate • Enter select • Esc clear filter"
-              : "1-9 select • type to filter • ↑↓ navigate • Enter select • Esc cancel";
-          addWrappedWithPrefix(" ", theme.fg("dim", hint));
+          lines.push(theme.fg("dim", truncateToWidth(` ${hint}`, renderWidth, "…")));
           lines.push(theme.fg("accent", "─".repeat(renderWidth)));
           cachedWidth = renderWidth;
-          cachedLines = lines.map((line) => truncateToWidth(line, renderWidth, ""));
+          cachedRows = rowBudget;
+          cachedLines = lines.slice(0, rowBudget).map((line) => truncateToWidth(line, renderWidth, ""));
           return cachedLines;
         };
 
@@ -457,27 +497,34 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
       };
     },
 
-    renderCall(args, theme) {
-      let text = `${theme.fg("toolTitle", theme.bold("question "))}${theme.fg("muted", args.question)}`;
-      if (args.options.length) {
-        const numbered = [...args.options.map((option) => option.label), "Type a custom answer"]
-          .map((option, index) => `${index + 1}. ${option}`);
-        text += `\n${theme.fg("dim", `  Options: ${numbered.join(", ")}`)}`;
+    renderCall(args, theme, context) {
+      if (!context.expanded) {
+        const summary = `${theme.fg("toolTitle", theme.bold("question "))}${theme.fg("muted", oneLine(args.question))}\n${theme.fg("dim", `  ${args.options.length} option${args.options.length === 1 ? "" : "s"}`)}`;
+        return new BoundedText(summary, 3);
       }
-      return new Text(text, 0, 0);
+
+      const lines = [`${theme.fg("toolTitle", theme.bold("question "))}${theme.fg("muted", args.question)}`];
+      args.options.forEach((option, index) => {
+        lines.push(theme.fg("text", `${index + 1}. ${option.label}`));
+        if (option.description) lines.push(theme.fg("muted", `   ${option.description}`));
+        if (option.preview) lines.push(theme.fg("dim", option.preview));
+      });
+      lines.push(theme.fg("text", `${args.options.length + 1}. Type a custom answer`));
+      return new BoundedText(lines.join("\n"));
     },
 
-    renderResult(result, _options, theme) {
+    renderResult(result, options, theme) {
       const details = result.details;
       if (!details) {
         const first = result.content[0];
-        return new Text(first?.type === "text" ? first.text : "", 0, 0);
+        return new BoundedText(first?.type === "text" ? first.text : "", options.expanded ? undefined : 3);
       }
-      if (details.cancelled || details.answer === null) return new Text(theme.fg("warning", "Cancelled"), 0, 0);
+      if (details.cancelled || details.answer === null) return new BoundedText(theme.fg("warning", "Cancelled"));
       if (details.wasCustom) {
-        return new Text(`${theme.fg("success", "✓ ")}${theme.fg("muted", "(wrote) ")}${theme.fg("accent", details.answer)}`, 0, 0);
+        const text = `${theme.fg("success", "✓ ")}${theme.fg("muted", "(wrote) ")}${theme.fg("accent", details.answer)}`;
+        return new BoundedText(text, options.expanded ? undefined : 3);
       }
-      return new Text(`${theme.fg("success", "✓ ")}${theme.fg("accent", details.answer)}`, 0, 0);
+      return new BoundedText(`${theme.fg("success", "✓ ")}${theme.fg("accent", details.answer)}`);
     },
   });
 }

package/killeros/shell-ui.ts

@@ -1,4 +1,4 @@
-import { execFileSync } from "node:child_process";
+import { execFile } from "node:child_process";
 import { readFileSync } from "node:fs";
 import {
   CustomEditor,
@@ -11,6 +11,7 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import {
   Container,
+  CURSOR_MARKER,
   Text,
   truncateToWidth,
   visibleWidth,
@@ -18,16 +19,14 @@ import {
   type EditorTheme,
   type TUI,
 } from "@earendil-works/pi-tui";
+import { availableCommandNames } from "./commands.ts";
 import { formatCwd, padRight } from "./display.ts";
 import { reportError } from "./errors.ts";
 import { formatModel } from "./footer.ts";
 import { LEVEL_COLORS, type ThinkingLevel } from "./variants.ts";
 
-const COMMAND_BLUE_RGB = "120;169;255";
 const COMPACT_HEADER_MAX_WIDTH = 52;
 
-const commandBlue = (text: string): string => `\x1B[38;2;${COMMAND_BLUE_RGB}m${text}\x1B[39m`;
-
 function readPackageVersion(path: string | URL): string | undefined {
   try {
     const value = JSON.parse(readFileSync(path, "utf8")) as { version?: unknown };
@@ -45,20 +44,27 @@ const STARTUP_TIPS = [
   "Type / to browse every command available in this session.",
 ] as const;
 
-function resolveGitBranch(cwd: string): string | undefined {
-  try {
-    const branch = execFileSync("git", ["-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"], {
-      encoding: "utf8",
-      maxBuffer: 64 * 1024,
-      stdio: ["ignore", "pipe", "ignore"],
-      timeout: 500,
-      windowsHide: true,
-    }).trim();
-    if (!branch) return undefined;
-    return branch === "HEAD" ? "detached" : branch;
-  } catch {
-    return undefined;
-  }
+export function resolveGitBranch(cwd: string): Promise<string | undefined> {
+  return new Promise((resolve) => {
+    execFile(
+      "git",
+      ["-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"],
+      {
+        encoding: "utf8",
+        maxBuffer: 64 * 1024,
+        timeout: 500,
+        windowsHide: true,
+      },
+      (error, stdout) => {
+        if (error) {
+          resolve(undefined);
+          return;
+        }
+        const branch = stdout.trim();
+        resolve(branch ? branch === "HEAD" ? "detached" : branch : undefined);
+      },
+    );
+  });
 }
 
 function shuffledTips(): string[] {
@@ -78,14 +84,21 @@ function compactBoxLine(content: string, width: number, theme: Theme): string {
 class PiStartupHeader {
   private readonly pi: ExtensionAPI;
   private readonly ctx: ExtensionContext;
-  private readonly branch: string | undefined;
   private readonly tip: string;
+  private readonly tui: TUI;
+  private branch: string | undefined;
+  private disposed = false;
 
-  constructor(pi: ExtensionAPI, ctx: ExtensionContext, tip: string) {
+  constructor(pi: ExtensionAPI, ctx: ExtensionContext, tip: string, tui: TUI) {
     this.pi = pi;
     this.ctx = ctx;
-    this.branch = resolveGitBranch(ctx.cwd);
     this.tip = tip;
+    this.tui = tui;
+    void resolveGitBranch(ctx.cwd).then((branch) => {
+      if (this.disposed) return;
+      this.branch = branch;
+      this.tui.requestRender();
+    });
   }
 
   private tipLines(width: number, theme: Theme): string[] {
@@ -113,7 +126,7 @@ class PiStartupHeader {
     const repository = this.branch
       ? `${directory} ${theme.fg("dim", `· ${this.branch}`)}`
       : directory;
-    const modelCommand = commandBlue("/model");
+    const modelCommand = theme.fg("mdLink", "/model");
     const agentWidth = Math.max(0, innerWidth - visibleWidth(modelCommand) - 1);
     const agentCommand = `${truncateToWidth(agent, agentWidth, "…")} ${modelCommand}`;
     const border = (left: string, right: string): string => theme.fg("dim", `${left}${"─".repeat(panelWidth - 2)}${right}`);
@@ -131,10 +144,119 @@ class PiStartupHeader {
   }
 
   invalidate(): void {}
-  dispose(): void {}
+  dispose(): void {
+    this.disposed = true;
+  }
 }
 
 const ANSI_REGEX = /\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+const ANSI_SEQUENCE_AT_START = /^\x1b\[[0-?]*[ -/]*[@-~]/u;
+const COMMAND_TOKEN_PATTERN = /(^|[ \t])(\/[A-Za-z0-9:_-]*)/gu;
+
+function controlSequenceAt(text: string, index: number): string | undefined {
+  if (text.startsWith(CURSOR_MARKER, index)) return CURSOR_MARKER;
+  return text.slice(index).match(ANSI_SEQUENCE_AT_START)?.[0];
+}
+
+interface CommandToken {
+  text: string;
+  start: number;
+  end: number;
+  valid: boolean;
+}
+
+interface EditorVisualLine {
+  logicalLine: number;
+  startCol: number;
+  length: number;
+}
+
+function commandTokens(text: string, normalizedNames: readonly string[]): CommandToken[] {
+  return [...text.matchAll(COMMAND_TOKEN_PATTERN)].map((match) => {
+    const token = match[2] ?? "";
+    const prefix = token.slice(1).toLocaleLowerCase();
+    const start = (match.index ?? 0) + (match[1]?.length ?? 0);
+    return {
+      text: token,
+      start,
+      end: start + token.length,
+      valid: normalizedNames.some((name) => name.startsWith(prefix)),
+    };
+  });
+}
+
+function highlightTextRanges(
+  text: string,
+  ranges: Array<{ start: number; end: number }>,
+  color: (value: string) => string,
+): string {
+  if (ranges.length === 0) return text;
+
+  let output = "";
+  let buffer = "";
+  let bufferHighlighted: boolean | undefined;
+  let plainIndex = 0;
+  const flush = (): void => {
+    if (!buffer) return;
+    output += bufferHighlighted ? color(buffer) : buffer;
+    buffer = "";
+  };
+
+  for (let index = 0; index < text.length;) {
+    const control = controlSequenceAt(text, index);
+    if (control) {
+      flush();
+      output += control;
+      index += control.length;
+      continue;
+    }
+
+    const highlighted = ranges.some((range) => plainIndex >= range.start && plainIndex < range.end);
+    if (bufferHighlighted !== highlighted) {
+      flush();
+      bufferHighlighted = highlighted;
+    }
+    buffer += text[index];
+    plainIndex += 1;
+    index += 1;
+  }
+  flush();
+  return output;
+}
+
+function highlightEditorLines(
+  lines: string[],
+  sourceLines: string[],
+  visualLines: EditorVisualLine[],
+  scrollOffset: number,
+  commandNames: ReadonlySet<string>,
+  color: (value: string) => string,
+): { lines: string[]; bottomBorderIndex: number } {
+  let bottomBorderIndex = -1;
+  for (let index = lines.length - 1; index >= 1; index -= 1) {
+    if (isBorderLine(lines[index] ?? "")) {
+      bottomBorderIndex = index;
+      break;
+    }
+  }
+  if (bottomBorderIndex < 0) bottomBorderIndex = lines.length - 1;
+
+  const normalizedNames = [...commandNames].map((name) => name.toLocaleLowerCase());
+  for (let index = 1; index < bottomBorderIndex; index += 1) {
+    const visualLine = visualLines[scrollOffset + index - 1];
+    if (!visualLine) continue;
+    const visibleStart = visualLine.startCol;
+    const visibleEnd = visibleStart + visualLine.length;
+    const ranges = commandTokens(sourceLines[visualLine.logicalLine] ?? "", normalizedNames)
+      .filter((token) => token.valid && token.start < visibleEnd && token.end > visibleStart)
+      .map((token) => ({
+        start: Math.max(token.start, visibleStart) - visibleStart,
+        end: Math.min(token.end, visibleEnd) - visibleStart,
+      }));
+    lines[index] = highlightTextRanges(lines[index] ?? "", ranges, color);
+  }
+  return { lines, bottomBorderIndex };
+}
 
 function stripAnsi(text: string): string {
   return text.replace(ANSI_REGEX, "").trim();
@@ -145,12 +267,27 @@ function isBorderLine(line: string): boolean {
   return /^[─━═]+$/.test(unstyled) || /^───\s*[↓↑]/.test(unstyled) || /^─{3,}/.test(unstyled);
 }
 
+function isScrolledTopBorder(line: string): boolean {
+  const unstyled = stripAnsi(line);
+  return unstyled.includes("↑") || unstyled.includes(".");
+}
+
 class PiCodeEditor extends CustomEditor {
   private readonly appKeybindings: KeybindingsManager;
-
-  constructor(tui: TUI, theme: EditorTheme, appKeybindings: KeybindingsManager) {
+  private readonly runtimeTheme: Theme;
+  private readonly getCommandNames: () => ReadonlySet<string>;
+
+  constructor(
+    tui: TUI,
+    theme: EditorTheme,
+    appKeybindings: KeybindingsManager,
+    runtimeTheme: Theme,
+    getCommandNames: () => ReadonlySet<string>,
+  ) {
     super(tui, theme, appKeybindings);
     this.appKeybindings = appKeybindings;
+    this.runtimeTheme = runtimeTheme;
+    this.getCommandNames = getCommandNames;
   }
 
   override handleInput(data: string): void {
@@ -167,25 +304,42 @@ class PiCodeEditor extends CustomEditor {
     super.handleInput(data);
   }
 
+  private renderWithCommandHighlighting(
+    width: number,
+    color: (value: string) => string,
+  ): { lines: string[]; bottomBorderIndex: number } {
+    const lines = super.render(width);
+    const internals = this as unknown as {
+      lastWidth: number;
+      scrollOffset: number;
+      buildVisualLineMap: (layoutWidth: number) => EditorVisualLine[];
+    };
+    return highlightEditorLines(
+      lines,
+      this.getLines(),
+      internals.buildVisualLineMap(internals.lastWidth),
+      internals.scrollOffset,
+      this.getCommandNames(),
+      color,
+    );
+  }
+
   override render(width: number): string[] {
-    if (width < 4) return super.render(width);
+    if (width <= 0) return [];
+    const colorCommand = (value: string): string => this.runtimeTheme.fg("mdLink", value);
+    if (width < 4) {
+      return this.renderWithCommandHighlighting(width, colorCommand)
+        .lines.map((line) => truncateToWidth(line, width, ""));
+    }
     const innerWidth = width - 2;
-    const lines = super.render(innerWidth);
+    const highlighted = this.renderWithCommandHighlighting(innerWidth, colorCommand);
+    const { lines, bottomBorderIndex } = highlighted;
     if (lines.length < 2) return lines.map((line) => truncateToWidth(line, width, ""));
 
-    const gray = (text: string): string => `\x1B[90m${text}\x1B[39m`;
-    let bottomBorderIndex = -1;
-    for (let index = lines.length - 1; index >= 1; index -= 1) {
-      if (isBorderLine(lines[index] ?? "")) {
-        bottomBorderIndex = index;
-        break;
-      }
-    }
-    if (bottomBorderIndex < 0) bottomBorderIndex = lines.length - 1;
-
+    const gray = (text: string): string => this.runtimeTheme.fg("dim", text);
     const framed: string[] = [];
     const top = stripAnsi(lines[0] ?? "");
-    const isScrolledHeader = top.includes("↑");
+    const isScrolledHeader = isScrolledTopBorder(lines[0] ?? "");
     if (isScrolledHeader) {
       const count = top.match(/↑\s*(\d+)/)?.[1] ?? "";
       const indicator = `${gray("─── ↑ ")}${count}${gray(" more ")}${gray("─".repeat(Math.max(0, width - 12 - count.length)))}`;
@@ -215,38 +369,66 @@ class PiCodeEditor extends CustomEditor {
   }
 }
 
+const ACTIVITY_FRAMES = [
+  "·", "✢", "✱", "✶", "✻", "✽",
+  "✽", "✻", "✶", "✱", "✢", "·",
+] as const;
+const ACTIVITY_FRAME_INTERVAL_MS = 120;
 const ACTIVITY_WORDS = ["Brewing", "Pondering", "Tinkering", "Wrangling", "Noodling", "Cooking"] as const;
 
+function formatActivityMessage(word: string, theme: Theme): string {
+  return `${theme.fg("accent", `${word}…`)} ${theme.fg("dim", `(${theme.bold("esc")} to interrupt · thinking)`)}`;
+}
+
 export function registerShellUi(pi: ExtensionAPI): void {
   let activeHeader: PiStartupHeader | undefined;
-  let activityWordIndex = 0;
+  let activityDeck: string[] = [];
+  let lastActivityWord: string | undefined;
+  let activityTimer: ReturnType<typeof setInterval> | undefined;
   let tipDeck: string[] = [];
   const nextStartupTip = (): string => {
     if (tipDeck.length === 0) tipDeck = shuffledTips();
     return tipDeck.pop() ?? STARTUP_TIPS[0];
   };
+  const refillActivityDeck = (): void => {
+    activityDeck = [...ACTIVITY_WORDS];
+    for (let index = activityDeck.length - 1; index > 0; index -= 1) {
+      const swapIndex = Math.floor(Math.random() * (index + 1));
+      [activityDeck[index], activityDeck[swapIndex]] = [activityDeck[swapIndex]!, activityDeck[index]!];
+    }
+    if (activityDeck.length > 1 && activityDeck.at(-1) === lastActivityWord) {
+      [activityDeck[0], activityDeck[activityDeck.length - 1]] = [activityDeck.at(-1)!, activityDeck[0]!];
+    }
+  };
+  const nextActivityWord = (): string => {
+    if (activityDeck.length === 0) refillActivityDeck();
+    const word = activityDeck.pop() ?? ACTIVITY_WORDS[0];
+    lastActivityWord = word;
+    return word;
+  };
+  const clearActivityTimer = (): void => {
+    if (activityTimer) clearInterval(activityTimer);
+    activityTimer = undefined;
+  };
 
   pi.on("session_start", (_event, ctx) => {
     if (ctx.mode !== "tui") return;
     try {
       ctx.ui.setTheme("killeros");
       const startupTip = nextStartupTip();
-      ctx.ui.setHeader(() => {
+      ctx.ui.setHeader((tui) => {
         activeHeader?.dispose();
-        activeHeader = new PiStartupHeader(pi, ctx, startupTip);
+        activeHeader = new PiStartupHeader(pi, ctx, startupTip, tui);
         return activeHeader;
       });
+      clearActivityTimer();
       ctx.ui.setWorkingIndicator({
-        frames: [
-          ctx.ui.theme.fg("dim", "✻"),
-          ctx.ui.theme.fg("muted", "✻"),
-          ctx.ui.theme.fg("accent", "✻"),
-          ctx.ui.theme.fg("muted", "✻"),
-        ],
-        intervalMs: 180,
+        frames: ACTIVITY_FRAMES.map((frame) => ctx.ui.theme.fg("accent", frame)),
+        intervalMs: ACTIVITY_FRAME_INTERVAL_MS,
       });
       ctx.ui.setHiddenThinkingLabel("└ Thinking…");
-      ctx.ui.setEditorComponent((tui, theme, keybindings) => new PiCodeEditor(tui, theme, keybindings));
+      ctx.ui.setEditorComponent((tui, editorTheme, keybindings) =>
+        new PiCodeEditor(tui, editorTheme, keybindings, ctx.ui.theme, () => availableCommandNames(pi)));
     } catch (error) {
       reportError(ctx, "Killeros UI failed to initialize", error);
     }
@@ -254,17 +436,23 @@ export function registerShellUi(pi: ExtensionAPI): void {
 
   pi.on("agent_start", (_event, ctx) => {
     if (ctx.mode !== "tui") return;
-    ctx.ui.setWorkingMessage(`${ACTIVITY_WORDS[activityWordIndex]}…`);
-    activityWordIndex = (activityWordIndex + 1) % ACTIVITY_WORDS.length;
+    clearActivityTimer();
+    const updateWorkingWord = (): void => ctx.ui.setWorkingMessage(formatActivityMessage(nextActivityWord(), ctx.ui.theme));
+    updateWorkingWord();
+    activityTimer = setInterval(updateWorkingWord, 2_500);
+    activityTimer.unref?.();
   });
 
   pi.on("agent_end", (_event, ctx) => {
+    clearActivityTimer();
     if (ctx.mode === "tui") ctx.ui.setWorkingMessage();
   });
 
   pi.on("session_shutdown", () => {
+    clearActivityTimer();
     activeHeader?.dispose();
     activeHeader = undefined;
-    activityWordIndex = 0;
+    activityDeck = [];
+    lastActivityWord = undefined;
   });
 }

package/killeros/variants.ts

@@ -1,4 +1,4 @@
-import { DynamicBorder, type ExtensionAPI, type ExtensionContext, type ThemeColor } from "@earendil-works/pi-coding-agent";
+import { DynamicBorder, keyHint, type ExtensionAPI, type ExtensionContext, type ThemeColor } from "@earendil-works/pi-coding-agent";
 import { Container, SelectList, Text, truncateToWidth } from "@earendil-works/pi-tui";
 
 export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
@@ -119,7 +119,11 @@ export function registerVariants(pi: ExtensionAPI): void {
         selectList.onCancel = () => done(null);
         container.addChild(selectList);
         container.addChild(new Text("", 0, 0));
-        container.addChild(new Text(theme.fg("dim", "↑↓ navigate • Enter select • Esc cancel"), 1, 0));
+        container.addChild(new Text(
+          theme.fg("dim", `${keyHint("tui.select.up", "up")} • ${keyHint("tui.select.down", "down")} • ${keyHint("tui.select.confirm", "select")} • ${keyHint("tui.select.cancel", "cancel")}`),
+          1,
+          0,
+        ));
         container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
         return {
           render: (width) => container.render(width).map((line) => truncateToWidth(line, width, "")),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "killeros",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "A production-hardened TUI and workflow extension for the Pi coding agent.",
   "type": "module",
   "keywords": [

package/themes/killeros.json

@@ -4,6 +4,7 @@
   "vars": {
     "coral": "#d77757",
     "coralBright": "#e58b6d",
+    "commandBlue": "#78a9ff",
     "canvas": "#0a0a0a",
     "surface": "#121212",
     "surfaceRaised": "#1a1a1a",
@@ -43,7 +44,7 @@
     "toolOutput": "muted",
 
     "mdHeading": "coralBright",
-    "mdLink": "coralBright",
+    "mdLink": "commandBlue",
     "mdLinkUrl": "dim",
     "mdCode": "coralBright",
     "mdCodeBlock": "text",
@@ -68,8 +69,8 @@
     "syntaxPunctuation": "muted",
 
     "thinkingOff": "dim",
-    "thinkingMinimal": "#78685f",
-    "thinkingLow": "#98705f",
+    "thinkingMinimal": "#927f74",
+    "thinkingLow": "#a27b6a",
     "thinkingMedium": "#b27762",
     "thinkingHigh": "coral",
     "thinkingXhigh": "#d58272",