@dungle-scrubs/tallow 0.8.26 → 0.8.28

package/extensions/subagent-tool/process.ts

@@ -449,6 +449,7 @@ export interface ForegroundWatchdogThresholds {
 	readonly killGraceMs: number;
 	readonly startupTimeoutMs: number;
 	readonly toolExecutionTimeoutMs: number;
+	readonly wallClockTimeoutMs: number;
 }
 
 /** Heartbeat state tracked by the foreground subagent liveness watchdog. */
@@ -464,7 +465,7 @@ export type WatchdogStatus =
 	| {
 			readonly elapsedMs: number;
 			readonly kind: "stalled";
-			readonly phase: "inactivity" | "startup" | "tool_execution";
+			readonly phase: "inactivity" | "startup" | "tool_execution" | "wall_clock";
 			readonly timeoutMs: number;
 	  };
 
@@ -477,17 +478,33 @@ export const SUBAGENT_INACTIVITY_TIMEOUT_MS_ENV = "TALLOW_SUBAGENT_INACTIVITY_TI
 /** 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 total wall-clock timeout per foreground subagent. */
+export const SUBAGENT_WALL_CLOCK_TIMEOUT_MS_ENV = "TALLOW_SUBAGENT_WALL_CLOCK_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";
 
+/** Env var overriding the total wall-clock timeout for the stalled-worker retry phase. */
+export const SUBAGENT_RETRY_PHASE_TIMEOUT_MS_ENV = "TALLOW_SUBAGENT_RETRY_PHASE_TIMEOUT_MS";
+
 /** Default watchdog thresholds used by foreground subagents in runSingleAgent. */
 export const FOREGROUND_WATCHDOG_THRESHOLDS: ForegroundWatchdogThresholds = {
-	inactivityTimeoutMs: 180_000,
+	inactivityTimeoutMs: 120_000, // 2 min without any heartbeat event
 	killGraceMs: 5_000,
-	startupTimeoutMs: 60_000,
-	toolExecutionTimeoutMs: 600_000,
+	startupTimeoutMs: 30_000, // 30s to emit first event
+	toolExecutionTimeoutMs: 300_000, // 5 min per tool call (was 10 min)
+	wallClockTimeoutMs: 480_000, // 8 min total (was 15 min)
 };
 
+/**
+ * Default total wall-clock timeout for the entire stalled-worker retry phase.
+ *
+ * Without a cap, N stalled retries × per-worker watchdog timeout can block
+ * the parent for 30+ minutes. This limits the total retry phase so the
+ * parent agent can recover sooner.
+ */
+export const DEFAULT_RETRY_PHASE_TIMEOUT_MS = 180_000; // 3 minutes
+
 /** How often the foreground watchdog checks for stalled subagents. */
 const FOREGROUND_WATCHDOG_CHECK_INTERVAL_MS = 500;
 
@@ -532,9 +549,25 @@ export function resolveForegroundWatchdogThresholds(
 		toolExecutionTimeoutMs:
 			parseTimeoutOverrideMs(env[SUBAGENT_TOOL_EXECUTION_TIMEOUT_MS_ENV]) ??
 			FOREGROUND_WATCHDOG_THRESHOLDS.toolExecutionTimeoutMs,
+		wallClockTimeoutMs:
+			parseTimeoutOverrideMs(env[SUBAGENT_WALL_CLOCK_TIMEOUT_MS_ENV]) ??
+			FOREGROUND_WATCHDOG_THRESHOLDS.wallClockTimeoutMs,
 	};
 }
 
