@dungle-scrubs/tallow 0.8.21 → 0.8.23

package/extensions/health/index.ts

@@ -14,8 +14,9 @@ import type {
 	ExtensionContext,
 	Theme,
 } from "@mariozechner/pi-coding-agent";
-import { BorderedBox, ROUNDED, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
-import { resolveRuntimeProvenance } from "../../src/runtime-provenance.js";
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { resolveRuntimeProvenance } from "../../runtime/runtime-provenance.js";
+import { renderBorderedBox } from "../_shared/bordered-box.js";
 import { getTallowHomeDir } from "../_shared/tallow-paths.js";
 
 // ── Types ────────────────────────────────────────────────────────────────────
@@ -662,13 +663,12 @@ export default function healthExtension(pi: ExtensionAPI): void {
 			render(width: number): string[] {
 				const innerWidth = width - 4; // 2 borders + 2 padding
 				const contentLines = renderHealth(details, theme, innerWidth);
-				const box = new BorderedBox(contentLines, {
-					borderStyle: ROUNDED,
-					title: "Health",
+				return renderBorderedBox(contentLines, width, {
 					borderColorFn: (s) => theme.fg("muted", s),
+					style: "rounded",
+					title: "Health",
 					titleColorFn: (s) => theme.fg("accent", s),
 				});
-				return box.render(width);
 			},
 			invalidate() {},
 		};

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

@@ -2,6 +2,7 @@ import { describe, expect, it } from "bun:test";
 import {
 	adaptEventDataForHook,
 	CLAUDE_EVENT_MAP,
+	hasClaudeEventKeys,
 	shouldSkipClaudeToolResultHandler,
 	translateClaudeHooks,
 	translateClaudeOutput,
@@ -244,3 +245,37 @@ describe("shouldSkipClaudeToolResultHandler", () => {
 		);
 	});
 });
+
+describe("hasClaudeEventKeys", () => {
+	it("detects PreToolUse as a Claude event key", () => {
+		expect(hasClaudeEventKeys({ PreToolUse: [] })).toBe(true);
+	});
+
+	it("detects UserPromptSubmit as a Claude event key", () => {
+		expect(hasClaudeEventKeys({ UserPromptSubmit: [] })).toBe(true);
+	});
+
+	it("detects Stop as a Claude event key", () => {
+		expect(hasClaudeEventKeys({ Stop: [] })).toBe(true);
+	});
+
+	it("detects multiple Claude event keys", () => {
+		expect(hasClaudeEventKeys({ PreToolUse: [], PostToolUse: [], Stop: [] })).toBe(true);
+	});
+
+	it("returns false for native tallow event keys", () => {
+		expect(hasClaudeEventKeys({ tool_call: [], tool_result: [], agent_end: [] })).toBe(false);
+	});
+
+	it("returns false for empty objects", () => {
+		expect(hasClaudeEventKeys({})).toBe(false);
+	});
+
+	it("returns false for unrelated keys", () => {
+		expect(hasClaudeEventKeys({ name: "test", version: "1.0" })).toBe(false);
+	});
+
+	it("detects Claude keys in a mixed config", () => {
+		expect(hasClaudeEventKeys({ tool_call: [], PreToolUse: [] })).toBe(true);
+	});
+});

package/extensions/hooks/__tests__/subprocess-hardening.test.ts

@@ -119,3 +119,76 @@ describe("hook subprocess hardening", () => {
 		expect(elapsedMs).toBeLessThan(1000);
 	});
 });
