@dungle-scrubs/tallow 0.8.5 → 0.8.6

package/README.md

@@ -5,7 +5,7 @@
 <h1 align="center">Tallow</h1>
 
 <p align="center">
-  An opt-in, fully featured coding agent for your terminal. Built on <a href="https://github.com/nicobrinkkemper/pi-coding-agent">pi</a>.
+  A modular coding agent for your terminal. Built on <a href="https://github.com/nicobrinkkemper/pi-coding-agent">pi</a>.
 </p>
 
 <p align="center">
@@ -23,64 +23,35 @@
 ---
 
 <p align="center">
-  <img src="assets/screenshot.jpg" alt="Tallow multi-agent team coordinating a docs audit" />
+  <img src="assets/screenshot-annotated.png" alt="Tallow session showing status bar, auto-named session, and model selection" />
+  <br />
+  <sub>Shown with a customized <a href="https://wezfurlong.org/wezterm/">WezTerm</a> configuration.</sub>
 </p>
 
-Tallow is opt-in by default: start minimal, then enable only what your project needs.
-It is drop-in compatible with Claude Code projects via `.claude/` bridging.
-Install extensions, themes, and agents in any combination.
-This is a personal project I build in my spare time, so please be patient with
-issue and PR response times.
+Tallow is a terminal coding agent that starts minimal and scales up. Install only the
+extensions, themes, and agents your project needs, or enable everything. It drops into
+existing Claude Code projects via `.claude/` bridging, so nothing breaks when you switch.
+Ships with 50 extensions, 34 themes, and 10 specialized agents.
 
