@dungle-scrubs/tallow 0.8.25 → 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/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_*");
 	});
 });

package/extensions/subagent-tool/process.ts

@@ -448,10 +448,12 @@ export interface ForegroundWatchdogThresholds {
 	readonly inactivityTimeoutMs: number;
 	readonly killGraceMs: number;
 	readonly startupTimeoutMs: number;
+	readonly toolExecutionTimeoutMs: number;
 }
 
 /** Heartbeat state tracked by the foreground subagent liveness watchdog. */
 export interface WatchdogHeartbeatState {
+	readonly activeToolCalls: number;
 	readonly lastHeartbeatAtMs: number | null;
 	readonly startedAtMs: number;
 }
@@ -462,20 +464,86 @@ export type WatchdogStatus =
 	| {
 			readonly elapsedMs: number;
 			readonly kind: "stalled";
-			readonly phase: "inactivity" | "startup";
+			readonly phase: "inactivity" | "startup" | "tool_execution";
 			readonly timeoutMs: number;
 	  };
 
+/** Env var overriding the foreground startup timeout. */
+export const SUBAGENT_STARTUP_TIMEOUT_MS_ENV = "TALLOW_SUBAGENT_STARTUP_TIMEOUT_MS";
+
+/** Env var overriding the foreground inactivity timeout when no tool is active. */
+export const SUBAGENT_INACTIVITY_TIMEOUT_MS_ENV = "TALLOW_SUBAGENT_INACTIVITY_TIMEOUT_MS";
+
+/** Env var overriding the foreground timeout while a tool call is still running. */
+export const SUBAGENT_TOOL_EXECUTION_TIMEOUT_MS_ENV = "TALLOW_SUBAGENT_TOOL_EXECUTION_TIMEOUT_MS";
+
+/** Env var overriding the SIGTERM → SIGKILL grace window for stalled workers. */
+export const SUBAGENT_WATCHDOG_KILL_GRACE_MS_ENV = "TALLOW_SUBAGENT_WATCHDOG_KILL_GRACE_MS";
+
 /** Default watchdog thresholds used by foreground subagents in runSingleAgent. */
 export const FOREGROUND_WATCHDOG_THRESHOLDS: ForegroundWatchdogThresholds = {
-	inactivityTimeoutMs: 90_000,
+	inactivityTimeoutMs: 180_000,
 	killGraceMs: 5_000,
-	startupTimeoutMs: 30_000,
+	startupTimeoutMs: 60_000,
+	toolExecutionTimeoutMs: 600_000,
 };
 
 /** How often the foreground watchdog checks for stalled subagents. */
 const FOREGROUND_WATCHDOG_CHECK_INTERVAL_MS = 500;
 
+/** Foreground event types that count as liveness without changing tool-call state. */
+const WATCHDOG_HEARTBEAT_EVENT_TYPES = new Set([
+	"message_end",
+	"message_update",
+	"tool_execution_end",
+	"tool_execution_start",
+]);
+
+/**
+ * Parse a positive millisecond timeout override.
+ * @param rawValue - Raw env value
+ * @returns Parsed timeout in milliseconds, or undefined when invalid
+ */
+function parseTimeoutOverrideMs(rawValue: string | undefined): number | undefined {
+	if (!rawValue) return undefined;
+	const parsed = Number.parseInt(rawValue, 10);
+	if (Number.isNaN(parsed) || !Number.isFinite(parsed) || parsed <= 0) return undefined;
+	return parsed;
+}
+
+/**
+ * Resolve effective watchdog thresholds from env overrides.
+ * @param env - Environment lookup map
+ * @returns Watchdog thresholds used for this foreground worker
+ */
+export function resolveForegroundWatchdogThresholds(
+	env: EnvLookup = process.env
+): ForegroundWatchdogThresholds {
+	return {
+		inactivityTimeoutMs:
+			parseTimeoutOverrideMs(env[SUBAGENT_INACTIVITY_TIMEOUT_MS_ENV]) ??
+			FOREGROUND_WATCHDOG_THRESHOLDS.inactivityTimeoutMs,
+		killGraceMs:
+			parseTimeoutOverrideMs(env[SUBAGENT_WATCHDOG_KILL_GRACE_MS_ENV]) ??
+			FOREGROUND_WATCHDOG_THRESHOLDS.killGraceMs,
+		startupTimeoutMs:
+			parseTimeoutOverrideMs(env[SUBAGENT_STARTUP_TIMEOUT_MS_ENV]) ??
+			FOREGROUND_WATCHDOG_THRESHOLDS.startupTimeoutMs,
+		toolExecutionTimeoutMs:
+			parseTimeoutOverrideMs(env[SUBAGENT_TOOL_EXECUTION_TIMEOUT_MS_ENV]) ??
+			FOREGROUND_WATCHDOG_THRESHOLDS.toolExecutionTimeoutMs,
+	};
+}
+
+/**
+ * Return whether an event type counts as watchdog progress.
+ * @param eventType - Raw child-process event type
+ * @returns True when the event should refresh liveness
+ */
+export function isWatchdogHeartbeatEventType(eventType: string): boolean {
+	return WATCHDOG_HEARTBEAT_EVENT_TYPES.has(eventType);
+}
+
 /**
  * Create initial watchdog heartbeat state.
  * @param nowMs - Current wall-clock timestamp in milliseconds
@@ -483,6 +551,7 @@ const FOREGROUND_WATCHDOG_CHECK_INTERVAL_MS = 500;
  */
 export function createWatchdogHeartbeatState(nowMs: number): WatchdogHeartbeatState {
 	return {
+		activeToolCalls: 0,
 		lastHeartbeatAtMs: null,
 		startedAtMs: nowMs,
 	};
@@ -504,6 +573,40 @@ export function recordWatchdogHeartbeat(
 	};
 }
 
