@dungle-scrubs/tallow 0.8.24 → 0.8.26

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"
 						);
 				}

package/extensions/tasks/index.ts

@@ -5,7 +5,7 @@
  * - Three states: pending (☐), in-progress (◉), completed (☑)
  * - Bidirectional dependency tracking (blocks/blockedBy)
  * - Comments for cross-session handoff context
- * - Team-based sharing via ~/.tallow/teams/{team-name}/tasks/
+ * - Shared task groups via ~/.tallow/task-groups/{group-name}/tasks/
  * - Multi-session coordination via fs.watch
  * - One file per task (avoids write conflicts)
  * - Status widget with dynamic sizing
@@ -15,7 +15,7 @@
  * NOTE: This extension only runs in the main Pi process, not in subagent workers.
  *
  * This file is the composition root: it constructs shared infrastructure
- * (team name, file store) and delegates all registration to
+ * (shared task-group name, file store) and delegates all registration to
  * {@link registerTasksExtension}.  Domain logic lives in sibling modules.
  */
 
@@ -43,10 +43,10 @@ export { shouldClearOnAgentEnd } from "./state/index.js";
 export default function tasksExtension(pi: ExtensionAPI): void {
 	const isSubagent = process.env.PI_IS_SUBAGENT === "1";
 
-	// Auto-generate a team name so subagents can coordinate via shared directory.
-	// Subagents inherit PI_TEAM_NAME from the lead process automatically.
+	// 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 : `team-${randomUUID().slice(0, 8)}`);
+		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;

package/extensions/tasks/state/index.ts

@@ -12,13 +12,14 @@ import {
 	mkdirSync,
 	readdirSync,
 	readFileSync,
+	renameSync,
 	rmdirSync,
 	rmSync,
 	statSync,
 	unlinkSync,
 	watch,
 } from "node:fs";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import type { AgentMessage } from "@mariozechner/pi-agent-core";
 import type { AssistantMessage, TextContent } from "@mariozechner/pi-ai";
 import { atomicWriteFileSync } from "../../_shared/atomic-write.js";
@@ -26,8 +27,11 @@ import { getTallowPath } from "../../_shared/tallow-paths.js";
 
 // ── Constants ────────────────────────────────────────────────────────────────
 
-/** Directory root for team-based shared task lists. */
-export const TEAMS_DIR = getTallowPath("teams");
+/** Directory root for shared task-group state used by tasks/subagents. */
+export const TASK_GROUPS_DIR = getTallowPath("task-groups");
+
+/** Legacy directory root from older builds before task groups were split from teams. */
+export const LEGACY_TEAMS_DIR = getTallowPath("teams");
 
 /** Max age for team directories before cleanup (7 days in ms). */
 export const TEAM_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
@@ -120,6 +124,30 @@ export function nextTaskId(state: TasksState): string {
 	return id;
 }
 
+/**
+ * Move a legacy shared-task directory into the new task-groups root.
+ *
+ * Older builds stored shared task state under `~/.tallow/teams/`, which
+ * collided conceptually with the teams runtime. New builds use
+ * `~/.tallow/task-groups/`. Migration is best-effort and intentionally silent.
+ *
+ * @param currentDirPath - New task directory path under task-groups/
+ * @param legacyDirPath - Legacy task directory path under teams/
+ * @returns void
+ */
+function migrateLegacyTaskGroupDir(currentDirPath: string, legacyDirPath: string): void {
+	if (existsSync(currentDirPath) || !existsSync(legacyDirPath)) return;
+	const currentTeamDir = dirname(currentDirPath);
+	const legacyTeamDir = dirname(legacyDirPath);
+	mkdirSync(dirname(currentTeamDir), { recursive: true });
+	try {
+		renameSync(legacyTeamDir, currentTeamDir);
+	} catch {
+		// Best-effort migration only. If this fails, the session will recreate the
+		// new directory and continue without blocking startup.
+	}
+}
+
 // ── Message helpers ──────────────────────────────────────────────────────────
 
 /**
@@ -150,15 +178,17 @@ export function getTextContent(message: AssistantMessage): string {
 /**
  * Persistent, file-backed task store for cross-session sharing.
  *
- * Each team gets a directory at `~/.tallow/teams/{team-name}/tasks/` containing
- * one JSON file per task.  `fs.watch` on the directory detects changes from
- * other sessions sharing the same team.
+ * Each shared task group gets a directory at
+ * `~/.tallow/task-groups/{group-name}/tasks/` containing one JSON file per
+ * task. `fs.watch` on the directory detects changes from other sessions
+ * sharing the same task group.
  *
  * Without a team name, this store is inactive and the extension falls back
  * to session-entry persistence.
  */
 export class TaskListStore {
 	private readonly dirPath: string | null;
+	private readonly legacyDirPath: string | null;
 	private watcher: FSWatcher | null = null;
 	private onChange: (() => void) | null = null;
 	/** Debounce timer to coalesce rapid file change events. */
@@ -172,10 +202,13 @@ export class TaskListStore {
 	constructor(teamName: string | null) {
 		if (teamName) {
 			const safeName = teamName.replace(/[^a-zA-Z0-9._-]/g, "_");
-			this.dirPath = join(TEAMS_DIR, safeName, "tasks");
+			this.dirPath = join(TASK_GROUPS_DIR, safeName, "tasks");
+			this.legacyDirPath = join(LEGACY_TEAMS_DIR, safeName, "tasks");
+			migrateLegacyTaskGroupDir(this.dirPath, this.legacyDirPath);
 			mkdirSync(this.dirPath, { recursive: true });
 		} else {
 			this.dirPath = null;
+			this.legacyDirPath = null;
 		}
 	}
 
@@ -196,14 +229,23 @@ export class TaskListStore {
 	 */
 	loadAll(): Task[] | null {
 		if (!this.dirPath) return null;
-		if (!existsSync(this.dirPath)) return [];
-
+		const hasCurrentDir = existsSync(this.dirPath);
+		const hasLegacyDir = this.legacyDirPath ? existsSync(this.legacyDirPath) : false;
+		if (!hasCurrentDir && !hasLegacyDir) return [];
+
+		const currentFiles = hasCurrentDir
+			? readdirSync(this.dirPath).filter((fileName) => fileName.endsWith(".json"))
+			: [];
+		const readDirPath =
+			currentFiles.length > 0 || !hasLegacyDir || !this.legacyDirPath
+				? this.dirPath
+				: this.legacyDirPath;
 		const tasks: Task[] = [];
 		try {
-			const files = readdirSync(this.dirPath).filter((f) => f.endsWith(".json"));
+			const files = readdirSync(readDirPath).filter((f) => f.endsWith(".json"));
 			for (const file of files) {
 				try {
-					const raw = readFileSync(join(this.dirPath, file), "utf-8");
+					const raw = readFileSync(join(readDirPath, file), "utf-8");
 					const parsed = JSON.parse(raw) as Record<string, unknown>;
 					// Migrate old schema: title → subject, dependencies → blockedBy
 					if (parsed.title && !parsed.subject) {
@@ -386,37 +428,49 @@ export class TaskListStore {
 }
 
 /**
- * Remove team directories older than {@link TEAM_MAX_AGE_MS}.
+ * Remove stale task-group directories from one root.
  *
- * Skips the current team (if any) to avoid deleting an active session.
- * Runs once per session start — errors are silently ignored.
+ * @param rootDir - Root directory containing per-group subdirectories
+ * @param currentSafeName - Sanitized active task-group name to preserve
+ * @returns void
+ */
+function cleanupStaleTaskGroupRoot(rootDir: string, currentSafeName: string | null): void {
+	if (!existsSync(rootDir)) return;
+	const now = Date.now();
+	for (const entry of readdirSync(rootDir, { withFileTypes: true })) {
+		if (!entry.isDirectory()) continue;
+		if (entry.name === currentSafeName) continue;
+
+		const taskGroupPath = join(rootDir, entry.name);
+		try {
+			// Check tasks/ subdir mtime — that's where writes happen.
+			const tasksPath = join(taskGroupPath, "tasks");
+			const target = existsSync(tasksPath) ? tasksPath : taskGroupPath;
+			const { mtimeMs } = statSync(target);
+			if (now - mtimeMs > TEAM_MAX_AGE_MS) {
+				rmSync(taskGroupPath, { recursive: true, force: true });
+			}
+		} catch {
+			// Skip individual failures (permissions, race conditions).
+		}
+	}
+}
+
+/**
+ * Remove task-group directories older than {@link TEAM_MAX_AGE_MS}.
+ *
+ * Skips the current task group (if any) to avoid deleting an active session.
+ * Runs once per session start. The legacy `~/.tallow/teams/` root is also
+ * cleaned so older builds do not leave permanent clutter behind.
  *
- * @param currentTeamName - The active team name to preserve, or null
+ * @param currentTeamName - The active shared task-group name to preserve, or null
  */
 export function cleanupStaleTeams(currentTeamName: string | null): void {
 	try {
-		if (!existsSync(TEAMS_DIR)) return;
-		const now = Date.now();
 		const currentSafeName = currentTeamName?.replace(/[^a-zA-Z0-9._-]/g, "_") ?? null;
-
-		for (const entry of readdirSync(TEAMS_DIR, { withFileTypes: true })) {
-			if (!entry.isDirectory()) continue;
-			if (entry.name === currentSafeName) continue;
-
-			const teamPath = join(TEAMS_DIR, entry.name);
-			try {
-				// Check tasks/ subdir mtime — that's where writes happen
-				const tasksPath = join(teamPath, "tasks");
-				const target = existsSync(tasksPath) ? tasksPath : teamPath;
-				const { mtimeMs } = statSync(target);
-				if (now - mtimeMs > TEAM_MAX_AGE_MS) {
-					rmSync(teamPath, { recursive: true, force: true });
-				}
-			} catch {
-				// Skip individual failures (permissions, race conditions)
-			}
-		}
+		cleanupStaleTaskGroupRoot(TASK_GROUPS_DIR, currentSafeName);
+		cleanupStaleTaskGroupRoot(LEGACY_TEAMS_DIR, currentSafeName);
 	} catch {
-		// TEAMS_DIR doesn't exist or isn't readable — nothing to clean
+		// Task-group roots don't exist or aren't readable — nothing to clean.
 	}
 }

package/extensions/teams-tool/__tests__/archive-store.test.ts

@@ -0,0 +1,98 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+	deleteArchivedTeamFromDisk,
+	getTeamArchivesDir,
+	loadAllArchivedTeamsFromDisk,
+	loadArchivedTeamFromDisk,
+	writeArchivedTeamToDisk,
+} from "../archive-store.js";
+import {
+	addTaskToBoard,
+	addTeamMessage,
+	archiveTeam,
+	createTeamStore,
+	getArchivedTeams,
+	getTeams,
+} from "../store.js";
+
+let originalTallowHome: string | undefined;
+let tmpHome: string;
+
+beforeEach(() => {
+	originalTallowHome = process.env.TALLOW_CODING_AGENT_DIR;
+	tmpHome = mkdtempSync(join(tmpdir(), "tallow-team-archives-"));
+	process.env.TALLOW_CODING_AGENT_DIR = tmpHome;
+	getArchivedTeams().clear();
+	getTeams().clear();
+});
+
+afterEach(() => {
+	getArchivedTeams().clear();
+	getTeams().clear();
+	if (originalTallowHome === undefined) {
+		delete process.env.TALLOW_CODING_AGENT_DIR;
+	} else {
+		process.env.TALLOW_CODING_AGENT_DIR = originalTallowHome;
+	}
+	rmSync(tmpHome, { force: true, recursive: true });
+});
+
+describe("team archive persistence", () => {
+	it("writes and reloads archived teams from disk", () => {
+		const team = createTeamStore("alpha");
+		addTaskToBoard(team, "Investigate", "Read files", []);
+		const message = addTeamMessage(team, "alice", "bob", "hello");
+		message.readBy.add("bob");
+
+		const archived = archiveTeam("alpha");
+		expect(archived).toBeDefined();
+		if (!archived) return;
+
+		writeArchivedTeamToDisk(archived);
+
+		const loaded = loadArchivedTeamFromDisk("alpha");
+		expect(loaded).toBeDefined();
+		expect(loaded?.name).toBe("alpha");
+		expect(loaded?.tasks).toHaveLength(1);
+		expect(loaded?.messages).toHaveLength(1);
+		expect(loaded?.messages[0].readBy.has("bob")).toBe(true);
+	});
+
+	it("lists archives newest-first", () => {
+		const first = createTeamStore("first");
+		addTaskToBoard(first, "One", "", []);
+		const archivedFirst = archiveTeam("first");
+		expect(archivedFirst).toBeDefined();
+		if (!archivedFirst) return;
+		archivedFirst.archivedAt = 1;
+		writeArchivedTeamToDisk(archivedFirst);
+
+		const second = createTeamStore("second");
+		addTaskToBoard(second, "Two", "", []);
+		const archivedSecond = archiveTeam("second");
+		expect(archivedSecond).toBeDefined();
+		if (!archivedSecond) return;
+		archivedSecond.archivedAt = 2;
+		writeArchivedTeamToDisk(archivedSecond);
+
+		const names = loadAllArchivedTeamsFromDisk().map((archive) => archive.name);
+		expect(names).toEqual(["second", "first"]);
+	});
+
+	it("deletes persisted archives", () => {
+		createTeamStore("gone");
+		const archived = archiveTeam("gone");
+		expect(archived).toBeDefined();
+		if (!archived) return;
+		writeArchivedTeamToDisk(archived);
+		expect(loadArchivedTeamFromDisk("gone")?.name).toBe("gone");
+
+		deleteArchivedTeamFromDisk("gone");
+
+		expect(loadArchivedTeamFromDisk("gone")).toBeUndefined();
+		expect(getTeamArchivesDir().startsWith(tmpHome)).toBe(true);
+	});
+});

package/extensions/teams-tool/__tests__/peer-messaging.test.ts

@@ -258,4 +258,30 @@ describe("teammate task board operations", () => {
 		expect(team.tasks[0].status).toBe("completed");
 		expect(team.tasks[0].result).toBe("Found 388 files");
 	});
+
+	it("rejects completing a task owned by another teammate", async () => {
+		const team = freshTeam();
+		const { mate: alice } = mockTeammate("alice");
+		const { mate: bob } = mockTeammate("bob");
+		team.teammates.set("alice", alice);
+		team.teammates.set("bob", bob);
+
+		const { addTaskToBoard } = await import("../store");
+		const task = addTaskToBoard(team, "Count files", "Count .ts files", []);
+		task.status = "claimed";
+		task.assignee = "alice";
+
+		const bobTools = createTeammateTools(team, "bob");
+		const tasksTool = findTool(bobTools, "team_tasks");
+		const result = await tasksTool.execute("c4", {
+			action: "complete",
+			taskId: "1",
+			result: "I should not be allowed",
+		});
+
+		expect(result.isError).toBe(true);
+		expect(result.content[0].text).toContain("Only the assignee can complete it");
+		expect(team.tasks[0].status).toBe("claimed");
+		expect(team.tasks[0].result).toBeNull();
+	});
 });