+/**
+ * Resolve the effective retry-phase wall-clock timeout from env overrides.
+ *
+ * @param env - Environment lookup map
+ * @returns Timeout in milliseconds for the entire stalled-worker retry phase
+ */
+export function resolveRetryPhaseTimeoutMs(env: EnvLookup = process.env): number {
+	return (
+		parseTimeoutOverrideMs(env[SUBAGENT_RETRY_PHASE_TIMEOUT_MS_ENV]) ??
+		DEFAULT_RETRY_PHASE_TIMEOUT_MS
+	);
+}
+
 /**
  * Return whether an event type counts as watchdog progress.
  * @param eventType - Raw child-process event type
@@ -619,6 +652,18 @@ export function evaluateWatchdogStatus(
 	nowMs: number,
 	thresholds: ForegroundWatchdogThresholds
 ): WatchdogStatus {
+	// Wall-clock timeout: hard cap on total execution time, regardless of activity.
+	// Catches "slow but active" agents that keep making tool calls without finishing.
+	const totalElapsedMs = nowMs - state.startedAtMs;
+	if (totalElapsedMs >= thresholds.wallClockTimeoutMs) {
+		return {
+			elapsedMs: totalElapsedMs,
+			kind: "stalled",
+			phase: "wall_clock",
+			timeoutMs: thresholds.wallClockTimeoutMs,
+		};
+	}
+
 	if (state.lastHeartbeatAtMs === null) {
 		const startupElapsedMs = nowMs - state.startedAtMs;
 		if (startupElapsedMs >= thresholds.startupTimeoutMs) {
@@ -655,6 +700,15 @@ export function createStalledSubagentErrorMessage(
 	stalledStatus: Extract<WatchdogStatus, { kind: "stalled" }>
 ): string {
 	const timeoutSeconds = Math.max(1, Math.round(stalledStatus.timeoutMs / 1000));
+	const timeoutMinutes = Math.round(timeoutSeconds / 60);
+	if (stalledStatus.phase === "wall_clock") {
+		return (
+			`Subagent terminated after ${timeoutMinutes}m wall-clock timeout. ` +
+			"The agent was still active but exceeded the maximum allowed execution time. " +
+			"Action: break the task into smaller pieces, or increase " +
+			"TALLOW_SUBAGENT_WALL_CLOCK_TIMEOUT_MS for legitimately long work."
+		);
+	}
 	const phaseDescription =
 		stalledStatus.phase === "startup"
 			? "no startup activity was received"
@@ -743,6 +797,54 @@ export function terminateProcessWithGrace(
 /** Callback for streaming partial results during subagent execution. */
 export type OnUpdateCallback = (partial: AgentToolResult<SubagentDetails>) => void;
 