+
+describe("Claude-sourced hook subprocess execution", () => {
+	/**
+	 * Build a Claude-sourced command hook handler.
+	 *
+	 * @param command - Shell command executed by the hook
+	 * @param claudeEventName - Original Claude event name
+	 * @returns Claude-sourced command-type hook handler
+	 */
+	function createClaudeHandler(command: string, claudeEventName: string): HookHandler {
+		return {
+			command,
+			timeout: 5,
+			type: "command",
+			_claudeSource: true,
+			_claudeEventName: claudeEventName,
+		};
+	}
+
+	test("Claude-sourced handler translates deny output to block result", async () => {
+		const handler = createClaudeHandler(
+			`node -e "process.stdout.write(JSON.stringify({hookSpecificOutput:{permissionDecision:'deny',permissionDecisionReason:'blocked by policy'}}))"`,
+			"PreToolUse"
+		);
+		const result = await runCommandHook(handler, { tool_name: "bash" }, process.cwd());
+
+		expect(result.ok).toBe(false);
+		expect(result.decision).toBe("block");
+		expect(result.reason).toBe("blocked by policy");
+	});
+
+	test("Claude-sourced handler translates additionalContext output", async () => {
+		const handler = createClaudeHandler(
+			`node -e "process.stdout.write(JSON.stringify({hookSpecificOutput:{additionalContext:'remember this context'}}))"`,
+			"UserPromptSubmit"
+		);
+		const result = await runCommandHook(handler, { prompt: "hello" }, process.cwd());
+
+		expect(result.ok).toBe(true);
+		expect(result.additionalContext).toBe("remember this context");
+	});
+
+	test("Claude-sourced handler sets CLAUDE_PROJECT_DIR env var", async () => {
+		const handler = createClaudeHandler(
+			`node -e "process.stdout.write(JSON.stringify({hookSpecificOutput:{additionalContext:process.env.CLAUDE_PROJECT_DIR}}))"`,
+			"PreToolUse"
+		);
+		const testCwd = process.cwd();
+		const result = await runCommandHook(handler, { tool_name: "bash" }, testCwd);
+
+		expect(result.ok).toBe(true);
+		expect(result.additionalContext).toBe(testCwd);
+	});
+
+	test("Claude-sourced handler exit code 2 still blocks", async () => {
+		const handler = createClaudeHandler(
+			`node -e "process.stderr.write('BLOCKED: unsafe operation'); process.exit(2)"`,
+			"PreToolUse"
+		);
+		const result = await runCommandHook(handler, { tool_name: "bash" }, process.cwd());
+
+		expect(result.ok).toBe(false);
+		expect(result.decision).toBe("block");
+		expect(result.reason).toContain("BLOCKED: unsafe operation");
+	});
+
+	test("Claude-sourced handler with no output succeeds silently", async () => {
+		const handler = createClaudeHandler("true", "PreToolUse");
+		const result = await runCommandHook(handler, { tool_name: "bash" }, process.cwd());
+
+		expect(result.ok).toBe(true);
+	});
+});

package/extensions/hooks/index.ts

@@ -34,7 +34,7 @@ import {
 	type AgentRunnerCandidate,
 	formatMissingAgentRunnerError,
 	resolveAgentRunnerCandidates,
-} from "../../src/agent-runner.js";
+} from "../../runtime/agent-runner.js";
 import { isProjectTrusted } from "../_shared/project-trust.js";
 import { evaluateCommand } from "../_shared/shell-policy.js";
 import { getTallowHomeDir, getTallowPath } from "../_shared/tallow-paths.js";