+/**
+ * Record the start of a tool call for watchdog timeout widening.
+ * @param state - Existing watchdog heartbeat state
+ * @param nowMs - Current wall-clock timestamp in milliseconds
+ * @returns Updated heartbeat state
+ */
+export function recordWatchdogToolCallStart(
+	state: WatchdogHeartbeatState,
+	nowMs: number
+): WatchdogHeartbeatState {
+	return {
+		activeToolCalls: state.activeToolCalls + 1,
+		lastHeartbeatAtMs: nowMs,
+		startedAtMs: state.startedAtMs,
+	};
+}
+
+/**
+ * Record the completion of a tool call for watchdog timeout narrowing.
+ * @param state - Existing watchdog heartbeat state
+ * @param nowMs - Current wall-clock timestamp in milliseconds
+ * @returns Updated heartbeat state
+ */
+export function recordWatchdogToolCallEnd(
+	state: WatchdogHeartbeatState,
+	nowMs: number
+): WatchdogHeartbeatState {
+	return {
+		activeToolCalls: Math.max(0, state.activeToolCalls - 1),
+		lastHeartbeatAtMs: nowMs,
+		startedAtMs: state.startedAtMs,
+	};
+}
+
 /**
  * Evaluate current liveness state against watchdog thresholds.
  * @param state - Current heartbeat state
@@ -530,12 +633,14 @@ export function evaluateWatchdogStatus(
 	}
 
 	const inactivityElapsedMs = nowMs - state.lastHeartbeatAtMs;
-	if (inactivityElapsedMs >= thresholds.inactivityTimeoutMs) {
+	const timeoutMs =
+		state.activeToolCalls > 0 ? thresholds.toolExecutionTimeoutMs : thresholds.inactivityTimeoutMs;
+	if (inactivityElapsedMs >= timeoutMs) {
 		return {
 			elapsedMs: inactivityElapsedMs,
 			kind: "stalled",
-			phase: "inactivity",
-			timeoutMs: thresholds.inactivityTimeoutMs,
+			phase: state.activeToolCalls > 0 ? "tool_execution" : "inactivity",
+			timeoutMs,
 		};
 	}
 	return { kind: "healthy" };
@@ -552,9 +657,16 @@ export function createStalledSubagentErrorMessage(
 	const timeoutSeconds = Math.max(1, Math.round(stalledStatus.timeoutMs / 1000));
 	const phaseDescription =
 		stalledStatus.phase === "startup"
-			? "no startup heartbeat was received"
-			: `no heartbeat was received for ${timeoutSeconds}s`;
-	return `Subagent stalled (${phaseDescription}). Likely deadlock: waiting for an interactive confirmation path unavailable in subagent JSON mode. Action: avoid confirmation-gated steps, pre-authorize required tools, or run this step in the parent agent.`;
+			? "no startup activity was received"
+			: stalledStatus.phase === "tool_execution"
+				? `no subagent activity was received for ${timeoutSeconds}s while a tool call was running`
+				: `no subagent activity was received for ${timeoutSeconds}s`;
+	return (
+		`Subagent stalled (${phaseDescription}). Common causes: slow provider startup, long-running tool execution without progress events, ` +
+		"or an interactive confirmation path unavailable in subagent JSON mode. " +
+		"Action: narrow task scope, avoid confirmation-gated steps, run very long commands in the parent agent, " +
+		"or increase TALLOW_SUBAGENT_* timeout env vars when slow work is legitimate."
+	);
 }
 
 /**
@@ -1251,6 +1363,7 @@ export async function runSingleAgent(
 		if (!foregroundSpawn.ok) {
 			throw new Error(foregroundSpawn.reason);
 		}
+		const watchdogThresholds = resolveForegroundWatchdogThresholds();
 		const exitCode = await new Promise<number>((resolve) => {
 			const proc = foregroundSpawn.proc;
 			if (!proc.stdout || !proc.stderr) {
@@ -1292,7 +1405,7 @@ export async function runSingleAgent(
 				if (stopRequested) return;
 				stopRequested = true;
 				stopHandle = terminateProcessWithGrace(proc, {
-					killGraceMs: FOREGROUND_WATCHDOG_THRESHOLDS.killGraceMs,
+					killGraceMs: watchdogThresholds.killGraceMs,
 					onForceResolve: () => {
 						settle(1);
 					},
@@ -1309,16 +1422,14 @@ export async function runSingleAgent(
 					return;
 				}
 
-				if (
-					event.type === "message_end" ||
-					event.type === "tool_call_start" ||
-					event.type === "tool_result_end"
-				) {
-					heartbeatState = recordWatchdogHeartbeat(heartbeatState, Date.now());
+				const nowMs = Date.now();
+				if (isWatchdogHeartbeatEventType(String(event.type))) {
+					heartbeatState = recordWatchdogHeartbeat(heartbeatState, nowMs);
 				}
 
 				// Emit subagent_tool_call when tool starts
 				if (event.type === "tool_call_start") {
+					heartbeatState = recordWatchdogToolCallStart(heartbeatState, nowMs);
 					fgTurnCount++;
 					// Hard enforcement: kill after maxTurns tool calls
 					if (agent.maxTurns && fgTurnCount >= agent.maxTurns) {
@@ -1360,6 +1471,10 @@ export async function runSingleAgent(
 					emitUpdate();
 				}
 
+				if (event.type === "tool_result_end") {
+					heartbeatState = recordWatchdogToolCallEnd(heartbeatState, nowMs);
+				}
+
 				if (event.type === "tool_result_end" && event.message) {
 					currentResult.messages.push(event.message as Message);
 					// Detect permission denials vs regular errors
@@ -1385,11 +1500,7 @@ export async function runSingleAgent(
 
 			watchdogInterval = setInterval(() => {
 				if (isResolved || stopRequested) return;
-				const status = evaluateWatchdogStatus(
-					heartbeatState,
-					Date.now(),
-					FOREGROUND_WATCHDOG_THRESHOLDS
-				);
+				const status = evaluateWatchdogStatus(heartbeatState, Date.now(), watchdogThresholds);
 				if (status.kind !== "stalled") return;
 				applyStalledClassification(currentResult, status);
 				setForegroundSubagentStatus(taskId, "stalled", piEvents);

package/extensions/tasks/__tests__/store.test.ts

@@ -3,9 +3,9 @@
  * corruption tolerance, and session-only mode.
  */
 import { afterEach, describe, expect, it } from "bun:test";
