@dungle-scrubs/tallow 0.8.3 → 0.8.4

package/README.md

@@ -5,7 +5,7 @@
 <h1 align="center">Tallow</h1>
 
 <p align="center">
-  An opinionated coding agent. Built on <a href="https://github.com/nicobrinkkemper/pi-coding-agent">pi</a>.
+  An opt-in, fully featured coding agent for your terminal. Built on <a href="https://github.com/nicobrinkkemper/pi-coding-agent">pi</a>.
 </p>
 
 <p align="center">
@@ -26,22 +26,37 @@
   <img src="assets/screenshot.jpg" alt="Tallow multi-agent team coordinating a docs audit" />
 </p>
 
-49 extensions, 34 themes, 8 slash commands, and 10 specialized agents.
-Install only what you need — the interactive installer lets you pick.
+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.
 
 ## Features
 
-- **49 bundled extensions** — enhanced tools, hooks, tasks, teams, LSP, themes, permissions, context usage, and more
-- **34 terminal themes** — Tokyo Night, Catppuccin, Gruvbox, Rose Pine, Nord, and many others
-- **8 slash commands** — `/implement`, `/implement-and-review`, `/review`, `/fix`, `/test`, `/scout-and-plan`, `/scaffold`, `/question`
-- **9 specialized agents** — architect, debug, explore, planner, refactor, reviewer, scout, worker, tallow-expert
-- **Multi-agent teams** — coordinate multiple agents with task boards, messaging, and archive/resume
-- **Session naming** — auto-generated descriptive names for each session, shown in footer and `--list`
-- **Context fork** — run skills and commands in isolated subprocesses via `context: fork` frontmatter
+- **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
-- **Claude Code compatible** — `.claude/` directory bridging for seamless use of Tallow skills, agents, and commands in Claude Code
 - **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
+- **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).
 
@@ -298,7 +313,8 @@ If it shares a name with a bundled extension, yours takes precedence.
 
 - 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