+// ── Subprocess Arg Construction ──────────────────────────────────────────────
+
+/** Options for building subprocess CLI arguments. */
+export interface SubprocessArgsOptions {
+	/** Session file path for persistent teammates (omit for --no-session). */
+	session?: string;
+	/** Provider-qualified model display name (e.g. "anthropic/claude-sonnet-4-6"). */
+	modelDisplayName?: string;
+	/** Effective tool allowlist (already filtered by denylist). */
+	tools?: string[];
+	/** Skill names to pass via --skill flags. */
+	skills?: string[];
+	/** Path to temp file containing the system prompt. */
+	systemPromptPath?: string;
+	/** Task text (will be prefixed with "Task: "). */
+	task: string;
+}
+
+/**
+ * Build the CLI argument array for a subagent child process.
+ *
+ * **Invariant:** `-p <task>` is always the last pair in the array.
+ * Commander consumes the next token after `-p` as its required `<prompt>`
+ * value. Placing `-p` before other flags (e.g. `--no-session`) causes
+ * Commander to swallow the flag as the prompt text, leaving the real
+ * task as a stray positional argument.
+ *
+ * @param opts - Subprocess argument options
+ * @returns CLI argument array safe for child_process.spawn
+ */
+export function buildSubprocessArgs(opts: SubprocessArgsOptions): string[] {
+	const args: string[] = opts.session
+		? ["--mode", "json", "--session", opts.session]
+		: ["--mode", "json", "--no-session"];
+
+	if (opts.modelDisplayName) args.push("--model", opts.modelDisplayName);
+	if (opts.tools && opts.tools.length > 0) args.push("--tools", opts.tools.join(","));
+	if (opts.skills && opts.skills.length > 0) {
+		for (const skill of opts.skills) args.push("--skill", skill);
+	}
+	if (opts.systemPromptPath) args.push("--append-system-prompt", opts.systemPromptPath);
+
+	// CRITICAL: -p must be last — see JSDoc above.
+	args.push("-p", `Task: ${opts.task}`);
+
+	return args;
+}
+
 // ── Background Spawning ──────────────────────────────────────────────────────
 
 /**
@@ -813,18 +915,6 @@ export async function spawnBackgroundSubagent(
 	const agent = { ...resolved.agent, model: routing.model.id };
 	const agentSource = resolved.resolution === "ephemeral" ? ("ephemeral" as const) : agent.source;
 
-	const args: string[] = session
-		? ["--mode", "json", "-p", "--session", session]
-		: ["--mode", "json", "-p", "--no-session"];
-	// Use provider-qualified name (e.g. "openai-codex/gpt-5.1") so the child process
-	// resolves to the exact provider the router selected, not just the first match.
-	if (agent.model) args.push("--model", routing.model.displayName);
-	const effectiveTools = computeEffectiveTools(agent.tools, agent.disallowedTools);
-	if (effectiveTools && effectiveTools.length > 0) args.push("--tools", effectiveTools.join(","));
-	if (agent.skills && agent.skills.length > 0) {
-		for (const skill of agent.skills) args.push("--skill", skill);
-	}
-
 	let tmpPromptDir: string | undefined;
 	let tmpPromptPath: string | undefined;
 
@@ -839,7 +929,6 @@ export async function spawnBackgroundSubagent(
 		const tmp = writePromptToTempFile(agent.name, systemPrompt);
 		tmpPromptDir = tmp.dir;
 		tmpPromptPath = tmp.filePath;
-		args.push("--append-system-prompt", tmpPromptPath);
 	}
 
 	let expandedTask: string;
@@ -850,7 +939,16 @@ export async function spawnBackgroundSubagent(
 		const reason = error instanceof Error ? error.message : String(error);
 		return `Failed to expand task references for ${agentName}: ${reason}`;
 	}
-	args.push(`Task: ${expandedTask}`);
+
+	const effectiveTools = computeEffectiveTools(agent.tools, agent.disallowedTools);
+	const args = buildSubprocessArgs({
+		session,
+		modelDisplayName: agent.model ? routing.model.displayName : undefined,
+		tools: effectiveTools && effectiveTools.length > 0 ? effectiveTools : undefined,
+		skills: agent.skills && agent.skills.length > 0 ? agent.skills : undefined,
+		systemPromptPath: tmpPromptPath,
+		task: expandedTask,
+	});
 
 	const childEnv: Record<string, string> = { ...process.env, PI_IS_SUBAGENT: "1" } as Record<
 		string,
@@ -951,8 +1049,13 @@ export async function spawnBackgroundSubagent(
 		buffer = lines.pop() || "";
 		for (const line of lines) {
 			if (!line.trim()) continue;
+			// Strip leading terminal escape sequences — see foreground processLine.
+			let cleaned = line;
+			const jsonStart = cleaned.indexOf("{");
+			if (jsonStart > 0) cleaned = cleaned.slice(jsonStart);
+			else if (jsonStart < 0) continue;
 			try {
-				const event = JSON.parse(line);
+				const event = JSON.parse(cleaned);
 
 				// Emit subagent_tool_call when tool starts
 				if (event.type === "tool_call_start") {
@@ -1022,13 +1125,18 @@ export async function spawnBackgroundSubagent(
 
 	proc.on("close", (code) => {
 		if (buffer.trim()) {
-			try {
-				const event = JSON.parse(buffer);
-				if (event.type === "message_end" && event.message) {
-					result.messages.push(event.message);
+			let cleaned = buffer;
+			const jsonStart = cleaned.indexOf("{");
+			if (jsonStart > 0) cleaned = cleaned.slice(jsonStart);
+			if (jsonStart >= 0) {
+				try {
+					const event = JSON.parse(cleaned);
+					if (event.type === "message_end" && event.message) {
+						result.messages.push(event.message);
+					}
+				} catch {
+					/* ignore */
 				}
-			} catch {
-				/* ignore */
 			}
 		}
 		const finalOutput = getFinalOutput(result.messages);
@@ -1236,18 +1344,6 @@ export async function runSingleAgent(
 		background: false,
 	} satisfies SubagentStartEvent);
 
-	const args: string[] = session
-		? ["--mode", "json", "-p", "--session", session]
-		: ["--mode", "json", "-p", "--no-session"];
-	// Use provider-qualified name so the child process resolves to the exact provider.
-	if (agent.model) args.push("--model", routing.model.displayName);
-	const fgEffectiveTools = computeEffectiveTools(agent.tools, agent.disallowedTools);
-	if (fgEffectiveTools && fgEffectiveTools.length > 0)
-		args.push("--tools", fgEffectiveTools.join(","));
-	if (agent.skills && agent.skills.length > 0) {
-		for (const skill of agent.skills) args.push("--skill", skill);
-	}
-
 	let tmpPromptDir: string | null = null;
 	let tmpPromptPath: string | null = null;
 