-import { existsSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { type Task, TaskListStore } from "../state/index.js";
+import { LEGACY_TEAMS_DIR, TASK_GROUPS_DIR, type Task, TaskListStore } from "../state/index.js";
 
 /**
  * Create a minimal task for store tests.
@@ -119,6 +119,30 @@ describe("TaskListStore file-backed mode", () => {
 
 		expect(ctx.store.isShared).toBe(true);
 		expect(existsSync(ctx.dir)).toBe(true);
+		expect(ctx.dir.startsWith(TASK_GROUPS_DIR)).toBe(true);
+	});
+
+	it("migrates a legacy ~/.tallow/teams task directory into task-groups", () => {
+		const teamName = `legacy-${Date.now()}`;
+		const legacyDir = join(LEGACY_TEAMS_DIR, teamName, "tasks");
+		const nextDir = join(TASK_GROUPS_DIR, teamName, "tasks");
+		mkdirSync(legacyDir, { recursive: true });
+		writeFileSync(join(legacyDir, "1.json"), JSON.stringify(makeTask("1", "From legacy")), "utf-8");
+
+		const store = new TaskListStore(teamName);
+		stores.push({
+			cleanup: () => {
+				store.deleteAll();
+				store.close();
+				rmSync(join(nextDir, ".."), { recursive: true, force: true });
+				rmSync(join(legacyDir, ".."), { recursive: true, force: true });
+			},
+		});
+
+		expect(store.path).toBe(nextDir);
+		expect(existsSync(join(nextDir, "1.json"))).toBe(true);
+		expect(existsSync(join(legacyDir, "1.json"))).toBe(false);
+		expect(store.loadAll()?.[0].subject).toBe("From legacy");
 	});
 
 	it("saveTask persists and loadAll retrieves", () => {

package/extensions/tasks/commands/register-tasks-extension.ts

@@ -1093,7 +1093,7 @@ export function registerTasksExtension(
 					case "team": {
 						const current = store.isShared ? process.env.PI_TEAM_NAME : "(none — session-only)";
 						const teamPath = store.path ?? "N/A";
-						ctx.ui.notify(`Team: ${current}\nPath: ${teamPath}`, "info");
+						ctx.ui.notify(`Shared task group: ${current}\nPath: ${teamPath}`, "info");
 						break;
 					}
 
@@ -1122,7 +1122,7 @@ export function registerTasksExtension(
 								"  delete <n>    - Delete task n\n" +
 								"  clear         - Clear all tasks\n" +
 								"  toggle        - Show/hide task widget\n" +
-								"  team          - Show current team name and path",
+								"  team          - Show current shared task group and path",
 							"info"
 						);
 				}