-## Features
-
-- **Most valuable capabilities (non-exhaustive):**
-  - **Multi-model routing** — route work by intent/cost (`auto-cheap`, `auto-balanced`,
-    `auto-premium`) across available providers
-  - **Multi-agent teams** — coordinate specialized agents with shared task boards,
-    dependencies, messaging, and archive/resume
-  - **Context fork** — run isolated subprocess workflows with separate tools/models and
-    merge results back cleanly
-  - **Workspace rewind snapshots** — roll file changes back to earlier conversation turns
-  - **Task primitives + background execution** — explicit task lifecycle tracking and
-    non-blocking long-running work
-  - **Built-in LSP navigation** — definitions, references, hover, and workspace symbol
-    lookup
-- **Opt-in and modular** — install only the pieces you need, skip the rest
-- **Claude Code compatible** — `.claude/` + `.tallow/` directories are bridged so existing
-  project workflows keep working
-- **Fully featured when you want it** — 49 bundled extensions, 34 themes, 8 slash commands,
-  and 10 specialized agents
-- **Session naming** — auto-generated descriptive names for each session, shown in footer
-  and `--list`
-- **Debug mode** — structured JSONL diagnostic logging with `/diag` command
-- **SDK** — embed Tallow in your own scripts and orchestrators
-- **User-owned config** — agents and commands are installed to `~/.tallow/` where you can
-  edit, remove, or add your own
-
-Read the full [documentation](https://tallow.dungle-scrubs.com).
-
-## Requirements
-
-- Node.js ≥ 22
-- An API key for at least one supported LLM provider (Anthropic, OpenAI, Google, etc.)
-
-## Installation
-
-### Global install
+## Quick start
 
 ```bash
-bun install -g tallow
-tallow install
+npm install -g tallow   # or: pnpm add -g tallow / bun install -g tallow
+tallow install          # pick extensions, themes, agents
+tallow                  # start coding
 ```
 
-Or without global install:
+Or try it without installing globally:
 
 ```bash
-bunx tallow install
+npx tallow install      # or: pnpm dlx tallow install / bunx tallow install
 ```
 
-### From source
+> Requires Node.js ≥ 22 and an API key for at least one LLM provider
+> (Anthropic, OpenAI, Google, etc.)
+
+<details>
+<summary><strong>Install from source</strong></summary>
 
 ```bash
 git clone https://github.com/dungle-scrubs/tallow.git
@@ -93,121 +64,127 @@ node dist/install.js
 The installer walks you through selecting extensions, themes, and agents,
 then links the `tallow` binary globally.
 
+</details>
+
+## Highlights
+
+**Multi-model routing** — Route tasks by intent and cost across providers.
+`auto-cheap` for boilerplate, `auto-balanced` for everyday work, `auto-premium`
+when accuracy matters.
+
+**Multi-agent teams** — Spawn specialized agents that share a task board with
+dependencies, messaging, and archive/resume. Coordinate complex work across
+multiple models in parallel.
+
+**Context fork** — Branch into an isolated subprocess with its own tools and model,
+then merge results back into the main session.
+
+**Workspace rewind** — Every conversation turn snapshots your file changes. Roll back
+to any earlier turn when something goes wrong.
+
+**Background tasks** — Kick off long-running work without blocking the session.
+Track task lifecycle explicitly and check back when ready.
+
+**LSP** — Jump to definitions, find references, inspect types, and search
+workspace symbols — no editor required.
+
+**Claude Code compatible** — Projects with `.claude/` directories (skills, agents,
+commands) work without changes. Both `.tallow/` and `.claude/` are scanned;
+`.tallow/` takes precedence.
+
+**User-owned config** — Agents, commands, and extensions install to `~/.tallow/`
+where you own them. Edit, remove, or add your own.
+
 ## Usage
 
 ```bash
-# Interactive mode
+# Interactive session
 tallow
 
 # Single-shot prompt
 tallow -p "Fix the failing tests"
 
-# Pipe input from stdin
-echo "Explain this error" | tallow
-cat README.md | tallow -p "Summarize this"
+# Pipe in context
 git diff | tallow -p "Review these changes"
+cat src/main.ts | tallow -p "Find bugs in this code"
 
-# Continue most recent session
+# Continue the last session
 tallow --continue
 
-# Use a specific model
-tallow -m anthropic/claude-sonnet-4-20250514
-
-# Set thinking level
-tallow --thinking high
-
-# Run without persisting session
-tallow --no-session
+# Pick a model and thinking level
+tallow -m anthropic/claude-sonnet-4-20250514 --thinking high
 
-# Load additional extensions
-tallow -e ./my-extension
-
-# List saved sessions (shows auto-generated names)
+# List saved sessions
 tallow --list
 
-# Runtime auth via environment (not persisted)
-TALLOW_API_KEY=sk-ant-... tallow --provider anthropic
-
-# Runtime auth via reference (resolved at runtime)
-TALLOW_API_KEY_REF=op://Services/Anthropic/api-key tallow --provider anthropic
-
-# Run in RPC or JSON mode
-tallow --mode rpc
-
 # Restrict available tools
-tallow --tools read,grep,find      # Only read, grep, find
-tallow --tools readonly            # Preset: read, grep, find, ls
-tallow --tools none                # Chat only, no tools
+tallow --tools readonly            # read, grep, find, ls only
+tallow --tools none                # chat only, no tools
+```
 
-# Disable all extensions
-tallow --no-extensions
+See the [full CLI reference](https://tallow.dungle-scrubs.com) for all flags
+and modes (RPC, JSON, piped stdin, shell interpolation, etc.)
 
-# Print tallow home directory
-tallow --home
-```
+## Configuration
+
+Tallow stores its configuration in `~/.tallow/`:
 
-`--api-key` was removed to avoid leaking secrets in process arguments.
-Use `TALLOW_API_KEY` or `TALLOW_API_KEY_REF` instead.
+| Path | Purpose |
+|------|---------|
+| `settings.json` | Global settings (theme, icons, keybindings) |
+| `.env` | Environment variables loaded at startup (supports `op://` refs) |
+| `auth.json` | Provider auth references (see [SECURITY.md](SECURITY.md)) |
+| `models.json` | Model configuration |
+| `agents/` | Agent profiles — yours to edit |
+| `commands/` | Slash commands — yours to edit |
+| `extensions/` | User extensions (override bundled ones by name) |
+| `sessions/` | Persisted conversation sessions |
 
-### Piped input
+Project-level overrides live in `.tallow/` within your repo.
 
-Pipe file contents or command output directly into Tallow:
+## Extending Tallow
 
-```bash
-# Stdin becomes the prompt
-echo "What is 2+2?" | tallow
+### Themes
 
-# Stdin as context + explicit prompt
-cat src/main.ts | tallow -p "Find bugs in this code"
+Switch themes in-session with `/theme`, or set a default:
 
-# Pipe command output
-git log --oneline -20 | tallow -p "Summarize recent changes"
+```json
+{ "theme": "tokyo-night" }
 ```
 
-When stdin is piped, Tallow automatically enters print mode (single-shot).
-If both stdin and `-p` are provided, stdin is prepended as context before the
-prompt. Piped input is capped at 10 MB. JSON mode (`--mode json`) also
-accepts piped stdin.
+### Icons
 
-### Shell interpolation
+Override any TUI glyph in `settings.json` — only the keys you set change:
 
-Expand shell commands inline with `` !`command` `` syntax:
-
-```
-!`ls -la`
-!`git status`
-!`git branch --show-current`
+```json
+{ "icons": { "success": "✔", "error": "✘" } }
 ```
 
-**Disabled by default.** Enable explicitly with either:
+See the [icon reference](https://tallow.dungle-scrubs.com/getting-started/icons/) for all keys.
 
-- `TALLOW_ENABLE_SHELL_INTERPOLATION=1` (or `TALLOW_SHELL_INTERPOLATION=1`)
-- `"shellInterpolation": true` in `.tallow/settings.json` or `~/.tallow/settings.json`
+### Writing extensions
 
-When enabled, only allowlisted implicit commands run. The command output
-replaces the pattern before reaching the agent. 5-second timeout, 1 MB
-max output, non-recursive. High-risk explicit shell commands require
-confirmation (`TALLOW_ALLOW_UNSAFE_SHELL=1` bypasses confirmation in
-non-interactive environments).
+Extensions are TypeScript files that receive the pi `ExtensionAPI`:
 
-### Slash commands
+```typescript
+import type { ExtensionAPI } from "tallow";
 
-Inside an interactive session, type `/` to see available commands:
+export default function myExtension(api: ExtensionAPI): void {
+  api.registerCommand("greet", {
+    description: "Say hello",
+    handler: async (_args, ctx) => {
+      ctx.ui.notify("Hello from my extension!", "info");
+    },
+  });
+}
+```
 
-| Command | Description |
-|---------|-------------|
-| `/implement` | Implement a feature from a description |
-| `/implement-and-review` | Implement then self-review |
-| `/review` | Review recent changes |
-| `/fix` | Fix a bug from a description |
-| `/test` | Write or fix tests |
-| `/scout-and-plan` | Explore the codebase and create a plan |
-| `/scaffold` | Scaffold a new project |
-| `/question` | Introspect on agent reasoning without triggering actions |
+Place it in `~/.tallow/extensions/my-extension/index.ts`. If it shares a name
+with a bundled extension, yours takes precedence.
 
-## SDK
+### SDK
 
-Use Tallow programmatically in your own tools:
+Embed Tallow in your own scripts:
 
 ```typescript
 import { createTallowSession } from "tallow";
@@ -227,99 +204,21 @@ await session.prompt("What files are in this directory?");
 session.dispose();
 ```
 
-### SDK options
-
-```typescript
-const tallow = await createTallowSession({
-  cwd: "/path/to/project",
-  provider: "anthropic",
-  modelId: "claude-sonnet-4-20250514",
-  thinkingLevel: "high",
-  session: { type: "memory" },        // Don't persist
-  noBundledExtensions: true,           // Start clean
-  additionalExtensions: ["./my-ext"],   // Add your own
-  systemPrompt: "You are a test bot.",  // Override system prompt
-  apiKey: process.env.ANTHROPIC_API_KEY, // Runtime only, not persisted
-});
-```
-
-## Configuration
-
-Tallow stores its configuration in `~/.tallow/`:
-
-| Path | Purpose |
-|------|---------|
-| `~/.tallow/settings.json` | Global settings |
-| `~/.tallow/.env` | Environment variables loaded at startup (supports `op://` refs) |
-| `~/.tallow/auth.json` | Provider auth references (see [SECURITY.md](SECURITY.md)) |
-| `~/.tallow/models.json` | Model configuration |
-| `~/.tallow/keybindings.json` | Keybinding overrides |
-| `~/.tallow/agents/` | Agent profiles (installed from templates, yours to edit) |
-| `~/.tallow/commands/` | Slash commands (installed from templates, yours to edit) |
-| `~/.tallow/extensions/` | User extensions (override bundled ones by name) |
-| `~/.tallow/sessions/` | Persisted conversation sessions |
-
-Project-level configuration lives in `.tallow/` within your project directory.
-
-## Icons
-
-Override any TUI glyph in `~/.tallow/settings.json`:
-
-```json
-{
-  "icons": {
-    "success": "✔",
-    "error": "✘",
-    "spinner": ["⠋", "⠙", "⠹", "⠸"]
-  }
-}
-```
-
-Only keys you set are overridden — everything else keeps its default.
-See the [icon reference](https://tallow.dungle-scrubs.com/getting-started/icons/) for all available keys.
-
-## Themes
-
-Switch themes inside an interactive session with the `/theme` command,
-or set one in `~/.tallow/settings.json`:
-
-```json
-{
-  "theme": "tokyo-night"
-}
-```
-
-## Writing extensions
-
-Extensions are TypeScript files that receive the pi `ExtensionAPI`:
-
-```typescript
-import type { ExtensionAPI } from "tallow";
-
-export default function myExtension(api: ExtensionAPI): void {
-  api.registerCommand("greet", {
-    description: "Say hello",
-    handler: async (_args, ctx) => {
-      ctx.ui.notify("Hello from my extension!", "info");
-    },
-  });
-}
-```
-
-Place your extension in `~/.tallow/extensions/my-extension/index.ts`.
-If it shares a name with a bundled extension, yours takes precedence.
+See the [SDK docs](https://tallow.dungle-scrubs.com) for all options.
 
 ## Known limitations
 
 - Requires Node.js 22+ (uses modern ESM features)
 - Session persistence is local — no cloud sync
-- The `web_fetch` extension works best with a [Firecrawl](https://firecrawl.dev) API key
-  for JS-heavy pages
+- `web_fetch` works best with a [Firecrawl](https://firecrawl.dev) API key for JS-heavy pages
 
 ## Contributing
 
 See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup and guidelines.
 
+This is a personal project I build in my spare time — please be patient with
+issue and PR response times.
+
 ## License
 
 [MIT](LICENSE) © Kevin Frilot

package/dist/config.d.ts

@@ -1,6 +1,6 @@
 import { type RuntimePathProvider } from "./runtime-path-provider.js";
 export declare const APP_NAME = "tallow";
-export declare const TALLOW_VERSION = "0.8.5";
+export declare const TALLOW_VERSION = "0.8.6";
 export declare const CONFIG_DIR = ".tallow";
 /** ~/.tallow (or override from ~/.config/tallow-work-dirs) — all user config, sessions, auth, extensions */
 export declare const TALLOW_HOME: string;

package/dist/config.js

@@ -6,7 +6,7 @@ import { fileURLToPath } from "node:url";
 import { createRuntimePathProvider } from "./runtime-path-provider.js";
 // ─── Identity ────────────────────────────────────────────────────────────────
 export const APP_NAME = "tallow";
-export const TALLOW_VERSION = "0.8.5"; // x-release-please-version
+export const TALLOW_VERSION = "0.8.6"; // x-release-please-version
 export const CONFIG_DIR = ".tallow";
 // ─── Paths ───────────────────────────────────────────────────────────────────
 /** ~/.tallow (or override from ~/.config/tallow-work-dirs) — all user config, sessions, auth, extensions */

package/extensions/claude-bridge/index.ts

@@ -135,7 +135,8 @@ export function getNonCollidingSkillPaths(
 		return paths;
 	}
 
-	for (const entry of entries) {
+	const sortedEntries = [...entries].sort((left, right) => left.name.localeCompare(right.name));
+	for (const entry of sortedEntries) {
 		if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
 		if (knownSkillNames.has(entry.name)) continue;
 

package/extensions/wezterm-notify/extension.json

@@ -0,0 +1,15 @@
+{
+	"name": "wezterm-notify",
+	"version": "0.1.0",
+	"description": "Signal agent turn status to WezTerm via OSC 1337 user variables — enables tab spinner and done-color indicators.",
+	"category": "integration",
+	"tags": ["terminal", "wezterm", "notifications"],
+	"files": ["index.ts"],
+	"relationships": [
+		{
+			"type": "enhances",
+			"extension": "wezterm-pane-control"
+		}
+	],
+	"npmDependencies": {}
+}

package/extensions/wezterm-notify/index.ts

@@ -0,0 +1,86 @@
+/**
+ * WezTerm Turn Status Extension
+ *
+ * Signals agent turn status to WezTerm via OSC 1337 SetUserVar sequences.
+ * WezTerm Lua config reads `pi_status` from `pane:get_user_vars()` to drive
+ * tab bar indicators — a spinner while the agent is working, and a color
+ * change when it finishes.
+ *
+ * Gated behind `WEZTERM_PANE` — silent no-op outside WezTerm.
+ *
+ * A heartbeat (pi_heartbeat) fires every 500ms during a turn to trigger
+ * WezTerm's `update-right-status` event, which advances the spinner frame.
+ */
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+/**
+ * Set a WezTerm user variable via OSC 1337 escape sequence.
+ * WezTerm reads these in format-tab-title via `pane:get_user_vars()`.
+ *
+ * @param name - Variable name (e.g. "pi_status")
+ * @param value - Variable value (will be base64-encoded)
+ */
+function setWezTermUserVar(name: string, value: string): void {
+	const encoded = Buffer.from(value).toString("base64");
+	process.stdout.write(`\x1b]1337;SetUserVar=${name}=${encoded}\x07`);
+}
+
+/**
+ * Start a heartbeat that re-emits pi_heartbeat every 500ms.
+ * Each write triggers WezTerm to re-render the tab bar, driving the
+ * spinner animation in format-tab-title.
+ *
+ * @returns Cleanup function to stop the heartbeat
+ */
+function startHeartbeat(): () => void {
+	let frame = 0;
+	const interval = setInterval(() => {
+		setWezTermUserVar("pi_heartbeat", String(frame++));
+	}, 500);
+	return () => clearInterval(interval);
+}
+
+/**
+ * Register event handlers to signal turn status to WezTerm.
+ * Only activates when `WEZTERM_PANE` is set.
+ *
+ * @param pi - Extension API for registering event handlers
+ */
+export default function weztermNotify(pi: ExtensionAPI): void {
+	if (!process.env.WEZTERM_PANE) {
+		return;
+	}
+
+	let stopHeartbeat: (() => void) | null = null;
+
+	pi.on("turn_start", async () => {
+		setWezTermUserVar("pi_status", "working");
+		stopHeartbeat?.();
+		stopHeartbeat = startHeartbeat();
+	});
+
+	pi.on("turn_end", async () => {
+		stopHeartbeat?.();
+		stopHeartbeat = null;
+		setWezTermUserVar("pi_status", "done");
+	});
+
+	pi.on("input", async () => {
+		stopHeartbeat?.();
+		stopHeartbeat = null;
+		setWezTermUserVar("pi_status", "");
+		return { action: "continue" as const };
+	});
+
+	pi.on("session_start", async () => {
+		stopHeartbeat?.();
+		stopHeartbeat = null;
+		setWezTermUserVar("pi_status", "");
+	});
+
+	pi.on("session_shutdown", async () => {
+		stopHeartbeat?.();
+		stopHeartbeat = null;
+		setWezTermUserVar("pi_status", "");
+	});
+}

package/extensions/wezterm-notify/wezterm/tallow.lua

@@ -0,0 +1,197 @@
+--- tallow WezTerm integration
+--- Adds agent turn status indicators to the tab bar.
+---
+--- Standalone usage (module owns format-tab-title + update-right-status):
+---
+---   local tallow = require("tallow")
+---   tallow.setup()
+---
+--- If you already have custom handlers, do not call setup().
+--- Use helper functions instead:
+---
+---   local tallow = require("tallow")
+---   wezterm.on("update-right-status", function(window, pane)
+---     tallow.tick()
+---     -- your existing update-right-status logic
+---   end)
+---
+---   wezterm.on("format-tab-title", function(tab)
+---     local any_working, any_done_unseen = tallow.get_tab_status(tab)
+---     -- your existing format-tab-title logic using these status flags
+---   end)
+
+local wezterm = require("wezterm")
+
+local M = {}
+
+local SPINNER_CHARS = { "◰", "◳", "◲", "◱" }
+
+local defaults = {
+	spinner_color = "#d8a274",
+	done_color = "#61afef",
+	active_color = "#ccb266",
+	inactive_color = "#737373",
+	spinner_interval_seconds = 0.5,
+	max_title_length = 24,
+}
+
+---Copy a table shallowly.
+---@param value table
+---@return table
+local function copy_table(value)
+	local out = {}
+	for k, v in pairs(value) do
+		out[k] = v
+	end
+	return out
+end
+
+---Merge optional overrides onto defaults.
+---@param opts table|nil
+---@return table
+local function resolve_options(opts)
+	local out = copy_table(defaults)
+	if not opts then
+		return out
+	end
+
+	for k, v in pairs(opts) do
+		out[k] = v
+	end
+	return out
+end
+
+---Resolve the title text shown in tab rendering.
+---@param tab table TabInformation
+---@param max_len number
+---@return string
+local function resolve_title(tab, max_len)
+	local title = tostring(tab.tab_index + 1)
+
+	if tab.tab_title and #tab.tab_title > 0 then
+		title = tab.tab_title
+	end
+
+	if #title > max_len then
+		title = title:sub(1, max_len - 2) .. ".."
+	end
+
+	return title
+end
+
+---Aggregate pi_status across all panes in a tab.
+---@param tab table TabInformation from format-tab-title
+---@return boolean any_working
+---@return boolean any_done_unseen
+function M.get_tab_status(tab)
+	local any_working = false
+	local any_done_unseen = false
+
+	local mux_tab = wezterm.mux.get_tab(tab.tab_id)
+	if not mux_tab then
+		return false, false
+	end
+
+	if not wezterm.GLOBAL.pi_seen then
+		wezterm.GLOBAL.pi_seen = {}
+	end
+
+	for _, pane in ipairs(mux_tab:panes()) do
+		local vars = pane:get_user_vars()
+		local status = vars.pi_status or ""
+		local pid = tostring(pane:pane_id())
+
+		if status == "working" then
+			any_working = true
+			wezterm.GLOBAL.pi_seen[pid] = nil
+		elseif status == "done" then
+			if tab.is_active then
+				wezterm.GLOBAL.pi_seen[pid] = true
+			elseif not wezterm.GLOBAL.pi_seen[pid] then
+				any_done_unseen = true
+			end
+		else
+			wezterm.GLOBAL.pi_seen[pid] = nil
+		end
+	end
+
+	return any_working, any_done_unseen
+end
+
+---Advance spinner frame using wall-clock throttling.
+---@param opts table|nil Optional overrides
+function M.tick(opts)
+	local resolved = resolve_options(opts)
+	local now = os.clock()
+	local last = wezterm.GLOBAL.tallow_spinner_last or 0
+
+	if (now - last) >= resolved.spinner_interval_seconds then
+		local frame = wezterm.GLOBAL.tallow_spinner_frame or 0
+		wezterm.GLOBAL.tallow_spinner_frame = (frame + 1) % #SPINNER_CHARS
+		wezterm.GLOBAL.tallow_spinner_last = now
+	end
+end
+
+---Get current spinner glyph for the active frame.
+---@return string
+function M.spinner_char()
+	local frame = wezterm.GLOBAL.tallow_spinner_frame or 0
+	return SPINNER_CHARS[(frame % #SPINNER_CHARS) + 1]
+end
+
+---Render default tab title elements with tallow status indicators.
+---@param tab table TabInformation from format-tab-title
+---@param opts table|nil Optional color/timing overrides
+---@return table
+function M.render_tab_title(tab, opts)
+	local resolved = resolve_options(opts)
+	local any_working, any_done_unseen = M.get_tab_status(tab)
+	local title = resolve_title(tab, resolved.max_title_length)
+	local elements = {}
+
+	if any_working then
+		table.insert(elements, { Foreground = { Color = resolved.spinner_color } })
+		table.insert(elements, { Text = " " .. M.spinner_char() .. " " })
+	else
+		table.insert(elements, { Text = "   " })
+	end
+
+	local fg = tab.is_active and resolved.active_color or resolved.inactive_color
+	if any_done_unseen then
+		fg = resolved.done_color
+	end
+
+	table.insert(elements, { Foreground = { Color = fg } })
+	table.insert(elements, { Text = title .. "  " })
+	return elements
+end
+
+---Register default event handlers for tallow tab indicators.
+---
+---This owns both `update-right-status` and `format-tab-title`.
+---If your config already defines either handler, use helper methods
+---(`tick`, `get_tab_status`, `spinner_char`, `render_tab_title`) and
+---compose manually in your own handlers instead.
+---
+---@param opts table|nil Optional color/timing overrides
+function M.setup(opts)
+	local resolved = resolve_options(opts)
+
+	if wezterm.GLOBAL.tallow_handlers_registered then
+		wezterm.GLOBAL.tallow_handler_options = resolved
+		return
+	end
+
+	wezterm.GLOBAL.tallow_handlers_registered = true
+	wezterm.GLOBAL.tallow_handler_options = resolved
+
+	wezterm.on("update-right-status", function()
+		M.tick(wezterm.GLOBAL.tallow_handler_options)
+	end)
+
+	wezterm.on("format-tab-title", function(tab)
+		return M.render_tab_title(tab, wezterm.GLOBAL.tallow_handler_options)
+	end)
+end
+
+return M

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@dungle-scrubs/tallow",
-	"version": "0.8.5",
+	"version": "0.8.6",
 	"description": "An opinionated coding agent. Built on pi.",
 	"piConfig": {
 		"name": "tallow",

package/skills/tallow-expert/SKILL.md

@@ -34,7 +34,7 @@ Relay that answer to the user.
 | Component | Location |
 |-----------|----------|
 | Core source | `src/` (agent-runner.ts, atomic-write.ts, auth-hardening.ts, cli.ts, config.ts, extensions-global.d.ts, fatal-errors.ts, index.ts, install.ts, interactive-mode-patch.ts, pid-manager.ts, plugins.ts, process-cleanup.ts, project-trust.ts, runtime-path-provider.ts, sdk.ts, session-migration.ts, session-utils.ts) |
-| Extensions | `extensions/` — extension.json + index.ts each (49 bundled) |
+| Extensions | `extensions/` — extension.json + index.ts each (50 bundled) |
 | Skills | `skills/` — subdirs with SKILL.md |
 | Agents | `agents/` — markdown with YAML frontmatter |
 | Themes | `themes/` — JSON files (34 dark-only themes) |