@@ -568,15 +568,33 @@ function mergeHooks(target: HooksConfig, source: HooksConfig): void {
  * Reads hooks from a JSON file (standalone hooks.json or settings.json with hooks key).
  * Returns null if the file doesn't exist or can't be parsed.
  */
+/**
+ * Check whether a parsed object contains any Claude Code event names as top-level keys.
+ *
+ * Used to detect hooks.json files that use Claude format (PreToolUse, UserPromptSubmit, etc.)
+ * instead of native tallow format (tool_call, input, etc.).
+ *
+ * @param obj - Parsed JSON object to inspect
+ * @returns True when at least one key is a known Claude event name
+ */
+export function hasClaudeEventKeys(obj: Record<string, unknown>): boolean {
+	return Object.keys(obj).some((key) => key in CLAUDE_EVENT_MAP);
+}
+
 function readHooksFile(filePath: string): HooksConfig | null {
 	try {
 		if (!fs.existsSync(filePath)) return null;
 		const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
 		// Standalone hooks.json has event keys at top level.
 		// settings.json wraps them under a "hooks" key.
+		// Also detect Claude event names (PreToolUse, etc.) as valid top-level keys.
 		return (
 			content.hooks ??
-			(content.tool_call || content.tool_result || content.agent_end ? content : null)
+			(content.tool_call || content.tool_result || content.agent_end
+				? content
+				: hasClaudeEventKeys(content)
+					? content
+					: null)
 		);
 	} catch {
 		return null;
@@ -596,7 +614,10 @@ function scanExtensionHooks(extensionsDir: string): HooksConfig {
 			const hooksPath = path.join(extensionsDir, entry, "hooks.json");
 			const hooks = readHooksFile(hooksPath);
 			if (hooks) {
-				mergeHooks(merged, hooks);
+				mergeHooks(
+					merged,
+					hasClaudeEventKeys(hooks) ? translateClaudeHooks(hooks, hooksPath) : hooks
+				);
 			}
 		}
 	} catch {
@@ -655,7 +676,9 @@ function getPackageHooks(settingsPath: string): HooksConfig[] {
 			const hooksFile = path.join(resolved, "hooks.json");
 			const hooks = readHooksFile(hooksFile);
 			if (hooks) {
-				results.push(hooks);
+				// Translate Claude event names if present, so packages can use
+				// either native tallow format or Claude Code format in hooks.json.
+				results.push(hasClaudeEventKeys(hooks) ? translateClaudeHooks(hooks, hooksFile) : hooks);
 			}
 		}
 	} catch {

package/extensions/loop/__tests__/loop.test.ts

@@ -1,13 +1,18 @@
 /**
  * Unit tests for the loop extension's pure helpers.
  *
- * Tests interval parsing, countdown formatting, and argument parsing.
- * Integration tests for the full loop lifecycle live in
- * `extensions/__integration__/loop.test.ts`.
+ * Tests interval parsing, countdown formatting, argument parsing,
+ * max iterations, and until-condition extraction.
  */
 
 import { describe, expect, test } from "bun:test";
-import { formatCountdown, parseInterval, parseLoopArgs } from "../index.js";
+import {
+	extractUntilCondition,
+	formatCountdown,
+	parseInterval,
+	parseLoopArgs,
+	parseMaxIterations,
+} from "../index.js";
 
 describe("parseInterval", () => {
 	test("parses seconds", () => {
@@ -52,6 +57,69 @@ describe("parseInterval", () => {
 	});
 });
 
+describe("parseMaxIterations", () => {
+	test("parses x<N> format", () => {
+		expect(parseMaxIterations("x100")).toBe(100);
+		expect(parseMaxIterations("x1")).toBe(1);
+		expect(parseMaxIterations("x10")).toBe(10);
+	});
+
+	test("rejects zero", () => {
+		expect(parseMaxIterations("x0")).toBeNull();
+	});
+
+	test("rejects non-x formats", () => {
+		expect(parseMaxIterations("100")).toBeNull();
+		expect(parseMaxIterations("100x")).toBeNull();
+		expect(parseMaxIterations("abc")).toBeNull();
+		expect(parseMaxIterations("")).toBeNull();
+	});
+});
+
+describe("extractUntilCondition", () => {
+	test("extracts double-quoted condition", () => {
+		const result = extractUntilCondition(["until", '"build', "is", 'done"', "check", "status"]);
+		expect(result.condition).toBe("build is done");
+		expect(result.remaining).toEqual(["check", "status"]);
+	});
+
+	test("extracts single-quoted condition", () => {
+		const result = extractUntilCondition(["until", "'tests", "pass'", "run", "tests"]);
+		expect(result.condition).toBe("tests pass");
+		expect(result.remaining).toEqual(["run", "tests"]);
+	});
+
+	test("extracts single-word quoted condition", () => {
+		const result = extractUntilCondition(["until", '"done"', "check"]);
+		expect(result.condition).toBe("done");
+		expect(result.remaining).toEqual(["check"]);
+	});
+
+	test("extracts unquoted single-word condition", () => {
+		const result = extractUntilCondition(["until", "done", "check", "status"]);
+		expect(result.condition).toBe("done");
+		expect(result.remaining).toEqual(["check", "status"]);
+	});
+
+	test("returns null when no until keyword", () => {
+		const result = extractUntilCondition(["check", "deploy", "status"]);
+		expect(result.condition).toBeNull();
+		expect(result.remaining).toEqual(["check", "deploy", "status"]);
+	});
+
+	test("preserves tokens before until", () => {
+		const result = extractUntilCondition(["x10", "until", '"done"', "check"]);
+		expect(result.condition).toBe("done");
+		expect(result.remaining).toEqual(["x10", "check"]);
+	});
+
+	test("handles until at end with no condition", () => {
+		const result = extractUntilCondition(["check", "until"]);
+		expect(result.condition).toBeNull();
+		expect(result.remaining).toEqual(["check", "until"]);
+	});
+});
+
 describe("formatCountdown", () => {
 	test("returns 'now' for zero or negative", () => {
 		expect(formatCountdown(0)).toBe("now");
@@ -111,6 +179,8 @@ describe("parseLoopArgs", () => {
 			intervalMs: 300_000,
 			intervalLabel: "5m",
 			prompt: "check deploy",
+			maxIterations: null,
+			untilCondition: null,
 		});
 	});
 
@@ -121,6 +191,8 @@ describe("parseLoopArgs", () => {
 			intervalMs: 30_000,
 			intervalLabel: "30s",
 			prompt: "/stats",
+			maxIterations: null,
+			untilCondition: null,
 		});
 	});
 
@@ -155,6 +227,98 @@ describe("parseLoopArgs", () => {
 			intervalMs: 3_600_000,
 			intervalLabel: "1h",
 			prompt: "summarize git log --oneline -20",
+			maxIterations: null,
+			untilCondition: null,
+		});
+	});
+
+	// ── Max iterations ───────────────────────────────────────────────
+
+	test("parses x<N> max iterations", () => {
+		const result = parseLoopArgs("1m x100 run tests");
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 60_000,
+			intervalLabel: "1m",
+			prompt: "run tests",
+			maxIterations: 100,
+			untilCondition: null,
+		});
+	});
+
+	test("x<N> works with single iteration", () => {
+		const result = parseLoopArgs("5s x1 check once");
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 5_000,
+			intervalLabel: "5s",
+			prompt: "check once",
+			maxIterations: 1,
+			untilCondition: null,
+		});
+	});
+
+	// ── Until condition ──────────────────────────────────────────────
+
+	test("parses until condition with double quotes", () => {
+		const result = parseLoopArgs('2m until "build is done" check fuse index');
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 120_000,
+			intervalLabel: "2m",
+			prompt: "check fuse index",
+			maxIterations: null,
+			untilCondition: "build is done",
+		});
+	});
+
+	test("parses until condition with single quotes", () => {
+		const result = parseLoopArgs("1m until 'tests pass' run test suite");
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 60_000,
+			intervalLabel: "1m",
+			prompt: "run test suite",
+			maxIterations: null,
+			untilCondition: "tests pass",
+		});
+	});
+
+	test("parses unquoted until condition", () => {
+		const result = parseLoopArgs("5m until done check status");
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 300_000,
+			intervalLabel: "5m",
+			prompt: "check status",
+			maxIterations: null,
+			untilCondition: "done",
+		});
+	});
+
+	// ── Combined x<N> + until ────────────────────────────────────────
+
+	test("parses both x<N> and until condition", () => {
+		const result = parseLoopArgs('1m x50 until "tests pass" run the test suite');
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 60_000,
+			intervalLabel: "1m",
+			prompt: "run the test suite",
+			maxIterations: 50,
+			untilCondition: "tests pass",
+		});
+	});
+
+	test("until before x<N> also works", () => {
+		const result = parseLoopArgs('1m until "deployed" x10 check deploy status');
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 60_000,
+			intervalLabel: "1m",
+			prompt: "check deploy status",
+			maxIterations: 10,
+			untilCondition: "deployed",
 		});
 	});
 });

package/extensions/loop/extension.json

@@ -1,10 +1,11 @@
 {
 	"name": "loop",
-	"version": "0.1.0",
-	"description": "Run a prompt on a recurring interval (/loop 5m check deploy)",
-	"whenToUse": "Use /loop to run a prompt or slash command repeatedly at a fixed interval.",
+	"version": "0.2.0",
+	"description": "Run a prompt on a recurring interval with optional limits and stop conditions (/loop 5m check deploy)",
+	"whenToUse": "Use /loop to run a prompt or slash command repeatedly at a fixed interval. Supports max iterations (x<N>) and model-evaluated stop conditions (until \"condition\").",
 	"capabilities": {
-		"commands": ["loop"]
+		"commands": ["loop"],
+		"tools": ["loop_stop"]
 	},
 	"permissionSurface": {
 		"filesystem": "none",
@@ -13,7 +14,7 @@
 		"subprocess": false
 	},
 	"category": "automation",
-	"tags": ["loop", "recurring", "interval", "automation"],
+	"tags": ["loop", "recurring", "interval", "automation", "until", "condition"],
 	"files": ["index.ts"],
 	"relationships": [],
 	"npmDependencies": {}