@@ -1290,6 +1386,7 @@ export async function runSingleAgent(
 		},
 		model: agent.model,
 		step,
+		startTime: Date.now(),
 	};
 
 	/** Timestamp of the last emitted update, used for throttling. */
@@ -1327,11 +1424,18 @@ export async function runSingleAgent(
 			const tmp = writePromptToTempFile(agent.name, fgSystemPrompt);
 			tmpPromptDir = tmp.dir;
 			tmpPromptPath = tmp.filePath;
-			args.push("--append-system-prompt", tmpPromptPath);
 		}
 
 		const expandedTask = await expandFileReferences(task, effectiveCwd);
-		args.push(`Task: ${expandedTask}`);
+		const fgEffectiveTools = computeEffectiveTools(agent.tools, agent.disallowedTools);
+		const args = buildSubprocessArgs({
+			session,
+			modelDisplayName: agent.model ? routing.model.displayName : undefined,
+			tools: fgEffectiveTools && fgEffectiveTools.length > 0 ? fgEffectiveTools : undefined,
+			skills: agent.skills && agent.skills.length > 0 ? agent.skills : undefined,
+			systemPromptPath: tmpPromptPath ?? undefined,
+			task: expandedTask,
+		});
 		let wasAborted = false;
 
 		const fgChildEnv: Record<string, string> = {
@@ -1414,10 +1518,18 @@ export async function runSingleAgent(
 
 			const processLine = (line: string) => {
 				if (!line.trim()) return;
+				// Strip leading terminal escape sequences (e.g. OSC 1337 SetUserVar)
+				// that may leak into stdout when extensions write directly to
+				// process.stdout in JSON-mode child processes. Without this,
+				// JSON.parse silently fails and heartbeat events are lost.
+				let cleaned = line;
+				const jsonStart = cleaned.indexOf("{");
+				if (jsonStart > 0) cleaned = cleaned.slice(jsonStart);
+				else if (jsonStart < 0) return;
 				// biome-ignore lint/suspicious/noExplicitAny: pi subagent JSON protocol has dynamic shape
 				let event: Record<string, any>;
 				try {
-					event = JSON.parse(line);
+					event = JSON.parse(cleaned);
 				} catch {
 					return;
 				}

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

@@ -32,6 +32,7 @@ import {
 import { findCompletedTasks } from "../parsing/index.js";
 import {
 	type BgTaskView,
+	buildSessionTaskGroupName,
 	cleanupStaleTeams,
 	getTextContent,
 	isAssistantMessage,
@@ -41,7 +42,7 @@ import {
 	shouldClearOnAgentEnd,
 	type Task,
 	type TaskComment,
-	type TaskListStore,
+	TaskListStore,
 	type TaskStatus,
 	type TasksState,
 	type TeamWidgetView,
@@ -75,15 +76,17 @@ const agentIdentities = new Map<string, AgentIdentity>();
  * Registers task management tools, commands, and widget.
  *
  * @param pi - Extension API for registering tools, commands, and event handlers
- * @param store - Pre-constructed {@link TaskListStore} for file persistence
- * @param teamName - Active team name (or null for session-only mode)
+ * @param initialStore - Initial {@link TaskListStore} for file persistence
+ * @param initialTeamName - Active team name (or null for session-only mode)
  */
 export function registerTasksExtension(
 	pi: ExtensionAPI,
-	store: TaskListStore,
-	teamName: string | null
+	initialStore: TaskListStore,
+	initialTeamName: string | null
 ): void {
 	const isSubagent = process.env.PI_IS_SUBAGENT === "1";
+	let store = initialStore;
+	let teamName = initialTeamName;
 	const state: TasksState = {
 		tasks: [],
 		visible: true,
@@ -1023,9 +1026,7 @@ export function registerTasksExtension(
 								return `${t.id}. ${icon} ${t.subject}${blocked}${comments}`;
 							})
 							.join("\n");
-						const mode = store.isShared
-							? ` [team: ${process.env.PI_TEAM_NAME}]`
-							: " [session-only]";
+						const mode = store.isShared ? ` [team: ${teamName}]` : " [session-only]";
 						ctx.ui.notify(`Tasks${mode}:\n${list}`, "info");
 						break;
 					}
@@ -1091,7 +1092,7 @@ export function registerTasksExtension(
 					}
 
 					case "team": {
-						const current = store.isShared ? process.env.PI_TEAM_NAME : "(none — session-only)";
+						const current = store.isShared ? teamName : "(none — session-only)";
 						const teamPath = store.path ?? "N/A";
 						ctx.ui.notify(`Shared task group: ${current}\nPath: ${teamPath}`, "info");
 						break;
@@ -1916,8 +1917,37 @@ Before calling manage_tasks complete/update, call manage_tasks list first so ind
 	let lastBgCount = 0;
 	let lastBgTaskCount = 0;
 
-	// Restore state on session start
-	pi.on("session_start", async (_event, ctx) => {
+	/** Resolve the shared task-group name for the current session context.
+	 * @param ctx - Active extension context
+	 * @returns Shared task-group name, or null for session-only mode
+	 */
+	function resolveTaskGroupName(ctx: ExtensionContext): string | null {
+		if (isSubagent) return process.env.PI_TEAM_NAME ?? teamName;
+		const sessionId = ctx.sessionManager.getSessionId?.();
+		if (!sessionId) return null;
+		return buildSessionTaskGroupName(sessionId, ctx.cwd);
+	}
+	/** Rebind the file-backed task store for the current session.
+	 * @param ctx - Active extension context
+	 * @returns Nothing
+	 */
+	function syncTaskGroupStore(ctx: ExtensionContext): void {
+		const nextTeamName = resolveTaskGroupName(ctx);
+		store.close();
+		if (nextTeamName !== teamName) {
+			store = new TaskListStore(nextTeamName);
+			teamName = nextTeamName;
+		}
+		if (!isSubagent) {
+			if (teamName) process.env.PI_TEAM_NAME = teamName;
+			else delete process.env.PI_TEAM_NAME;
+		}
+	}
+
+	/** Reset runtime widget/session state before loading a different session.
+	 * @returns Nothing
+	 */
+	function resetSessionState(): void {
 		foregroundSubagents = [];
 		backgroundSubagents = [];
 		backgroundTasks = [];
@@ -1926,7 +1956,21 @@ Before calling manage_tasks complete/update, call manage_tasks list first so ind
 		lastBackgroundTaskPresenterState = null;
 		lastBgCount = 0;
 		lastBgTaskCount = 0;
+		agentActivity.clear();
+		agentIdentities.clear();
+		state.tasks = [];
+		state.visible = true;
+		state.nextId = 1;
+		state.activeTaskId = null;
+	}
 
+	/** Restore tasks/widget state for the current session or switched session.
+	 * @param ctx - Active extension context
+	 * @returns Nothing
+	 */
+	function restoreSessionState(ctx: ExtensionContext): void {
+		resetSessionState();
+		syncTaskGroupStore(ctx);
 		// Restore meta state (visibility, nextId) from session entries
 		const entries = ctx.sessionManager.getEntries();
 		const stateEntry = entries
@@ -1947,14 +1991,11 @@ Before calling manage_tasks complete/update, call manage_tasks list first so ind
 		// Load tasks: prefer file store (shared mode), fall back to session entries
 		if (store.isShared) {
 			loadFromStore();
-
-			// Start watching for cross-session changes
 			store.watch(() => {
 				loadFromStore();
 				updateWidget(ctx);
 			});
 		} else if (stateEntry?.data?.tasks) {
-			// Session-only mode: restore from entries, migrating old schema
 			state.tasks = stateEntry.data.tasks.map((t) => ({
 				id: (t.id as string) ?? String(state.nextId++),
 				subject: (t.subject as string) ?? (t.title as string) ?? "Untitled",
@@ -1969,15 +2010,10 @@ Before calling manage_tasks complete/update, call manage_tasks list first so ind
 				createdAt: (t.createdAt as number) ?? Date.now(),
 				completedAt: t.completedAt as number | undefined,
 			}));
-			// Recalculate nextId
 			const maxId = state.tasks.reduce((max, t) => Math.max(max, Number(t.id) || 0), 0);
 			state.nextId = Math.max(state.nextId, maxId + 1);
 		}
 
-		// Clear orphaned tasks on startup: at session_start no agents are running,
-		// so any in_progress tasks are leftovers from a dead session.
-		// Also clear if all tasks are already completed — the 2s auto-clear timer
-		// from a previous turn may have been killed by an extension reload.
 		if (state.tasks.length > 0) {
 			const orphaned = state.tasks.filter((t) => t.status === "in_progress");
 			const allCompleted = state.tasks.every((t) => t.status === "completed");
@@ -1986,7 +2022,6 @@ Before calling manage_tasks complete/update, call manage_tasks list first so ind
 			}
 		}
 
-		// Clean up team directories older than 7 days
 		cleanupStaleTeams(teamName);
 
 		if (!isSubagent) {
@@ -2131,6 +2166,14 @@ Before calling manage_tasks complete/update, call manage_tasks list first so ind
 
 		updateWidget(ctx);
 		updateAgentBar(ctx);
+	}
+
+	pi.on("session_start", async (_event, ctx) => {
+		restoreSessionState(ctx);
+	});
+
+	pi.on("session_switch", async (_event, ctx) => {
+		restoreSessionState(ctx);
 	});
 
 	// Cleanup on session end
@@ -2150,6 +2193,7 @@ Before calling manage_tasks complete/update, call manage_tasks list first so ind
 		legacyInteropBridgeCleanup?.();
 		legacyInteropBridgeCleanup = undefined;
 		store.close();
+		if (!isSubagent) delete process.env.PI_TEAM_NAME;
 		persistState();
 	});
 }

package/extensions/tasks/extension.json

@@ -11,6 +11,7 @@
 			"before_agent_start",
 			"session_shutdown",
 			"session_start",
+			"session_switch",
 			"subagent_start",
 			"subagent_stop",
 			"subagent_tool_call",

package/extensions/tasks/index.ts

@@ -19,7 +19,6 @@
  * {@link registerTasksExtension}.  Domain logic lives in sibling modules.
  */
 
-import { randomUUID } from "node:crypto";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { registerTasksExtension } from "./commands/register-tasks-extension.js";
 import { TaskListStore } from "./state/index.js";
@@ -31,7 +30,7 @@ export type { AgentIdentity } from "./agents/index.js";
 export { classifyAgent } from "./agents/index.js";
 export { _extractTasksFromText, escapeRegex, findCompletedTasks } from "./parsing/index.js";
 export type { Task, TaskComment, TaskStatus, TasksState } from "./state/index.js";
-export { shouldClearOnAgentEnd } from "./state/index.js";
+export { buildSessionTaskGroupName, shouldClearOnAgentEnd } from "./state/index.js";
 
 // ── Entry point ──────────────────────────────────────────────────────────────
 
@@ -42,16 +41,7 @@ export { shouldClearOnAgentEnd } from "./state/index.js";
  */
 export default function tasksExtension(pi: ExtensionAPI): void {
 	const isSubagent = process.env.PI_IS_SUBAGENT === "1";
-
-	// Auto-generate a shared task-group name so subagents can coordinate via a
-	// file-backed store. PI_TEAM_NAME stays as the env var for backward compatibility.
-	const teamName =
-		process.env.PI_TEAM_NAME ?? (isSubagent ? null : `task-group-${randomUUID().slice(0, 8)}`);
-	if (teamName && !process.env.PI_TEAM_NAME) {
-		// Set on process.env so child subagents inherit it automatically
-		process.env.PI_TEAM_NAME = teamName;
-	}
-
+	const teamName = isSubagent ? (process.env.PI_TEAM_NAME ?? null) : null;
 	const store = new TaskListStore(teamName);
 	registerTasksExtension(pi, store, teamName);
 }

package/extensions/tasks/state/index.ts

@@ -6,6 +6,7 @@
  * locking and `fs.watch`, and pure predicates that operate on task arrays.
  */
 
+import { createHash } from "node:crypto";
 import type { FSWatcher } from "node:fs";
 import {
 	existsSync,
@@ -39,6 +40,31 @@ export const TEAM_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 /** Minimum width for side-by-side layout (tasks left, subagents right). */
 export const MIN_SIDE_BY_SIDE_WIDTH = 120;
 
+/** Prefix used for session-scoped shared task-group directories. */
+const SESSION_TASK_GROUP_PREFIX = "task-group";
+
+/**
+ * Build a stable task-group name for a session/cwd pair.
+ *
+ * Main sessions use this to isolate task boards per session while keeping the
+ * same group name when the user reopens the same session later. Subagents
+ * inherit the resolved name via `PI_TEAM_NAME`.
+ *
+ * @param sessionId - Current session identifier
+ * @param cwd - Current working directory for the session
+ * @returns Stable, filesystem-safe task-group name
+ */
+export function buildSessionTaskGroupName(sessionId: string, cwd: string): string {
+	const safeSessionId =
+		sessionId
+			.replace(/[^a-zA-Z0-9._-]/g, "_")
+			.replace(/_+/g, "_")
+			.replace(/^_+|_+$/g, "")
+			.slice(0, 24) || "session";
+	const digest = createHash("sha256").update(`${sessionId}:${cwd}`).digest("hex").slice(0, 12);
+	return `${SESSION_TASK_GROUP_PREFIX}-${safeSessionId}-${digest}`;
+}
+
 // ── Task Types ───────────────────────────────────────────────────────────────
 
 /** Lifecycle state of a task. */

package/extensions/teams-tool/dashboard.ts

@@ -692,7 +692,19 @@ export class TeamDashboardEditor extends CustomEditor {
 		);
 
 		const footer = this.renderFooter(width);
-		return [...merged, footer];
+		const contentLines = [...merged, footer];
+
+		// Pad to fill the terminal height. On the alternate screen the TUI
+		// renders all children (header, chat history, widgets, editor, footer)
+		// and the visible viewport is the last `rows` lines. Without padding,
+		// stale conversation content bleeds through at the top of the dashboard.
+		// Prepending blank lines pushes that content off-screen.
+		const targetLines = this.tui.terminal.rows;
+		while (contentLines.length < targetLines) {
+			contentLines.unshift("");
+		}
+
+		return contentLines;
 	}
 
 	/**

package/extensions/teams-tool/sessions/spawn.ts

@@ -15,7 +15,7 @@ import {
 	SessionManager,
 	SettingsManager,
 } from "@mariozechner/pi-coding-agent";
-import { applyKnownModelMetadataOverrides } from "../../../src/model-metadata-overrides.js";
+import { applyKnownModelMetadataOverrides } from "../../../runtime/model-metadata-overrides.js";
 import { getTallowHomeDir, getTallowPath } from "../../_shared/tallow-paths.js";
 import {
 	type AgentConfig,
@@ -255,7 +255,7 @@ export async function spawnTeammateSession(
 	// Use the user's tallow auth and model config so teammates inherit
 	// API keys and custom model definitions from the main session.
 	const authStorage = AuthStorage.create(getTallowPath("auth.json"));
-	const modelRegistry = new ModelRegistry(authStorage, getTallowPath("models.json"));
+	const modelRegistry = ModelRegistry.create(authStorage, getTallowPath("models.json"));
 	applyKnownModelMetadataOverrides(modelRegistry);
 	const model = modelRegistry.find(resolvedModel.provider, resolvedModel.id);
 	if (!model) {

package/extensions/teams-tool/tools/register-extension.ts

@@ -232,8 +232,11 @@ export function registerTeamsToolExtension(pi: ExtensionAPI): void {
 	 */
 	function handleDashboardEscape(ctx: ExtensionContext): void {
 		if (!dashboardEnabled) return;
+		const hasActiveTeams = (getTeams() as Map<string, unknown>).size > 0;
 		disableDashboard(ctx, false);
-		ctx.ui.notify("Team dashboard disabled. Teammates keep running.", "info");
+		if (hasActiveTeams) {
+			ctx.ui.notify("Team dashboard disabled. Teammates keep running.", "info");
+		}
 	}
 
 	/**
@@ -283,7 +286,12 @@ export function registerTeamsToolExtension(pi: ExtensionAPI): void {
 		ctx.ui.setEditorComponent(undefined);
 		ctx.ui.setWorkingMessage();
 		ctx.ui.setStatus("team-dashboard", undefined);
-		if (notify) ctx.ui.notify("Team dashboard disabled.", "info");
+		// Only notify when there are active teams — the notification is
+		// confusing when it appears during unrelated flows (e.g. subagent
+		// parallel) because the dashboard auto-disabled as a side effect.
+		if (notify && (getTeams() as Map<string, unknown>).size > 0) {
+			ctx.ui.notify("Team dashboard disabled.", "info");
+		}
 	}
 
 	/**