+- The `web_fetch` extension works best with a [Firecrawl](https://firecrawl.dev) API key
+  for JS-heavy pages
 
 ## Contributing
 

package/dist/config.d.ts

@@ -1,5 +1,5 @@
 export declare const APP_NAME = "tallow";
-export declare const TALLOW_VERSION = "0.8.3";
+export declare const TALLOW_VERSION = "0.8.4";
 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

@@ -5,7 +5,7 @@ import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 // ─── Identity ────────────────────────────────────────────────────────────────
 export const APP_NAME = "tallow";
-export const TALLOW_VERSION = "0.8.3"; // x-release-please-version
+export const TALLOW_VERSION = "0.8.4"; // 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/__integration__/claude-hooks-compat.test.ts

@@ -0,0 +1,118 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { loadHooksConfig } from "../hooks/index.js";
+
+let cwd: string;
+let homeDir: string;
+let originalHome: string | undefined;
+
+/**
+ * Writes JSON with pretty formatting, creating parent directories as needed.
+ *
+ * @param filePath - Destination file path
+ * @param value - JSON-serializable payload
+ * @returns void
+ */
+function writeJson(filePath: string, value: unknown): void {
+	mkdirSync(dirname(filePath), { recursive: true });
+	writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+beforeEach(() => {
+	cwd = mkdtempSync(join(tmpdir(), "tallow-claude-hooks-cwd-"));
+	homeDir = mkdtempSync(join(tmpdir(), "tallow-claude-hooks-home-"));
+	originalHome = process.env.HOME;
+	process.env.HOME = homeDir;
+});
+
+afterEach(() => {
+	if (originalHome !== undefined) {
+		process.env.HOME = originalHome;
+	} else {
+		delete process.env.HOME;
+	}
+
+	rmSync(cwd, { recursive: true, force: true });
+	rmSync(homeDir, { recursive: true, force: true });
+});
+
+describe("Claude hooks compatibility integration", () => {
+	it("loads and translates .claude/settings.json hook events", () => {
+		writeJson(join(cwd, ".claude", "settings.json"), {
+			hooks: {
+				PreToolUse: [
+					{
+						matcher: "Bash",
+						hooks: [{ type: "command", command: "echo pre" }],
+					},
+				],
+				PostToolUseFailure: [
+					{
+						matcher: "Write",
+						hooks: [{ type: "command", command: "echo fail" }],
+					},
+				],
+			},
+		});
+
+		const config = loadHooksConfig(cwd);
+		expect(config.tool_call).toHaveLength(1);
+		expect(config.tool_result).toHaveLength(1);
+		expect(config.tool_call[0]?.matcher).toBe("bash");
+		expect(config.tool_result[0]?.matcher).toBe("write");
+		expect(config.tool_call[0]?.hooks[0]?._claudeSource).toBe(true);
+		expect(config.tool_call[0]?.hooks[0]?._claudeEventName).toBe("PreToolUse");
+		expect(config.tool_result[0]?.hooks[0]?._claudeEventName).toBe("PostToolUseFailure");
+	});
+
+	it("keeps .tallow hooks ahead of .claude hooks for matching order", () => {
+		writeJson(join(cwd, ".tallow", "hooks.json"), {
+			tool_call: [
+				{
+					matcher: "bash",
+					hooks: [{ type: "command", command: "echo tallow" }],
+				},
+			],
+		});
+		writeJson(join(cwd, ".claude", "settings.json"), {
+			hooks: {
+				PreToolUse: [
+					{
+						matcher: "Bash",
+						hooks: [{ type: "command", command: "echo claude" }],
+					},
+				],
+			},
+		});
+
+		const config = loadHooksConfig(cwd);
+		const handlers = config.tool_call?.map((entry) => entry.hooks[0]?.command);
+		expect(handlers).toEqual(["echo tallow", "echo claude"]);
+	});
+
+	it("allows native and Claude event names in the same .claude config", () => {
+		writeJson(join(cwd, ".claude", "settings.json"), {
+			hooks: {
+				PreToolUse: [
+					{
+						matcher: "Edit|Write",
+						hooks: [{ type: "command", command: "echo claude" }],
+					},
+				],
+				tool_call: [
+					{
+						matcher: "bash",
+						hooks: [{ type: "command", command: "echo native" }],
+					},
+				],
+			},
+		});
+
+		const config = loadHooksConfig(cwd);
+		expect(config.tool_call).toHaveLength(2);
+		expect(config.tool_call?.[0]?.matcher).toBe("edit|write");
+		expect(config.tool_call?.[1]?.matcher).toBe("bash");
+	});
+});

package/extensions/context-fork/index.ts

@@ -407,7 +407,7 @@ export default function (pi: ExtensionAPI): void {
 		const explicitModel = fm.model ?? agentConfig?.model;
 		const resolvedModel = explicitModel
 			? resolveModel(explicitModel)
-			: await routeForkedModel(content, undefined, ctx.model?.id);
+			: await routeForkedModel(content, undefined, ctx.model?.id, undefined, ctx.cwd);
 
 		// Show working indicator
 		const workingParts = [`🔀 forking: /${commandName}`];

package/extensions/context-fork/model-resolver.ts

@@ -34,15 +34,25 @@ export function resolveModel(input: string | undefined): string | undefined {
  * @param modelOverride - Explicit model (fuzzy matched), skips auto-routing
  * @param parentModelId - Parent model ID for fallback inheritance
  * @param hints - Optional routing hints (modelScope, costPreference, etc.)
+ * @param cwd - Working directory used for project-local routing settings
  * @returns Resolved model ID, or undefined on failure
  */
 export async function routeForkedModel(
 	task: string,
 	modelOverride?: string,
 	parentModelId?: string,
-	hints?: RoutingHints
+	hints?: RoutingHints,
+	cwd?: string
 ): Promise<string | undefined> {
-	const routing = await routeModel(task, modelOverride, undefined, parentModelId, undefined, hints);
+	const routing = await routeModel(
+		task,
+		modelOverride,
+		undefined,
+		parentModelId,
+		undefined,
+		hints,
+		cwd
+	);
 	if (!routing.ok) return modelOverride; // fallback to raw string
 	return routing.model.id;
 }

package/extensions/hooks/__tests__/claude-compat.test.ts

@@ -0,0 +1,215 @@
+import { describe, expect, it } from "bun:test";
+import {
+	adaptEventDataForHook,
+	CLAUDE_EVENT_MAP,
+	shouldSkipClaudeToolResultHandler,
+	translateClaudeHooks,
+	translateClaudeOutput,
+	translateClaudeToolMatcher,
+} from "../index.js";
+
+describe("translateClaudeToolMatcher", () => {
+	it("maps Claude built-in tool names to tallow tool names", () => {
+		expect(translateClaudeToolMatcher("Bash")).toBe("bash");
+		expect(translateClaudeToolMatcher("Edit|Write")).toBe("edit|write");
+		expect(translateClaudeToolMatcher("Read|Glob|Grep")).toBe("read|find|grep");
+	});
+
+	it("passes through unknown and MCP matchers unchanged", () => {
+		expect(translateClaudeToolMatcher("mcp__github__.*")).toBe("mcp__github__.*");
+		expect(translateClaudeToolMatcher("CustomTool")).toBe("CustomTool");
+		expect(translateClaudeToolMatcher("*")).toBe("*");
+	});
+});
+
+describe("translateClaudeHooks", () => {
+	it("translates Claude event names to tallow event names", () => {
+		const config = {
+			PreToolUse: [{ matcher: "Bash", hooks: [{ type: "command", command: "echo pre" }] }],
+			PostToolUse: [{ matcher: "Write", hooks: [{ type: "command", command: "echo post" }] }],
+			Stop: [{ hooks: [{ type: "command", command: "echo stop" }] }],
+		};
+
+		const translated = translateClaudeHooks(config, "test-source");
+		expect(translated.tool_call).toHaveLength(1);
+		expect(translated.tool_result).toHaveLength(1);
+		expect(translated.agent_end).toHaveLength(1);
+		expect(translated.tool_call[0]?.matcher).toBe("bash");
+		expect(translated.tool_result[0]?.matcher).toBe("write");
+
+		const handler = translated.tool_call[0]?.hooks[0];
+		expect(handler?._claudeSource).toBe(true);
+		expect(handler?._claudeEventName).toBe("PreToolUse");
+	});
+
+	it("skips PermissionRequest with a warning", () => {
+		const warnings: string[] = [];
+		const originalWarn = console.warn;
+		console.warn = (...args: unknown[]) => {
+			warnings.push(args.map((arg) => String(arg)).join(" "));
+		};
+
+		try {
+			const translated = translateClaudeHooks(
+				{
+					PermissionRequest: [
+						{ matcher: "Bash", hooks: [{ type: "command", command: "echo deny" }] },
+					],
+				},
+				"/tmp/.claude/settings.json"
+			);
+
+			expect(Object.keys(translated)).toHaveLength(0);
+			expect(warnings.some((line) => line.includes("PermissionRequest"))).toBe(true);
+		} finally {
+			console.warn = originalWarn;
+		}
+	});
+
+	it("supports mixed native + Claude events in the same config", () => {
+		const translated = translateClaudeHooks({
+			PreToolUse: [{ matcher: "Edit|Write", hooks: [{ type: "command", command: "echo a" }] }],
+			tool_call: [{ matcher: "bash", hooks: [{ type: "command", command: "echo b" }] }],
+		});
+
+		expect(translated.tool_call).toHaveLength(2);
+		expect(translated.tool_call[0]?.matcher).toBe("edit|write");
+		expect(translated.tool_call[1]?.matcher).toBe("bash");
+	});
+
+	it("passes unknown events through for forward compatibility", () => {
+		const translated = translateClaudeHooks({
+			FutureEvent: [{ hooks: [{ type: "command", command: "echo future" }] }],
+		});
+
+		expect(translated.FutureEvent).toHaveLength(1);
+		expect(translated.FutureEvent[0]?.hooks[0]?._claudeSource).toBe(true);
+		expect(translated.FutureEvent[0]?.hooks[0]?._claudeEventName).toBe("FutureEvent");
+	});
+
+	it("maps all documented Claude events", () => {
+		const expectedMappings = {
+			SessionStart: "session_start",
+			UserPromptSubmit: "input",
+			PreToolUse: "tool_call",
+			PermissionRequest: "tool_call",
+			PostToolUse: "tool_result",
+			PostToolUseFailure: "tool_result",
+			Notification: "notification",
+			SubagentStart: "subagent_start",
+			SubagentStop: "subagent_stop",
+			Stop: "agent_end",
+			TeammateIdle: "teammate_idle",
+			TaskCompleted: "task_completed",
+			PreCompact: "session_before_compact",
+			SessionEnd: "session_shutdown",
+		};
+
+		expect(CLAUDE_EVENT_MAP).toEqual(expectedMappings);
+	});
+});
+
+describe("adaptEventDataForHook", () => {
+	it("adapts tool_call payload for PreToolUse hooks", () => {
+		const adapted = adaptEventDataForHook(
+			"tool_call",
+			{ input: { command: "echo hi" }, toolName: "bash" },
+			{ _claudeEventName: "PreToolUse", _claudeSource: true, type: "command" },
+			"/repo"
+		);
+
+		expect(adapted.tool_name).toBe("bash");
+		expect(adapted.tool_input).toEqual({ command: "echo hi" });
+		expect(adapted.hook_event_name).toBe("PreToolUse");
+		expect(adapted.cwd).toBe("/repo");
+	});
+
+	it("adapts tool_result payload for PostToolUse hooks", () => {
+		const adapted = adaptEventDataForHook(
+			"tool_result",
+			{ content: [{ text: "ok", type: "text" }], input: { path: "a.ts" }, toolName: "write" },
+			{ _claudeEventName: "PostToolUse", _claudeSource: true, type: "command" },
+			"/repo"
+		);
+
+		expect(adapted.tool_name).toBe("write");
+		expect(adapted.tool_input).toEqual({ path: "a.ts" });
+		expect(adapted.tool_response).toEqual([{ text: "ok", type: "text" }]);
+	});
+
+	it("adapts input payload for UserPromptSubmit hooks", () => {
+		const adapted = adaptEventDataForHook(
+			"input",
+			{ source: "terminal", text: "hello" },
+			{ _claudeEventName: "UserPromptSubmit", _claudeSource: true, type: "command" },
+			"/repo"
+		);
+
+		expect(adapted.prompt).toBe("hello");
+		expect(adapted.hook_event_name).toBe("UserPromptSubmit");
+	});
+
+	it("keeps native hook payload unchanged", () => {
+		const event = { input: { command: "ls" }, toolName: "bash" };
+		const adapted = adaptEventDataForHook("tool_call", event, { type: "command" }, "/repo");
+		expect(adapted).toEqual(event);
+	});
+});
+
+describe("translateClaudeOutput", () => {
+	it("maps permissionDecision deny to a blocking result", () => {
+		const result = translateClaudeOutput({
+			hookSpecificOutput: {
+				permissionDecision: "deny",
+				permissionDecisionReason: "no",
+			},
+		});
+
+		expect(result).toEqual({ decision: "block", ok: false, reason: "no" });
+	});
+
+	it("maps top-level decision block to a blocking result", () => {
+		const result = translateClaudeOutput({ decision: "block", reason: "blocked" });
+		expect(result).toEqual({ decision: "block", ok: false, reason: "blocked" });
+	});
+
+	it("maps continue=false to a stop result", () => {
+		const result = translateClaudeOutput({ continue: false, stopReason: "stop" });
+		expect(result).toEqual({ ok: false, reason: "stop" });
+	});
+
+	it("passes additional context through", () => {
+		const result = translateClaudeOutput({
+			hookSpecificOutput: { additionalContext: "remember this" },
+		});
+		expect(result).toEqual({ additionalContext: "remember this", ok: true });
+	});
+});
+
+describe("shouldSkipClaudeToolResultHandler", () => {
+	it("only runs PostToolUseFailure when isError=true", () => {
+		const handler = {
+			_claudeEventName: "PostToolUseFailure",
+			_claudeSource: true,
+			type: "command",
+		};
+		expect(shouldSkipClaudeToolResultHandler("tool_result", { isError: false }, handler)).toBe(
+			true
+		);
+		expect(shouldSkipClaudeToolResultHandler("tool_result", { isError: true }, handler)).toBe(
+			false
+		);
+	});
+
+	it("only runs PostToolUse when isError=false", () => {
+		const handler = {
+			_claudeEventName: "PostToolUse",
+			_claudeSource: true,
+			type: "command",
+		};
+		expect(shouldSkipClaudeToolResultHandler("tool_result", { isError: true }, handler)).toBe(true);
+		expect(shouldSkipClaudeToolResultHandler("tool_result", { isError: false }, handler)).toBe(
+			false
+		);
+	});
+});

package/extensions/hooks/hooks.schema.json

@@ -1,7 +1,7 @@
 {
 	"$schema": "http://json-schema.org/draft-07/schema#",
 	"title": "Pi Hooks Configuration",
-	"description": "Configuration for Pi agent hooks — shell commands, LLM prompts, or subagents triggered by lifecycle events.",
+	"description": "Configuration for Pi agent hooks - shell commands, LLM prompts, or subagents triggered by lifecycle events.",
 	"type": "object",
 	"properties": {
 		"$schema": {
@@ -41,7 +41,7 @@
 				},
 				"before_agent_start": {
 					"$ref": "#/$defs/eventHooks",
-					"description": "Before the agent starts — can inject context."
+					"description": "Before the agent starts - can inject context."
 				},
 				"setup": {
 					"$ref": "#/$defs/eventHooks",
@@ -61,7 +61,7 @@
 				},
 				"session_before_compact": {
 					"$ref": "#/$defs/eventHooks",
-					"description": "Before context compaction — can preserve data."
+					"description": "Before context compaction - can preserve data."
 				},
 				"session_fork": {
 					"$ref": "#/$defs/eventHooks",
@@ -89,7 +89,7 @@
 				},
 				"context": {
 					"$ref": "#/$defs/eventHooks",
-					"description": "Context filtering — can modify messages sent to the model."
+					"description": "Context filtering - can modify messages sent to the model."
 				},
 				"model_select": {
 					"$ref": "#/$defs/eventHooks",
@@ -118,6 +118,62 @@
 				"task_completed": {
 					"$ref": "#/$defs/eventHooks",
 					"description": "When a team task completes. Matcher filters on assignee."
+				},
+				"SessionStart": {
+					"$ref": "#/$defs/eventHooks",
+					"description": "Claude Code alias for session_start."
+				},
+				"UserPromptSubmit": {
+					"$ref": "#/$defs/eventHooks",
+					"description": "Claude Code alias for input."
+				},
+				"PreToolUse": {
+					"$ref": "#/$defs/eventHooks",
+					"description": "Claude Code alias for tool_call. Matcher uses Claude names like Bash/Edit/Write and is translated automatically."
+				},
+				"PermissionRequest": {
+					"$ref": "#/$defs/eventHooks",
+					"description": "Claude Code event with no tallow equivalent. Parsed for compatibility and skipped with a warning."
+				},
+				"PostToolUse": {
+					"$ref": "#/$defs/eventHooks",
+					"description": "Claude Code alias for successful tool_result (isError=false)."
+				},
+				"PostToolUseFailure": {
+					"$ref": "#/$defs/eventHooks",
+					"description": "Claude Code alias for failed tool_result (isError=true)."
+				},
+				"Notification": {
+					"$ref": "#/$defs/eventHooks",
+					"description": "Claude Code alias for notification."
+				},
+				"SubagentStart": {
+					"$ref": "#/$defs/eventHooks",
+					"description": "Claude Code alias for subagent_start."
+				},
+				"SubagentStop": {
+					"$ref": "#/$defs/eventHooks",
+					"description": "Claude Code alias for subagent_stop."
+				},
+				"Stop": {
+					"$ref": "#/$defs/eventHooks",
+					"description": "Claude Code alias for agent_end."
+				},
+				"TeammateIdle": {
+					"$ref": "#/$defs/eventHooks",
+					"description": "Claude Code alias for teammate_idle."
+				},
+				"TaskCompleted": {
+					"$ref": "#/$defs/eventHooks",
+					"description": "Claude Code alias for task_completed."
+				},
+				"PreCompact": {
+					"$ref": "#/$defs/eventHooks",
+					"description": "Claude Code alias for session_before_compact."
+				},
+				"SessionEnd": {
+					"$ref": "#/$defs/eventHooks",
+					"description": "Claude Code alias for session_shutdown."
 				}
 			},
 			"additionalProperties": {
@@ -155,7 +211,7 @@
 		},
 		"hookHandler": {
 			"type": "object",
-			"description": "A single hook action — shell command, LLM prompt, or subagent.",
+			"description": "A single hook action - shell command, LLM prompt, or subagent.",
 			"properties": {
 				"type": {
 					"type": "string",