@dungle-scrubs/tallow 0.8.24 → 0.8.26

package/extensions/custom-footer/context-display.ts

@@ -0,0 +1,49 @@
+import type { ContextUsage } from "@mariozechner/pi-coding-agent";
+
+/**
+ * Formats token counts with k/M suffixes for readability.
+ *
+ * @param count - Token count to format
+ * @returns Formatted string (e.g., "1.2k", "5M")
+ */
+function formatTokens(count: number): string {
+	if (count < 1000) return count.toString();
+	if (count < 10_000) 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`;
+}
+
+/**
+ * Formats footer context usage without reusing stale pre-compaction token counts.
+ *
+ * `ctx.getContextUsage()` intentionally returns `tokens: null` after compaction
+ * until a fresh assistant response arrives. The footer must preserve that
+ * unknown state instead of showing a bogus percentage from stale usage data.
+ *
+ * @param usage - Current context usage snapshot, if available
+ * @param fallbackContextWindow - Active model context window when usage is unavailable
+ * @param autoCompactEnabled - Whether to append the auto-compaction indicator
+ * @returns Display text plus raw percentage for severity coloring
+ */
+export function formatContextUsageDisplay(
+	usage: ContextUsage | undefined,
+	fallbackContextWindow: number,
+	autoCompactEnabled: boolean
+): { readonly percent: number | null; readonly text: string } {
+	const autoIndicator = autoCompactEnabled ? " (auto)" : "";
+	const contextWindow = usage?.contextWindow ?? fallbackContextWindow;
+	const tokens = usage ? usage.tokens : 0;
+
+	if (contextWindow <= 0) {
+		return { percent: null, text: `?/?${autoIndicator}` };
+	}
+
+	const windowText = formatTokens(contextWindow);
+	if (tokens === null) {
+		return { percent: null, text: `?/${windowText}${autoIndicator}` };
+	}
+
+	const percent = (tokens / contextWindow) * 100;
+	return { percent, text: `${percent.toFixed(1)}%/${windowText}${autoIndicator}` };
+}

package/extensions/custom-footer/index.ts

@@ -19,6 +19,7 @@
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
 import { runGitCommandSync } from "../_shared/shell-policy.js";
+import { formatContextUsageDisplay } from "./context-display.js";
 
 /** Cached git repository state for the footer display. */
 interface GitState {
@@ -204,26 +205,12 @@ export default function customFooterExtension(pi: ExtensionAPI): void {
 						}
 					}
 
-					// Get context percentage from last assistant message
-					const branch = sessionManager.getBranch();
-					const lastAssistant = branch
-						.slice()
-						.reverse()
-						.find(
-							(e) =>
-								e.type === "message" &&
-								e.message.role === "assistant" &&
-								(e.message as unknown as Record<string, string>).stopReason !== "aborted"
-						);
-
-					let contextTokens = 0;
-					if (lastAssistant?.type === "message" && lastAssistant.message.role === "assistant") {
-						const u = lastAssistant.message.usage;
-						contextTokens = u.input + u.output + u.cacheRead + u.cacheWrite;
-					}
-
-					const contextWindow = model?.contextWindow || 0;
-					const contextPercentValue = contextWindow > 0 ? (contextTokens / contextWindow) * 100 : 0;
+					const contextUsage = extensionCtx.getContextUsage();
+					const { percent: contextPercentValue, text: contextDisplay } = formatContextUsageDisplay(
+						contextUsage,
+						model?.contextWindow ?? 0,
+						autoCompactEnabled
+					);
 
 					// Build path (replace home with ~)
 					let pwd = process.cwd();
@@ -270,10 +257,10 @@ export default function customFooterExtension(pi: ExtensionAPI): void {
 					if (totalCost) statsParts.push(`$${totalCost.toFixed(3)}`);
 
 					// Context percentage with color
-					const autoIndicator = autoCompactEnabled ? " (auto)" : "";
-					const contextDisplay = `${contextPercentValue.toFixed(1)}%/${formatTokens(contextWindow)}${autoIndicator}`;
 					let contextStr: string;
-					if (contextPercentValue > 90) {
+					if (contextPercentValue === null) {
+						contextStr = theme.fg("dim", contextDisplay);
+					} else if (contextPercentValue > 90) {
 						contextStr = theme.fg("error", contextDisplay);
 					} else if (contextPercentValue > 70) {
 						contextStr = theme.fg("warning", contextDisplay);

package/extensions/permissions/index.ts

@@ -25,7 +25,12 @@ import {
 	type PermissionVerdict,
 	redactSensitiveReasonText,
 } from "../_shared/permissions.js";
-import { getPermissions, recordAudit, reloadPermissions } from "../_shared/shell-policy.js";
+import {
+	getPermissions,
+	isYoloMode,
+	recordAudit,
+	reloadPermissions,
+} from "../_shared/shell-policy.js";
 
 // ── Helper: build expansion vars ─────────────────────────────────────────────
 
@@ -69,6 +74,14 @@ export default function (pi: ExtensionAPI): void {
 	pi.on("session_start", async (_event, ctx) => {
 		currentCwd = ctx.cwd;
 
+		// Yolo mode banner
+		if (isYoloMode()) {
+			ctx.ui?.notify(
+				"⚡ YOLO mode — auto-approving tool confirmations. Hard denies still enforced.",
+				"warning"
+			);
+		}
+
 		// Eagerly load permissions to surface any config warnings at startup
 		const permissions = getPermissions(currentCwd);
 		const totalRules =
@@ -119,6 +132,10 @@ export default function (pi: ExtensionAPI): void {
 					return { block: true, reason: buildBlockReason(verdict) };
 				}
 				if (verdict.action === "ask") {
+					if (isYoloMode()) {
+						recordPermissionAudit(event.toolName, cwd, "confirmed", verdict);
+						continue;
+					}
 					const confirmed = await confirmPermission(ctx, event.toolName, agent, verdict);
 					if (!confirmed) {
 						recordPermissionAudit(event.toolName, cwd, "blocked", verdict);
@@ -142,16 +159,20 @@ export default function (pi: ExtensionAPI): void {
 		}
 
 		if (verdict.action === "ask") {
-			const specifier = getSpecifierDisplay(toolName, input, cwd);
-			const confirmed = await confirmPermission(ctx, event.toolName, specifier, verdict);
-			if (!confirmed) {
-				recordPermissionAudit(event.toolName, cwd, "blocked", verdict);
-				return {
-					block: true,
-					reason: `Permission request denied: ${buildBlockReason(verdict)}`,
-				};
+			if (isYoloMode()) {
+				recordPermissionAudit(event.toolName, cwd, "confirmed", verdict);
+			} else {
+				const specifier = getSpecifierDisplay(toolName, input, cwd);
+				const confirmed = await confirmPermission(ctx, event.toolName, specifier, verdict);
+				if (!confirmed) {
+					recordPermissionAudit(event.toolName, cwd, "blocked", verdict);
+					return {
+						block: true,
+						reason: `Permission request denied: ${buildBlockReason(verdict)}`,
+					};
+				}
+				recordPermissionAudit(event.toolName, cwd, "confirmed", verdict);
 			}
-			recordPermissionAudit(event.toolName, cwd, "confirmed", verdict);
 		}
 
 		if (verdict.action === "allow") {

package/extensions/plan-mode-tool/__tests__/index.test.ts

@@ -63,10 +63,10 @@ function registerMockTools(pi: ExtensionAPI): void {
  * @param entries - Session entries returned by sessionManager.getEntries
  * @returns Context object compatible with extension handlers
  */
-function createContext(entries: unknown[] = []): ExtensionContext {
+function createContext(entries: unknown[] = [], hasUI = true): ExtensionContext {
 	return {
 		cwd: process.cwd(),
-		hasUI: true,
+		hasUI,
 		ui: {
 			notify() {},
 			setStatus() {},
@@ -180,4 +180,34 @@ describe("plan-mode strict readonly enforcement", () => {
 		);
 		expect(blockedResult).toMatchObject({ block: true });
 	});
+
+	test("auto-enable only triggers for interactive UI input", async () => {
+		const [result] = await harness.fireEvent(
+			"input",
+			{ source: "interactive", text: "plan only fix auth" },
+			createContext([], true)
+		);
+
+		expect(result).toEqual({ action: "transform", text: "fix auth" });
+		expect(harness.api.getActiveTools()).toEqual(
+			PLAN_MODE_ALLOWED_TOOLS.filter((name) => BASELINE_TOOLS.includes(name))
+		);
+	});
+
+	test("auto-enable ignores headless or non-interactive input", async () => {
+		const [headlessResult] = await harness.fireEvent(
+			"input",
+			{ source: "interactive", text: "plan only fix auth" },
+			createContext([], false)
+		);
+		const [rpcResult] = await harness.fireEvent(
+			"input",
+			{ source: "rpc", text: "plan only fix auth" },
+			createContext([], true)
+		);
+
+		expect(headlessResult).toEqual({ action: "continue" });
+		expect(rpcResult).toEqual({ action: "continue" });
+		expect(harness.api.getActiveTools()).toEqual([...BASELINE_TOOLS]);
+	});
 });

package/extensions/plan-mode-tool/index.ts

@@ -378,13 +378,18 @@ Use action "enable" to enter plan mode, "disable" to exit, or "status" to check
 		}
 	});
 
-	// Auto-enable plan mode when user expresses planning intent in natural language
+	// Auto-enable plan mode when a human interactive session explicitly signals planning intent.
 	pi.on("input", async (event, ctx) => {
 		// No-op if already in plan mode
 		if (planModeEnabled) {
 			return { action: "continue" as const };
 		}
 
+		// Headless/orchestrated prompts should never toggle workflow modes via string matching.
+		if (!ctx.hasUI || event.source !== "interactive") {
+			return { action: "continue" as const };
+		}
+
 		if (!detectPlanIntent(event.text)) {
 			return { action: "continue" as const };
 		}

package/extensions/skill-commands/__tests__/shared-skills-dirs.test.ts

@@ -0,0 +1,113 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { resolveSharedSkillsDirsFromSettings } from "../index.js";
+
+/**
+ * Create a temporary directory for test fixtures.
+ *
+ * @returns Path to the newly created temp directory
+ */
+function createTmpDir(): string {
+	return mkdtempSync(join(tmpdir(), "skill-cmds-shared-"));
+}
+
+/**
+ * Write a settings.json file with the given content.
+ *
+ * @param dir - Directory to write settings.json into
+ * @param settings - Settings object to serialize
+ * @returns Path to the written settings.json
+ */
+function writeSettings(dir: string, settings: Record<string, unknown>): string {
+	const path = join(dir, "settings.json");
+	writeFileSync(path, JSON.stringify(settings, null, 2));
+	return path;
+}
+
+describe("resolveSharedSkillsDirsFromSettings", () => {
+	let tmp: string;
+
+	beforeEach(() => {
+		tmp = createTmpDir();
+	});
+
+	afterEach(() => {
+		rmSync(tmp, { recursive: true, force: true });
+	});
+
+	it("returns empty array when settings file does not exist", () => {
+		expect(resolveSharedSkillsDirsFromSettings(join(tmp, "nope.json"))).toEqual([]);
+	});
+
+	it("returns empty array when settings file is invalid JSON", () => {
+		const path = join(tmp, "settings.json");
+		writeFileSync(path, "not json {{");
+		expect(resolveSharedSkillsDirsFromSettings(path)).toEqual([]);
+	});
+
+	it("returns empty array when sharedSkillsDirs is missing", () => {
+		const path = writeSettings(tmp, { theme: "nord" });
+		expect(resolveSharedSkillsDirsFromSettings(path)).toEqual([]);
+	});
+
+	it("returns empty array when sharedSkillsDirs is not an array", () => {
+		const path = writeSettings(tmp, { sharedSkillsDirs: "/some/path" });
+		expect(resolveSharedSkillsDirsFromSettings(path)).toEqual([]);
+	});
+
+	it("resolves absolute paths that exist as directories", () => {
+		const skillsDir = join(tmp, "my-skills");
+		mkdirSync(skillsDir);
+		const path = writeSettings(tmp, { sharedSkillsDirs: [skillsDir] });
+
+		expect(resolveSharedSkillsDirsFromSettings(path)).toEqual([skillsDir]);
+	});
+
+	it("skips non-existent directories silently", () => {
+		const path = writeSettings(tmp, {
+			sharedSkillsDirs: [join(tmp, "does-not-exist")],
+		});
+		expect(resolveSharedSkillsDirsFromSettings(path)).toEqual([]);
+	});
+
+	it("skips paths that are files, not directories", () => {
+		const filePath = join(tmp, "not-a-dir");
+		writeFileSync(filePath, "hello");
+		const path = writeSettings(tmp, { sharedSkillsDirs: [filePath] });
+
+		expect(resolveSharedSkillsDirsFromSettings(path)).toEqual([]);
+	});
+
+	it("rejects relative paths", () => {
+		const path = writeSettings(tmp, {
+			sharedSkillsDirs: ["relative/path", "./also-relative", "no-slash"],
+		});
+		expect(resolveSharedSkillsDirsFromSettings(path)).toEqual([]);
+	});
+
+	it("rejects non-string and empty entries", () => {
+		const path = writeSettings(tmp, {
+			sharedSkillsDirs: [42, null, "", "  ", true],
+		});
+		expect(resolveSharedSkillsDirsFromSettings(path)).toEqual([]);
+	});
+
+	it("handles mixed valid and invalid entries", () => {
+		const validDir = join(tmp, "valid");
+		mkdirSync(validDir);
+		const path = writeSettings(tmp, {
+			sharedSkillsDirs: [validDir, "relative", join(tmp, "nonexistent"), 42],
+		});
+
+		expect(resolveSharedSkillsDirsFromSettings(path)).toEqual([validDir]);
+	});
+
+	it("expands tilde paths (skips when dir does not exist)", () => {
+		const path = writeSettings(tmp, {
+			sharedSkillsDirs: ["~/.nonexistent-skills-test-dir-99999"],
+		});
+		expect(resolveSharedSkillsDirsFromSettings(path)).toEqual([]);
+	});
+});

package/extensions/skill-commands/index.ts

@@ -125,24 +125,81 @@ function disableBuiltinSkillCommands(): void {
 	}
 }
 
+/**
+ * Resolve shared skill directories from global settings.
+ *
+ * Reads `sharedSkillsDirs`, tilde-expands each entry, and validates
+ * that it exists and is a directory. Mirrors the logic in `sdk.ts`
+ * so slash-command registration sees the same skills as the system prompt.
+ *
+ * @param settingsPath - Path to global settings.json
+ * @returns Array of validated, resolved directory paths
+ */
+export function resolveSharedSkillsDirsFromSettings(settingsPath: string): string[] {
+	if (!fs.existsSync(settingsPath)) return [];
+	let settings: Record<string, unknown>;
+	try {
+		settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+	} catch {
+		return [];
+	}
+	const raw = settings.sharedSkillsDirs;
+	if (!Array.isArray(raw)) return [];
+
+	const home = process.env.HOME ?? process.env.USERPROFILE ?? "~";
+	const resolved: string[] = [];
+
+	for (const entry of raw) {
+		if (typeof entry !== "string" || !entry.trim()) continue;
+		const trimmed = entry.trim();
+		let expanded: string;
+		if (trimmed === "~") {
+			expanded = home;
+		} else if (trimmed.startsWith("~/")) {
+			expanded = join(home, trimmed.slice(2));
+		} else if (trimmed.startsWith("/")) {
+			expanded = trimmed;
+		} else {
+			continue;
+		}
+		try {
+			const stats = fs.statSync(expanded);
+			if (stats.isDirectory()) resolved.push(expanded);
+		} catch {
+			// statSync failed — skip this entry
+		}
+	}
+	return resolved;
+}
+
 export default function (pi: ExtensionAPI) {
 	disableBuiltinSkillCommands();
 
+	const agentDir =
+		process.env.PI_CODING_AGENT_DIR ??
+		join(process.env.HOME ?? process.env.USERPROFILE ?? "~", ".tallow");
+	const settingsPath = join(agentDir, "settings.json");
+
+	// Shared skill directories from global settings (e.g. ~/dev/skills)
+	const sharedSkillsDirs = resolveSharedSkillsDirsFromSettings(settingsPath);
+
 	// Include .claude/skills/ directories for Claude Code compatibility
-	const claudeSkillPaths: string[] = [];
+	const extraSkillPaths: string[] = [...sharedSkillsDirs];
 	const userClaudeSkills = join(
 		process.env.HOME ?? process.env.USERPROFILE ?? "~",
 		".claude",
 		"skills"
 	);
 	const projectClaudeSkills = join(process.cwd(), ".claude", "skills");
-	if (fs.existsSync(userClaudeSkills)) claudeSkillPaths.push(userClaudeSkills);
+	if (fs.existsSync(userClaudeSkills)) extraSkillPaths.push(userClaudeSkills);
 	if (isProjectTrusted(process.cwd()) && fs.existsSync(projectClaudeSkills)) {
-		claudeSkillPaths.push(projectClaudeSkills);
+		extraSkillPaths.push(projectClaudeSkills);
 	}
 
-	// Load skills synchronously during extension init for autocomplete to work
-	const { skills } = loadSkills({ skillPaths: claudeSkillPaths });
+	// Load skills synchronously during extension init for autocomplete to work.
+	// includeDefaults: true picks up ~/.tallow/skills/ and ./skills/ (project).
+	// extraSkillPaths adds shared dirs + Claude bridge paths.
+	const { skills } = loadSkills({ agentDir, skillPaths: extraSkillPaths });
 
 	for (const skill of skills) {
 		// Validate name before registration — invalid names produce broken commands

package/extensions/slash-command-bridge/index.ts

@@ -395,7 +395,8 @@ WHEN TO USE:
 
 WHEN NOT TO USE:
 - The user already ran the command themselves
-- You want to start a new session (suggest the user run /clear instead)`,
+- You want to start a new session (suggest the user run /clear instead)
+- Context usage is below 80% — there is no need to compact proactively. Do NOT compact between tasks "just in case". Compaction destroys conversation history and should only happen when the context window is nearly full.`,
 		parameters: Type.Object({
 			command: Type.String({
 				description:
@@ -490,6 +491,34 @@ WHEN NOT TO USE:
 				}
 
 				case "compact": {
+					// Guard: reject model-initiated compact when context usage is low.
+					// The model frequently compacts proactively at 15-30% usage, wasting
+					// context and losing valuable conversation history. Only allow
+					// programmatic compact when usage exceeds 80% of the context window.
+					const compactUsage = ctx.getContextUsage?.();
+					if (
+						compactUsage &&
+						compactUsage.tokens !== null &&
+						compactUsage.tokens > 0 &&
+						compactUsage.contextWindow > 0
+					) {
+						const usagePercent = (compactUsage.tokens / compactUsage.contextWindow) * 100;
+						if (usagePercent < 80) {
+							return {
+								content: [
+									{
+										type: "text",
+										text:
+											`Context usage is only ${Math.round(usagePercent)}% — compaction is not needed yet. ` +
+											"The session has plenty of context space remaining. " +
+											"Continue working normally; compaction will happen automatically when needed.",
+									},
+								],
+								details: { command, rejected: true, usagePercent },
+							};
+						}
+					}
+
 					// Don't call ctx.compact() here — it aborts the agent mid-tool-call,
 					// orphaning the tool execution spinner (plan 95/98). Defer to a
 					// proven turn_end boundary so the tool completes normally first.

package/extensions/subagent-tool/__tests__/process-liveness.test.ts

@@ -5,7 +5,14 @@ import {
 	createWatchdogHeartbeatState,
 	evaluateWatchdogStatus,
 	type ForegroundWatchdogThresholds,
+	isWatchdogHeartbeatEventType,
 	recordWatchdogHeartbeat,
+	recordWatchdogToolCallEnd,
+	recordWatchdogToolCallStart,
+	resolveForegroundWatchdogThresholds,
+	SUBAGENT_INACTIVITY_TIMEOUT_MS_ENV,
+	SUBAGENT_STARTUP_TIMEOUT_MS_ENV,
+	SUBAGENT_TOOL_EXECUTION_TIMEOUT_MS_ENV,
 	terminateProcessWithGrace,
 } from "../process.js";
 
@@ -13,6 +20,7 @@ const TEST_THRESHOLDS: ForegroundWatchdogThresholds = {
 	inactivityTimeoutMs: 2_000,
 	killGraceMs: 50,
 	startupTimeoutMs: 1_000,
+	toolExecutionTimeoutMs: 8_000,
 };
 
 interface ManualTimer {
@@ -102,6 +110,38 @@ describe("foreground subagent liveness watchdog", () => {
 		expect(stalledStatus.phase).toBe("inactivity");
 	});
 
+	it("widens the timeout while a tool call is still running", () => {
+		let state = createWatchdogHeartbeatState(0);
+		state = recordWatchdogToolCallStart(state, 500);
+		expect(evaluateWatchdogStatus(state, 6_000, TEST_THRESHOLDS).kind).toBe("healthy");
+
+		const stalledStatus = evaluateWatchdogStatus(state, 8_600, TEST_THRESHOLDS);
+		expect(stalledStatus.kind).toBe("stalled");
+		if (stalledStatus.kind !== "stalled") return;
+		expect(stalledStatus.phase).toBe("tool_execution");
+
+		state = recordWatchdogToolCallEnd(state, 8_600);
+		expect(state.activeToolCalls).toBe(0);
+	});
+
+	it("treats message updates and tool execution events as heartbeats", () => {
+		expect(isWatchdogHeartbeatEventType("message_update")).toBe(true);
+		expect(isWatchdogHeartbeatEventType("tool_execution_start")).toBe(true);
+		expect(isWatchdogHeartbeatEventType("tool_execution_end")).toBe(true);
+		expect(isWatchdogHeartbeatEventType("tool_result_end")).toBe(false);
+	});
+
+	it("applies env overrides for watchdog thresholds", () => {
+		const thresholds = resolveForegroundWatchdogThresholds({
+			[SUBAGENT_INACTIVITY_TIMEOUT_MS_ENV]: "7000",
+			[SUBAGENT_STARTUP_TIMEOUT_MS_ENV]: "3000",
+			[SUBAGENT_TOOL_EXECUTION_TIMEOUT_MS_ENV]: "11000",
+		});
+		expect(thresholds.inactivityTimeoutMs).toBe(7_000);
+		expect(thresholds.startupTimeoutMs).toBe(3_000);
+		expect(thresholds.toolExecutionTimeoutMs).toBe(11_000);
+	});
+
 	it("stalled termination escalates and resolves without hanging", async () => {
 		const state = createWatchdogHeartbeatState(0);
 		const stalledStatus = evaluateWatchdogStatus(state, 1_001, TEST_THRESHOLDS);
@@ -134,8 +174,7 @@ describe("foreground subagent liveness watchdog", () => {
 		expect(signals).toEqual(["SIGTERM", "SIGKILL"]);
 		expect(resolvedCode).toBe(1);
 		expect(result.stopReason).toBe("stalled");
-		expect(result.errorMessage).toContain(
-			"interactive confirmation path unavailable in subagent JSON mode"
-		);
+		expect(result.errorMessage).toContain("slow provider startup");
+		expect(result.errorMessage).toContain("TALLOW_SUBAGENT_*");
 	});
 });