@mrclrchtr/supi-extras 1.3.1 → 1.5.0

package/README.md

@@ -1,44 +1,79 @@
 # @mrclrchtr/supi-extras
 
-Small fixes for PI — the papercuts you didn't know you had, removed.
+Adds a bundle of small quality-of-life features to the [pi coding agent](https://github.com/earendil-works/pi).
 
-Command aliases so you type less. A prompt stash so you never lose a draft. A tab spinner so you know when the agent is working. Each one is tiny. Together they make sessions feel smoother.
+## Install
+
+```bash
+pi install npm:@mrclrchtr/supi-extras
+```
+
+For local development:
+
+```bash
+pi install ./packages/supi-extras
+```
+
+After editing the source, run `/reload`.
 
 ## What you get
 
-### Fewer keystrokes
+This package mixes a few commands and shortcuts with a few always-on UI tweaks.
 
-`/exit`, `/e`, `/clear` — muscle-memory shortcuts. `$skill-name` expands to `/skill:skill-name` automatically. Less typing, more doing.
+## Commands
 
-### Never lose a draft
+- `/exit` — exit pi
+- `/e` — alias for `/exit`
+- `/clear` — start a new session (alias for `/new`)
+- `/supi-stash` — browse, restore, copy, delete, or clear saved prompt drafts
 
-`Alt+S` stashes your current prompt. `Alt+C` copies it to clipboard. `/supi-stash` opens a keyboard-driven overlay to browse, restore, or delete saved drafts. Stashes survive restarts.
+## Shortcuts
 
-### Know when the agent is working
+- `Alt+S` — stash the current editor text
+- `Alt+C` — copy the current editor text to the system clipboard
+- `$skill-name` — input shorthand that expands to `/skill:skill-name`
 
-A braille spinner in the terminal tab title while work is in progress. Glance at the tab — if it's spinning, the agent hasn't finished.
+The `$skill-name` helper also adds skill-only autocomplete while the cursor is inside a `$...` token.
 
-### No hung editors
+## Prompt stash
 
-Sets `GIT_EDITOR=true` so git never blocks on an interactive editor. Pi runs headless — editor invocations hang. This prevents that.
+Prompt stash stores drafts in `~/.pi/agent/supi/prompt-stash.json` so they survive restarts.
 
-## Install
+`/supi-stash` opens an overlay with these actions:
 
-```bash
-pi install npm:@mrclrchtr/supi-extras
-```
+- `Enter` — restore the selected draft into the editor
+- `c` — copy the selected draft to the clipboard
+- `d` — delete the selected draft
+- `D` — clear all drafts
+- `Esc` — close the overlay
+
+If the stash file cannot be read or written, the feature degrades to in-memory use instead of breaking the extension.
+
+## Passive behavior
+
+### Tab-title spinner
+
+While the agent is working, the package animates a spinner in the terminal tab title. When the turn finishes, it shows a done marker. If `ask_user` is active, the spinner pauses so the waiting-for-input title is not overwritten.
+
+### Footer model and effort colors
+
+The footer keeps pi's existing information but recolors the active model and reasoning level using theme tokens.
+
+### Headless git safety
+
+The package sets:
 
-## Stash overlay
+- `GIT_EDITOR=true`
+- `GIT_SEQUENCE_EDITOR=true`
 
-`/supi-stash` opens an overlay in your terminal:
+That prevents git subprocesses from hanging while waiting for an interactive editor.
 
-| Key | Action |
-|-----|--------|
-| `↑↓` | Navigate stashed drafts |
-| `Enter` | Restore selected draft to editor |
-| `c` | Copy to clipboard |
-| `d` | Delete (list refreshes in-place) |
-| `D` | Clear all stashes |
-| `Esc` | Cancel |
+## Source
 
-Stashes persist to `~/.pi/agent/supi/prompt-stash.json` across restarts.
+- `src/aliases.ts` — command aliases
+- `src/prompt-stash.ts` — prompt stash shortcuts, persistence, and overlay
+- `src/skill-shortcut.ts` — `$skill-name` expansion and autocomplete
+- `src/tab-spinner.ts` — terminal tab-title spinner
+- `src/copy-prompt.ts` and `src/clipboard.ts` — copy-to-clipboard shortcut and helper
+- `src/model-effort-colors.ts` — footer recoloring
+- `src/git-editor.ts` — git editor environment guard

package/node_modules/@mrclrchtr/supi-core/README.md

@@ -1,65 +1,78 @@
 # @mrclrchtr/supi-core
 
-Shared infrastructure for SuPi packages.
+Shared infrastructure for SuPi extensions.
+
+This package is mainly for extension authors. It gives you a common config system, settings plumbing, context helpers, registries, and a small extension surface that registers `/supi-settings`.
 
 ## Install
 
-Use it as a dependency in another extension package:
+### As a dependency for another extension
 
 ```bash
 pnpm add @mrclrchtr/supi-core
 ```
 
-## Package role
-
-`@mrclrchtr/supi-core` now has two explicit surfaces:
+### As a pi package
 
-- `@mrclrchtr/supi-core/api` — shared library helpers for other SuPi packages
-- `@mrclrchtr/supi-core/extension` — a minimal pi extension that registers `/supi-settings`
-
-`pi.extensions` still points at the real file path `./src/extension.ts` inside the package. The `/api` and `/extension` paths are consumer-facing package exports, not manifest aliases.
+```bash
+pi install npm:@mrclrchtr/supi-core
+```
 
-## What it provides
+Installing it as a pi package adds the minimal `/supi-settings` extension surface.
 
-Current exports cover:
+## Package surfaces
 
-- shared config loading, scoped reads, writes, and key removal
-- config-backed settings registration helpers for `/supi-settings`
-- the shared settings registry, overlay UI, and `registerSettingsCommand()` helper
-- XML `<extension-context>` wrapping plus context-message utilities
-- context-provider and debug-event registries reused across SuPi packages
-- project root and path helpers reused by packages such as `supi-lsp`
+- `@mrclrchtr/supi-core/api` — reusable helpers for other packages and extensions
+- `@mrclrchtr/supi-core/extension` — minimal pi extension that registers `/supi-settings`
 
-## Config system
+## What you get from the API
 
-Config resolution order:
+### Config helpers
 
-```text
-defaults <- global <- project
-```
+- `loadSupiConfig()` — merged config with resolution order `defaults <- global <- project`
+- `loadSupiConfigForScope()` — load one scope at a time for settings UIs
+- `writeSupiConfig()` — persist values
+- `removeSupiConfigKey()` — remove a key or override
 
 Config file locations:
 
 - global: `~/.pi/agent/supi/config.json`
 - project: `.pi/supi/config.json`
 
-Main helpers:
+### Settings helpers
+
+- `registerSettings()` — register an arbitrary settings section
+- `registerConfigSettings()` — register a config-backed settings section with scoped persistence helpers
+- `registerSettingsCommand()` — register `/supi-settings`
+- `openSettingsOverlay()` — open the shared settings UI directly
+- `createInputSubmenu()` — helper for simple text-entry submenus
+
+The built-in settings UI supports:
 
-- `loadSupiConfig()` — effective merged config (`defaults <- global <- project`)
-- `loadSupiConfigForScope()` — raw single-scope config for settings UIs (`defaults <- selected scope`)
-- `writeSupiConfig()`
-- `removeSupiConfigKey()`
-- `registerConfigSettings()`
+- project/global scope toggle
+- grouped extension sections
+- searchable setting lists
 
-## Context and settings helpers
+### Context helpers
 
-- `wrapExtensionContext()`
+- `wrapExtensionContext()` — wrap injected text in SuPi's `<extension-context>` tag
 - `findLastUserMessageIndex()`
 - `getContextToken()`
+- `getPromptContent()`
 - `pruneAndReorderContextMessages()`
-- `registerSettings()`
-- `registerSettingsCommand()`
-- `openSettingsOverlay()`
+- `restorePromptContent()`
+
+### Shared registries
+
+- context-provider registry for `/supi-context`
+- debug-event registry for producers that want shared debug capture
+- settings registry used by `/supi-settings`
+
+### Project and session helpers
+
+- project-root detection and directory walking helpers such as `findProjectRoot()` and `walkProject()`
+- active-branch session helper: `getActiveBranchEntries()`
+- terminal helpers such as `formatTitle()`, `signalWaiting()`, and `signalDone()`
 
 ## Example
 
@@ -80,17 +93,15 @@ registerConfigSettings({
 });
 
 const message = wrapExtensionContext("my-extension", "hello", {
-  turn: 1,
   file: "CLAUDE.md",
+  turn: 1,
 });
 ```
 
-## Requirements
-
-- `@earendil-works/pi-coding-agent`
-- `@earendil-works/pi-tui`
-
 ## Source
 
-- Library surface: `src/api.ts`
-- Extension surface: `src/extension.ts`
+- `src/api.ts` — exported library surface
+- `src/extension.ts` — minimal `/supi-settings` entrypoint
+- `src/config.ts` — shared config loading and writing
+- `src/config-settings.ts` — config-backed settings registration helper
+- `src/settings-ui.ts` — shared settings overlay

package/node_modules/@mrclrchtr/supi-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-core",
-  "version": "1.3.1",
+  "version": "1.5.0",
   "description": "SuPi core — shared infrastructure for SuPi extensions (XML context tags, config system)",
   "license": "MIT",
   "repository": {

package/node_modules/@mrclrchtr/supi-core/src/api.ts

@@ -2,30 +2,30 @@
 // Provides XML context tag wrapping, unified config system, context-message utilities,
 // and settings registry for supi-wide TUI settings.
 
-export type { SupiConfigLocation, SupiConfigOptions } from "./config.ts";
+export type { SupiConfigLocation, SupiConfigOptions } from "./config/config.ts";
 export {
   loadSupiConfig,
   loadSupiConfigForScope,
   removeSupiConfigKey,
   writeSupiConfig,
-} from "./config.ts";
-export type { ConfigSettingsHelpers, ConfigSettingsOptions } from "./config-settings.ts";
-export { registerConfigSettings } from "./config-settings.ts";
-export type { ContextMessageLike } from "./context-messages.ts";
+} from "./config/config.ts";
+export type { ConfigSettingsHelpers, ConfigSettingsOptions } from "./config/config-settings.ts";
+export { registerConfigSettings } from "./config/config-settings.ts";
+export type { ContextMessageLike } from "./context/context-messages.ts";
 export {
   findLastUserMessageIndex,
   getContextToken,
   getPromptContent,
   pruneAndReorderContextMessages,
   restorePromptContent,
-} from "./context-messages.ts";
-export type { ContextProvider } from "./context-provider-registry.ts";
+} from "./context/context-messages.ts";
+export type { ContextProvider } from "./context/context-provider-registry.ts";
 export {
   clearRegisteredContextProviders,
   getRegisteredContextProviders,
   registerContextProvider,
-} from "./context-provider-registry.ts";
-export { wrapExtensionContext } from "./context-tag.ts";
+} from "./context/context-provider-registry.ts";
+export { wrapExtensionContext } from "./context/context-tag.ts";
 export type {
   DebugAgentAccess,
   DebugEvent,
@@ -49,6 +49,7 @@ export {
   redactDebugData,
   resetDebugRegistry,
 } from "./debug-registry.ts";
+export { fileToUri, resolveToolPath, stripToolPathPrefix, uriToFile } from "./path-utils.ts";
 export type { KnownRootEntry } from "./project-roots.ts";
 export {
   buildKnownRootsMap,
@@ -63,15 +64,16 @@ export {
   sortRootsBySpecificity,
   walkProject,
 } from "./project-roots.ts";
+export { createRegistry, createSessionStateRegistry } from "./registry-utils.ts";
 export { getActiveBranchEntries } from "./session-utils.ts";
-export { registerSettingsCommand } from "./settings-command.ts";
-export type { SettingsScope, SettingsSection } from "./settings-registry.ts";
+export { registerSettingsCommand } from "./settings/settings-command.ts";
+export type { SettingsScope, SettingsSection } from "./settings/settings-registry.ts";
 export {
   clearRegisteredSettings,
   getRegisteredSettings,
   registerSettings,
-} from "./settings-registry.ts";
-export { createInputSubmenu, openSettingsOverlay } from "./settings-ui.ts";
+} from "./settings/settings-registry.ts";
+export { createInputSubmenu, openSettingsOverlay } from "./settings/settings-ui.ts";
 export type { TitleTarget } from "./terminal.ts";
 export {
   DONE_SYMBOL,

package/node_modules/@mrclrchtr/supi-core/src/{config-settings.ts → config/config-settings.ts}

@@ -2,9 +2,9 @@
 // Wraps registerSettings() and centralizes selected-scope loading + scoped persistence.
 
 import type { SettingItem } from "@earendil-works/pi-tui";
+import type { SettingsScope } from "../settings/settings-registry.ts";
+import { registerSettings } from "../settings/settings-registry.ts";
 import { loadSupiConfigForScope, removeSupiConfigKey, writeSupiConfig } from "./config.ts";
-import type { SettingsScope } from "./settings-registry.ts";
-import { registerSettings } from "./settings-registry.ts";
 
 export interface ConfigSettingsHelpers {
   /** Write a key to the selected scope's config section. */

package/node_modules/@mrclrchtr/supi-core/src/{context-provider-registry.ts → context/context-provider-registry.ts}

@@ -3,7 +3,7 @@
 // Extensions declare context data providers via `registerContextProvider()` during their
 // factory function. The `/supi-context` command reads them via `getRegisteredContextProviders()`.
 
-import { createRegistry } from "./registry-utils.ts";
+import { createRegistry } from "../registry-utils.ts";
 
 export interface ContextProvider {
   /** Unique identifier — e.g. "rtk" */

package/node_modules/@mrclrchtr/supi-core/src/extension.ts

@@ -1 +1 @@
-export { registerSettingsCommand as default } from "./settings-command.ts";
+export { registerSettingsCommand as default } from "./settings/settings-command.ts";

package/node_modules/@mrclrchtr/supi-core/src/index.ts

@@ -2,30 +2,30 @@
 // Provides XML context tag wrapping, unified config system, context-message utilities,
 // and settings registry for supi-wide TUI settings.
 
-export type { SupiConfigLocation, SupiConfigOptions } from "./config.ts";
+export type { SupiConfigLocation, SupiConfigOptions } from "./config/config.ts";
 export {
   loadSupiConfig,
   loadSupiConfigForScope,
   removeSupiConfigKey,
   writeSupiConfig,
-} from "./config.ts";
-export type { ConfigSettingsHelpers, ConfigSettingsOptions } from "./config-settings.ts";
-export { registerConfigSettings } from "./config-settings.ts";
-export type { ContextMessageLike } from "./context-messages.ts";
+} from "./config/config.ts";
+export type { ConfigSettingsHelpers, ConfigSettingsOptions } from "./config/config-settings.ts";
+export { registerConfigSettings } from "./config/config-settings.ts";
+export type { ContextMessageLike } from "./context/context-messages.ts";
 export {
   findLastUserMessageIndex,
   getContextToken,
   getPromptContent,
   pruneAndReorderContextMessages,
   restorePromptContent,
-} from "./context-messages.ts";
-export type { ContextProvider } from "./context-provider-registry.ts";
+} from "./context/context-messages.ts";
+export type { ContextProvider } from "./context/context-provider-registry.ts";
 export {
   clearRegisteredContextProviders,
   getRegisteredContextProviders,
   registerContextProvider,
-} from "./context-provider-registry.ts";
-export { wrapExtensionContext } from "./context-tag.ts";
+} from "./context/context-provider-registry.ts";
+export { wrapExtensionContext } from "./context/context-tag.ts";
 export type {
   DebugAgentAccess,
   DebugEvent,
@@ -49,6 +49,7 @@ export {
   redactDebugData,
   resetDebugRegistry,
 } from "./debug-registry.ts";
+export { fileToUri, resolveToolPath, stripToolPathPrefix, uriToFile } from "./path-utils.ts";
 export type { KnownRootEntry } from "./project-roots.ts";
 export {
   buildKnownRootsMap,
@@ -63,15 +64,16 @@ export {
   sortRootsBySpecificity,
   walkProject,
 } from "./project-roots.ts";
+export { createRegistry, createSessionStateRegistry } from "./registry-utils.ts";
 export { getActiveBranchEntries } from "./session-utils.ts";
-export { registerSettingsCommand } from "./settings-command.ts";
-export type { SettingsScope, SettingsSection } from "./settings-registry.ts";
+export { registerSettingsCommand } from "./settings/settings-command.ts";
+export type { SettingsScope, SettingsSection } from "./settings/settings-registry.ts";
 export {
   clearRegisteredSettings,
   getRegisteredSettings,
   registerSettings,
-} from "./settings-registry.ts";
-export { createInputSubmenu, openSettingsOverlay } from "./settings-ui.ts";
+} from "./settings/settings-registry.ts";
+export { createInputSubmenu, openSettingsOverlay } from "./settings/settings-ui.ts";
 export type { TitleTarget } from "./terminal.ts";
 export {
   DONE_SYMBOL,

package/node_modules/@mrclrchtr/supi-core/src/path-utils.ts

@@ -0,0 +1,40 @@
+import * as path from "node:path";
+
+/** Strip pi's optional leading `@` file-path prefix from a tool input. */
+export function stripToolPathPrefix(target: string): string {
+  return target.startsWith("@") ? target.slice(1) : target;
+}
+
+/**
+ * Resolve a tool-style file path from a session cwd.
+ *
+ * Built-in pi file tools accept a leading `@` prefix in path arguments, so
+ * shared SuPi path helpers normalize that prefix before resolving relative
+ * paths.
+ */
+export function resolveToolPath(cwd: string, target: string): string {
+  return path.resolve(cwd, stripToolPathPrefix(target));
+}
+
+/** Convert a file path to a file:// URI. */
+export function fileToUri(filePath: string): string {
+  const resolved = path.resolve(filePath);
+  if (process.platform === "win32") {
+    return `file:///${resolved.replace(/\\/g, "/")}`;
+  }
+  return `file://${resolved}`;
+}
+
+/** Convert a file:// URI to a file path. */
+export function uriToFile(uri: string): string {
+  if (!uri.startsWith("file://")) return uri;
+  let filePath = decodeURIComponent(uri.slice(7));
+  if (
+    process.platform === "win32" &&
+    filePath.startsWith("/") &&
+    /^[A-Za-z]:/.test(filePath.slice(1))
+  ) {
+    filePath = filePath.slice(1);
+  }
+  return filePath;
+}

package/node_modules/@mrclrchtr/supi-core/src/registry-utils.ts

@@ -5,8 +5,20 @@
 // Without this, each symlink path gets its own module copy and its own Map,
 // so registrations from one instance are invisible to consumers in another.
 
+import * as path from "node:path";
+
 const SYMBOL_PREFIX = "@mrclrchtr/supi-core/";
 
+function getGlobalRegistryMap<T>(name: string): Map<string, T> {
+  const key = Symbol.for(SYMBOL_PREFIX + name);
+  let map = (globalThis as Record<symbol, unknown>)[key] as Map<string, T> | undefined;
+  if (!map) {
+    map = new Map<string, T>();
+    (globalThis as Record<symbol, unknown>)[key] = map;
+  }
+  return map;
+}
+
 /**
  * Create a named registry backed by `globalThis` + `Symbol.for`.
  *
@@ -18,16 +30,7 @@ const SYMBOL_PREFIX = "@mrclrchtr/supi-core/";
  * @returns An object with `register`, `getAll`, and `clear` functions.
  */
 export function createRegistry<T>(name: string) {
-  const key = Symbol.for(SYMBOL_PREFIX + name);
-
-  const getMap = (): Map<string, T> => {
-    let map = (globalThis as Record<symbol, unknown>)[key] as Map<string, T> | undefined;
-    if (!map) {
-      map = new Map<string, T>();
-      (globalThis as Record<symbol, unknown>)[key] = map;
-    }
-    return map;
-  };
+  const getMap = (): Map<string, T> => getGlobalRegistryMap<T>(name);
 
   return {
     /**
@@ -52,3 +55,32 @@ export function createRegistry<T>(name: string) {
     },
   };
 }
+
+/**
+ * Create a named session-state registry keyed by normalized cwd.
+ *
+ * This helper is intended for session-scoped runtime services that should be
+ * shared across duplicate jiti module instances while keeping package-specific
+ * state unions and convenience wrappers local to the calling package.
+ */
+export function createSessionStateRegistry<TState>(name: string) {
+  const getMap = (): Map<string, TState> => getGlobalRegistryMap<TState>(name);
+  const normalizeCwd = (cwd: string): string => path.resolve(cwd);
+
+  return {
+    /** Get the current state for one session cwd. */
+    get: (cwd: string): TState | undefined => {
+      return getMap().get(normalizeCwd(cwd));
+    },
+
+    /** Store the current state for one session cwd. */
+    set: (cwd: string, state: TState): void => {
+      getMap().set(normalizeCwd(cwd), state);
+    },
+
+    /** Clear the current state for one session cwd. */
+    clear: (cwd: string): void => {
+      getMap().delete(normalizeCwd(cwd));
+    },
+  };
+}

package/node_modules/@mrclrchtr/supi-core/src/{settings-registry.ts → settings/settings-registry.ts}

@@ -4,7 +4,7 @@
 // factory function. The generic settings UI reads them via `getRegisteredSettings()`.
 
 import type { SettingItem } from "@earendil-works/pi-tui";
-import { createRegistry } from "./registry-utils.ts";
+import { createRegistry } from "../registry-utils.ts";
 
 export type SettingsScope = "project" | "global";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-extras",
-  "version": "1.3.1",
+  "version": "1.5.0",
   "description": "SuPi extras — command aliases, skill shorthand, tab spinner, /supi-stash prompt stash with TUI overlay, and other small utilities",
   "license": "MIT",
   "repository": {
@@ -21,7 +21,7 @@
   ],
   "dependencies": {
     "clipboardy": "^5.3.1",
-    "@mrclrchtr/supi-core": "1.3.1"
+    "@mrclrchtr/supi-core": "1.5.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-core"

package/src/index.ts

@@ -1,6 +1,7 @@
 import aliases from "./aliases.ts";
 import copyPrompt from "./copy-prompt.ts";
 import gitEditor from "./git-editor.ts";
+import modelEffortColors from "./model-effort-colors.ts";
 import promptStash from "./prompt-stash.ts";
 import skillShortcut from "./skill-shortcut.ts";
 import tabSpinner from "./tab-spinner.ts";
@@ -12,4 +13,5 @@ export default function (pi: Parameters<typeof tabSpinner>[0]) {
   gitEditor(pi);
   aliases(pi);
   skillShortcut(pi);
+  modelEffortColors(pi);
 }

package/src/model-effort-colors-helpers.ts

@@ -0,0 +1,277 @@
+/**
+ * Pure helpers for model-effort-colors extension.
+ * Extracted to keep the extension entrypoint under complexity / line-count limits.
+ */
+import type { ThemeColor } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+
+// ---- re-exports for the extension entrypoint ----
+
+export type ModelInfo = {
+  id?: string;
+  provider?: string;
+  reasoning?: boolean;
+  contextWindow?: number;
+};
+
+export interface UsageEntry {
+  type: string;
+  message?: {
+    role: string;
+    usage: {
+      input: number;
+      output: number;
+      cacheRead?: number;
+      cacheWrite?: number;
+      cost: { total: number };
+    };
+  };
+}
+
+export interface UsageTotals {
+  totalInput: number;
+  totalOutput: number;
+  totalCacheRead: number;
+  totalCacheWrite: number;
+  totalCost: number;
+}
+
+export interface FooterTheme {
+  fg(color: ThemeColor, text: string): string;
+}
+
+export interface FooterData {
+  getGitBranch(): string | null;
+  getExtensionStatuses(): ReadonlyMap<string, string>;
+  onBranchChange(cb: () => void): () => void;
+}
+
+// ---- color mappings ----
+
+const PROVIDER_PATTERNS: Array<[RegExp, ThemeColor]> = [
+  [/anthropic|claude/, "accent"],
+  [/openai|gpt|chatgpt/, "success"],
+  [/google|gemini/, "warning"],
+  [/mistral|codestral/, "muted"],
+  [/xai|grok/, "thinkingXhigh"],
+  [/deepseek/, "thinkingHigh"],
+  [/meta|llama/, "thinkingMedium"],
+  [/ollama|local/, "dim"],
+];
+
+export function providerThemeToken(provider: string | undefined): ThemeColor {
+  const haystack = String(provider ?? "").toLowerCase();
+  for (const [re, color] of PROVIDER_PATTERNS) {
+    if (re.test(haystack)) return color;
+  }
+  return "dim";
+}
+
+export function thinkingThemeToken(level: string): ThemeColor {
+  switch (level.toLowerCase()) {
+    case "off":
+      return "thinkingOff";
+    case "minimal":
+      return "thinkingMinimal";
+    case "low":
+      return "thinkingLow";
+    case "medium":
+      return "thinkingMedium";
+    case "high":
+      return "thinkingHigh";
+    case "xhigh":
+      return "thinkingXhigh";
+    default:
+      return "dim";
+  }
+}
+
+// ---- formatting helpers ----
+
+export function formatTokens(count: number): string {
+  if (count < 1000) return count.toString();
+  if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
+  if (count < 1_000_000) return `${Math.round(count / 1000)}k`;
+  if (count < 10_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
+  return `${Math.round(count / 1_000_000)}M`;
+}
+
+export function sanitizeStatusText(text: string): string {
+  return text
+    .replace(/[\r\n\t]/g, " ")
+    .replace(/ +/g, " ")
+    .trim();
+}
+
+// ---- usage aggregation ----
+
+/** Aggregate token/cost usage across all assistant messages. */
+export function gatherUsage(entries: ReadonlyArray<UsageEntry>): UsageTotals {
+  let totalInput = 0;
+  let totalOutput = 0;
+  let totalCacheRead = 0;
+  let totalCacheWrite = 0;
+  let totalCost = 0;
+
+  for (const entry of entries) {
+    if (entry.type === "message" && entry.message?.role === "assistant") {
+      const u = entry.message.usage;
+      totalInput += u.input;
+      totalOutput += u.output;
+      totalCacheRead += u.cacheRead ?? 0;
+      totalCacheWrite += u.cacheWrite ?? 0;
+      totalCost += u.cost.total;
+    }
+  }
+
+  return { totalInput, totalOutput, totalCacheRead, totalCacheWrite, totalCost };
+}
+
+// ---- stats builder ----
+
+/** Build the left-side stats string. */
+export function buildStatsLeft(params: {
+  contextWindow: number;
+  percent: number | null;
+  usage: UsageTotals;
+  useSubscription: boolean;
+}): { text: string; contextPercentValue: number } {
+  const { contextWindow, percent, usage, useSubscription } = params;
+  const { totalInput, totalOutput, totalCacheRead, totalCacheWrite, totalCost } = usage;
+
+  const contextPercentValue = percent ?? 0;
+  const contextPercent = percent != null ? percent.toFixed(1) : "?";
+
+  const parts: string[] = [];
+  if (totalInput) parts.push(`↑${formatTokens(totalInput)}`);
+  if (totalOutput) parts.push(`↓${formatTokens(totalOutput)}`);
+  if (totalCacheRead) parts.push(`R${formatTokens(totalCacheRead)}`);
+  if (totalCacheWrite) parts.push(`W${formatTokens(totalCacheWrite)}`);
+
+  if (totalCost || useSubscription) {
+    parts.push(`$${totalCost.toFixed(3)}${useSubscription ? " (sub)" : ""}`);
+  }
+
+  const ctxDisplay =
+    contextPercent === "?"
+      ? `?/${formatTokens(contextWindow)}`
+      : `${contextPercent}%/${formatTokens(contextWindow)}`;
+  parts.push(ctxDisplay);
+
+  return { text: parts.join(" "), contextPercentValue };
+}
+
+// ---- context-percent coloring ----
+
+/** Color the context-% portion based on thresholds. */
+export function colorContextPercent(statsLeft: string, pctVal: number, theme: FooterTheme): string {
+  if (pctVal > 90) {
+    return statsLeft.replace(/\d+\.?\d*%/, (m) => theme.fg("error", m));
+  }
+  if (pctVal > 70) {
+    return statsLeft.replace(/\d+\.?\d*%/, (m) => theme.fg("warning", m));
+  }
+  return statsLeft;
+}
+
+// ---- right-side builders ----
+
+/** Build the styled right portion (model name + effort level). */
+export function styleRightSide(params: {
+  model: ModelInfo | undefined;
+  thinkingLevel: string;
+  theme: FooterTheme;
+  statsLeftWidth: number;
+  availableWidth: number;
+}): { plain: string; styled: string } {
+  const { model, thinkingLevel, theme, statsLeftWidth, availableWidth } = params;
+
+  const modelName = model?.id ?? "no-model";
+  const effortLabel = thinkingLevel === "off" ? "thinking off" : thinkingLevel.toLowerCase();
+
+  let plain = modelName;
+  if (model?.reasoning) {
+    plain = `${modelName} • ${effortLabel}`;
+  }
+  if (model?.provider) {
+    const withProvider = `(${model.provider}) ${plain}`;
+    if (statsLeftWidth + 2 + visibleWidth(withProvider) <= availableWidth) {
+      plain = withProvider;
+    }
+  }
+
+  const providerToken = providerThemeToken(model?.provider);
+  const thinkingToken = thinkingThemeToken(thinkingLevel);
+  const providerPrefix = model?.provider ? `(${model.provider}) ` : "";
+
+  let styled = "";
+  if (providerPrefix) styled += theme.fg("dim", providerPrefix);
+  styled += theme.fg(providerToken, modelName);
+
+  if (model?.reasoning) {
+    styled += theme.fg("dim", " • ");
+    styled += theme.fg(thinkingToken, effortLabel);
+  }
+
+  return { plain, styled };
+}
+
+/** Apply right-justified padding between stats and right side. */
+export function layoutRightSide(params: {
+  plain: string;
+  styled: string;
+  statsLeftWidth: number;
+  availableWidth: number;
+}): { styled: string; padding: string } {
+  const { plain, styled, statsLeftWidth, availableWidth } = params;
+  const rightWidth = visibleWidth(plain);
+  const minPadding = 2;
+
+  if (statsLeftWidth + minPadding + rightWidth <= availableWidth) {
+    return { styled, padding: " ".repeat(availableWidth - statsLeftWidth - rightWidth) };
+  }
+
+  const avail = availableWidth - statsLeftWidth - minPadding;
+  if (avail <= 0) {
+    return { styled: "", padding: "" };
+  }
+
+  const finalStyled = truncateToWidth(styled, avail + (styled.length - plain.length), "");
+  const finalPlain = truncateToWidth(plain, avail, "");
+  const padding = " ".repeat(
+    Math.max(0, availableWidth - statsLeftWidth - visibleWidth(finalPlain)),
+  );
+  return { styled: finalStyled, padding };
+}
+
+// ---- path line ----
+
+/** Build the working-directory line for the footer. */
+export function buildPwdLine(params: {
+  cwd: string;
+  gitBranch: string | null;
+  sessionName: string | undefined;
+}): string {
+  const home = process.env.HOME || process.env.USERPROFILE;
+  let pwd = params.cwd;
+  if (home && pwd.startsWith(home)) {
+    pwd = `~${pwd.slice(home.length)}`;
+  }
+  if (params.gitBranch) pwd = `${pwd} (${params.gitBranch})`;
+  if (params.sessionName) pwd = `${pwd} • ${params.sessionName}`;
+  return pwd;
+}
+
+// ---- thinking level ----
+
+export function latestThinkingLevel(
+  entries: ReadonlyArray<{ type: string; thinkingLevel?: string }>,
+): string {
+  let level = "off";
+  for (const e of entries) {
+    if (e.type === "thinking_level_change" && e.thinkingLevel) {
+      level = e.thinkingLevel;
+    }
+  }
+  return level;
+}

package/src/model-effort-colors.ts

@@ -0,0 +1,178 @@
+/**
+ * Model/effort footer coloring for pi.
+ *
+ * Colors the model name in the footer by semantically mapping the provider
+ * to PI theme tokens, and colors the thinking/effort level using PI's
+ * built-in thinking-level theme tokens. No hardcoded hex colors, no
+ * animations.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import {
+  buildPwdLine,
+  buildStatsLeft,
+  colorContextPercent,
+  type FooterData,
+  type FooterTheme,
+  gatherUsage,
+  latestThinkingLevel,
+  layoutRightSide,
+  type ModelInfo,
+  sanitizeStatusText,
+  styleRightSide,
+  type UsageEntry,
+} from "./model-effort-colors-helpers.ts";
+
+// ---------------------------------------------------------------------------
+// Extension
+// ---------------------------------------------------------------------------
+
+export default function modelEffortColors(pi: ExtensionAPI) {
+  let currentModel: unknown;
+  let requestRender: (() => void) | undefined;
+
+  pi.on("session_start", (_event, ctx) => {
+    currentModel = ctx.model;
+    installFooter(ctx);
+  });
+
+  pi.on("model_select", (event, _ctx) => {
+    currentModel = event.model;
+    requestRender?.();
+  });
+
+  pi.on("thinking_level_select", (_event, _ctx) => {
+    requestRender?.();
+  });
+
+  pi.on("session_shutdown", () => {
+    currentModel = undefined;
+    requestRender = undefined;
+  });
+
+  // ---- footer installation ----
+
+  // biome-ignore lint/suspicious/noExplicitAny: ctx type from pi session_start handler is complex
+  function installFooter(ctx: any) {
+    ctx.ui.setFooter(
+      (tui: { requestRender(): void }, theme: FooterTheme, footerData: FooterData) => {
+        requestRender = () => tui.requestRender();
+        const branchUnsub = footerData.onBranchChange(() => tui.requestRender());
+
+        return {
+          dispose() {
+            branchUnsub();
+            requestRender = undefined;
+          },
+          invalidate() {},
+          render(width: number): string[] {
+            const model = (currentModel ?? ctx.model) as ModelInfo | undefined;
+
+            // Thinking level
+            const thinkingLevel = resolveThinkingLevel(
+              model,
+              (pi as { getThinkingLevel?: () => string }).getThinkingLevel,
+              ctx.sessionManager.getEntries(),
+            );
+
+            // Usage
+            const usage = gatherUsage(ctx.sessionManager.getEntries() as ReadonlyArray<UsageEntry>);
+
+            // Context window
+            const contextUsage = ctx.getContextUsage() as
+              | { percent?: number | null; contextWindow?: number }
+              | undefined;
+            const contextWindow = contextUsage?.contextWindow ?? model?.contextWindow ?? 0;
+            const useSubscription = model
+              ? ctx.modelRegistry.isUsingOAuth(
+                  // biome-ignore lint/suspicious/noExplicitAny: pi Model<Api> type is generic
+                  model as any,
+                )
+              : false;
+
+            // Stats
+            const rawStats = buildStatsLeft({
+              contextWindow,
+              percent: contextUsage?.percent ?? null,
+              usage,
+              useSubscription,
+            });
+
+            let statsLeft = rawStats.text;
+            let statsLeftWidth = visibleWidth(statsLeft);
+            if (statsLeftWidth > width) {
+              statsLeft = truncateToWidth(statsLeft, width, "...");
+              statsLeftWidth = visibleWidth(statsLeft);
+            }
+            statsLeft = colorContextPercent(statsLeft, rawStats.contextPercentValue, theme);
+
+            // Right side
+            const right = styleRightSide({
+              model,
+              thinkingLevel,
+              theme,
+              statsLeftWidth,
+              availableWidth: width,
+            });
+            const laidOut = layoutRightSide({
+              plain: right.plain,
+              styled: right.styled,
+              statsLeftWidth,
+              availableWidth: width,
+            });
+
+            // Path line + assembly
+            const pwdLine = truncateToWidth(
+              theme.fg(
+                "dim",
+                buildPwdLine({
+                  cwd: ctx.sessionManager.getCwd(),
+                  gitBranch: footerData.getGitBranch(),
+                  sessionName: ctx.sessionManager.getSessionName(),
+                }),
+              ),
+              width,
+              theme.fg("dim", "..."),
+            );
+
+            const lines = [
+              pwdLine,
+              theme.fg("dim", statsLeft) + theme.fg("dim", laidOut.padding) + laidOut.styled,
+            ];
+
+            // Extension statuses
+            buildStatusLine(lines, footerData, width, theme);
+
+            return lines;
+          },
+        };
+      },
+    );
+  }
+}
+
+/** Resolve the current thinking level. */
+function resolveThinkingLevel(
+  model: ModelInfo | undefined,
+  getThinkingLevel: (() => string) | undefined,
+  entries: ReadonlyArray<{ type: string; thinkingLevel?: string }>,
+): string {
+  if (!model?.reasoning) return "off";
+  return getThinkingLevel?.() ?? latestThinkingLevel(entries);
+}
+function buildStatusLine(
+  lines: string[],
+  footerData: FooterData,
+  width: number,
+  theme: FooterTheme,
+): void {
+  const statuses = footerData.getExtensionStatuses();
+  if (statuses.size === 0) return;
+
+  const entries = Array.from(statuses.entries()) as Array<[string, string]>;
+  const statusLine = entries
+    .sort((a, b) => a[0].localeCompare(b[0]))
+    .map(([, text]) => sanitizeStatusText(text))
+    .join(" ");
+  lines.push(truncateToWidth(statusLine, width, theme.fg("dim", "...")));
+}

package/src/tab-spinner.ts

@@ -13,113 +13,208 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { formatTitle, signalDone } from "@mrclrchtr/supi-core/api";
 
 const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const AGENT_END_SETTLE_MS = 200;
 
+// biome-ignore lint/complexity/noExcessiveLinesPerFunction: spinner state and event wiring are intentionally colocated
 export default function tabSpinner(pi: ExtensionAPI) {
   let timer: ReturnType<typeof setInterval> | null = null;
+  let pendingAgentEndTimer: ReturnType<typeof setTimeout> | null = null;
   let frame = 0;
   let activeCount = 0;
   let hasActiveAgent = false;
+  let pendingAgentEnd = false;
   let askUserActive = 0;
   let currentCtx: ExtensionContext | undefined;
+  let cachedSessionName: string | undefined;
+  let cachedCwd: string | undefined;
+  const unregisterBusHandlers: Array<() => void> = [];
 
-  /** Build the current base title from session name and cwd. */
+  /** Build the current base title from cached cwd plus the latest safe session name lookup. */
   function title() {
-    return formatTitle(pi.getSessionName(), currentCtx?.cwd);
+    return formatTitle(getSessionNameSafe(), cachedCwd);
   }
 
-  /** Restore the base title immediately. */
-  function stop() {
+  function clearPendingAgentEnd() {
+    pendingAgentEnd = false;
+    if (pendingAgentEndTimer) {
+      clearTimeout(pendingAgentEndTimer);
+      pendingAgentEndTimer = null;
+    }
+  }
+
+  function clearSpinnerTimer() {
     if (timer) {
       clearInterval(timer);
       timer = null;
     }
-    frame = 0;
-    if (currentCtx) {
-      currentCtx.ui.setTitle(title());
+  }
+
+  function handleStaleContext() {
+    clearPendingAgentEnd();
+    clearSpinnerTimer();
+    activeCount = 0;
+    hasActiveAgent = false;
+    currentCtx = undefined;
+  }
+
+  function rememberContext(ctx: ExtensionContext) {
+    currentCtx = ctx;
+    cachedCwd = ctx.cwd;
+    cachedSessionName = getSessionNameSafe();
+  }
+
+  function getSessionNameSafe(): string | undefined {
+    try {
+      const next = pi.getSessionName();
+      if (next !== undefined) {
+        cachedSessionName = next;
+      }
+      return cachedSessionName;
+    } catch {
+      handleStaleContext();
+      return cachedSessionName;
     }
   }
 
+  function safelySetTitle(nextTitle: string) {
+    if (!currentCtx) return;
+    try {
+      currentCtx.ui.setTitle(nextTitle);
+    } catch {
+      handleStaleContext();
+    }
+  }
+
+  /** Restore the base title immediately. */
+  function stop() {
+    clearPendingAgentEnd();
+    clearSpinnerTimer();
+    frame = 0;
+    const baseTitle = title();
+    safelySetTitle(baseTitle);
+  }
+
   /** Show the ✓ done symbol in the title and play the terminal bell. */
   function showDone() {
-    if (timer) {
-      clearInterval(timer);
-      timer = null;
-    }
+    clearPendingAgentEnd();
+    clearSpinnerTimer();
     frame = 0;
-    if (currentCtx) {
-      signalDone(currentCtx, title());
+    const baseTitle = title();
+    if (!currentCtx) return;
+    try {
+      signalDone(currentCtx, baseTitle);
+    } catch {
+      handleStaleContext();
     }
   }
 
   /** Start the spinner interval. Overwrites any ✓ shown. */
   function start() {
-    if (timer) return;
-    if (!currentCtx) return;
+    if (timer || !currentCtx) return;
     timer = setInterval(() => {
       const icon = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
-      currentCtx?.ui.setTitle(`${icon} ${title()}`);
+      const baseTitle = title();
+      safelySetTitle(`${icon} ${baseTitle}`);
       frame++;
     }, 80);
   }
 
   function increment(ctx: ExtensionContext) {
-    currentCtx = ctx;
+    clearPendingAgentEnd();
+    rememberContext(ctx);
     activeCount++;
-    if (activeCount === 1) start();
+    if (activeCount === 1 && askUserActive === 0) start();
+  }
+
+  function resumePendingAgent(ctx: ExtensionContext) {
+    if (!pendingAgentEnd) return;
+    clearPendingAgentEnd();
+    rememberContext(ctx);
+    hasActiveAgent = true;
+    if (askUserActive === 0) start();
   }
 
   /** Decrement count for supi:working tasks — restores title when idle. */
   function decrement() {
-    const floor = hasActiveAgent ? 1 : 0;
+    const floor = hasActiveAgent || pendingAgentEnd ? 1 : 0;
     activeCount = Math.max(floor, activeCount - 1);
     if (activeCount === 0) stop();
   }
 
-  /** Decrement count for agent turns — shows ✓ when idle. */
-  function agentEnded() {
+  function finalizeAgentEnd() {
+    clearPendingAgentEnd();
     activeCount = Math.max(0, activeCount - 1);
-    if (activeCount === 0) showDone();
+    if (activeCount === 0) {
+      showDone();
+      return;
+    }
+    if (askUserActive === 0) start();
   }
 
+  /** Defer the done state briefly so immediate retries do not flash ✓. */
+  function agentEnded() {
+    clearPendingAgentEnd();
+    pendingAgentEnd = true;
+    pendingAgentEndTimer = setTimeout(() => {
+      finalizeAgentEnd();
+    }, AGENT_END_SETTLE_MS);
+    pendingAgentEndTimer.unref?.();
+  }
+
+  function unregisterEvents() {
+    for (const unregister of unregisterBusHandlers.splice(0)) {
+      unregister();
+    }
+  }
+
+  pi.on("session_start", async (_event, ctx) => {
+    rememberContext(ctx);
+  });
+
   pi.on("agent_start", async (_event, ctx) => {
+    if (pendingAgentEnd) {
+      resumePendingAgent(ctx);
+      return;
+    }
     hasActiveAgent = true;
     increment(ctx);
   });
 
-  pi.on("agent_end", async (_event, _ctx) => {
+  pi.on("turn_start", async (_event, ctx) => resumePendingAgent(ctx));
+
+  pi.on("agent_end", async (event) => {
+    const retryAwareEvent = event as { willRetry?: boolean };
+    if (retryAwareEvent.willRetry) return;
     hasActiveAgent = false;
     agentEnded();
   });
 
   pi.on("session_shutdown", async (_event, ctx) => {
+    unregisterEvents();
     activeCount = 0;
-    currentCtx = ctx;
+    rememberContext(ctx);
     stop();
+    currentCtx = undefined;
   });
 
-  pi.events.on("supi:working:start", () => {
-    if (currentCtx) increment(currentCtx);
-  });
-
-  pi.events.on("supi:working:end", () => {
-    decrement();
-  });
-
-  pi.events.on("supi:ask-user:start", () => {
-    askUserActive++;
-    // Pause the spinner so ask_user's attention title (set via signalWaiting)
-    // is visible to the user instead of being overwritten on the next tick.
-    if (timer) {
-      clearInterval(timer);
-      timer = null;
-    }
-  });
-
-  pi.events.on("supi:ask-user:end", () => {
-    askUserActive = Math.max(0, askUserActive - 1);
-    if (askUserActive === 0 && activeCount > 0) {
-      // Resume the spinner if the agent (or background work) is still running.
-      start();
-    }
-  });
+  unregisterBusHandlers.push(
+    pi.events.on("supi:working:start", () => {
+      if (currentCtx) increment(currentCtx);
+    }),
+  );
+  unregisterBusHandlers.push(pi.events.on("supi:working:end", () => decrement()));
+
+  unregisterBusHandlers.push(
+    pi.events.on("supi:ask-user:start", () => {
+      askUserActive++;
+      clearSpinnerTimer();
+    }),
+  );
+
+  unregisterBusHandlers.push(
+    pi.events.on("supi:ask-user:end", () => {
+      askUserActive = Math.max(0, askUserActive - 1);
+      if (askUserActive === 0 && activeCount > 0) start();
+    }),
+  );
 }