@dungle-scrubs/tallow 0.8.25 → 0.8.26

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();
+	});
 });

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

@@ -0,0 +1,200 @@
+/**
+ * Persistent archive storage for teams-tool.
+ *
+ * Archives are stored on disk so `team_resume` survives process restarts and
+ * session shutdown. Runtime state still uses the in-memory store; this module
+ * only handles serialization and persistence of archived snapshots.
+ */
+
+import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { atomicWriteFileSync } from "../_shared/atomic-write.js";
+import { getTallowPath } from "../_shared/tallow-paths.js";
+import type { ArchivedTeam, TeamMessage } from "./store.js";
+
+interface SerializedTeamMessage {
+	readonly content: string;
+	readonly from: string;
+	readonly readBy: readonly string[];
+	readonly timestamp: number;
+	readonly to: string;
+}
+
+interface SerializedArchivedTeam {
+	readonly archivedAt: number;
+	readonly messages: readonly SerializedTeamMessage[];
+	readonly name: string;
+	readonly taskCounter: number;
+	readonly tasks: ArchivedTeam["tasks"];
+}
+
+/**
+ * Resolve the directory that stores archived teams.
+ *
+ * @returns Absolute archive directory path under the active tallow home
+ */
+export function getTeamArchivesDir(): string {
+	return getTallowPath("team-archives");
+}
+
+/**
+ * Ensure the archive directory exists before reading or writing.
+ *
+ * @returns Archive directory path
+ */
+function ensureTeamArchivesDir(): string {
+	const dir = getTeamArchivesDir();
+	mkdirSync(dir, { recursive: true });
+	return dir;
+}
+
+/**
+ * Resolve the archive file path for one team name.
+ *
+ * @param teamName - Team name to encode into a stable file name
+ * @returns Absolute JSON file path
+ */
+function getArchiveFilePath(teamName: string): string {
+	return join(ensureTeamArchivesDir(), `${encodeURIComponent(teamName)}.json`);
+}
+
+/**
+ * Convert a runtime TeamMessage into a JSON-safe form.
+ *
+ * @param message - Runtime message with Set-based read tracking
+ * @returns Serializable message record
+ */
+function serializeTeamMessage(message: TeamMessage): SerializedTeamMessage {
+	return {
+		content: message.content,
+		from: message.from,
+		readBy: [...message.readBy].sort(),
+		timestamp: message.timestamp,
+		to: message.to,
+	};
+}
+
+/**
+ * Convert an archived team into a JSON-safe form.
+ *
+ * @param archived - Archived team snapshot from the runtime store
+ * @returns Serializable archive payload
+ */
+function serializeArchivedTeam(archived: ArchivedTeam): SerializedArchivedTeam {
+	return {
+		archivedAt: archived.archivedAt,
+		messages: archived.messages.map(serializeTeamMessage),
+		name: archived.name,
+		taskCounter: archived.taskCounter,
+		tasks: archived.tasks,
+	};
+}
+
+/**
+ * Convert a serialized message back into the runtime representation.
+ *
+ * @param message - JSON-parsed message payload
+ * @returns Runtime message with Set-based read tracking
+ */
+function deserializeTeamMessage(message: SerializedTeamMessage): TeamMessage {
+	return {
+		content: message.content,
+		from: message.from,
+		readBy: new Set(message.readBy),
+		timestamp: message.timestamp,
+		to: message.to,
+	};
+}
+
+/**
+ * Parse an archived-team JSON payload.
+ *
+ * @param raw - Raw JSON string from disk
+ * @returns Parsed archive, or undefined when malformed
+ */
+function deserializeArchivedTeam(raw: string): ArchivedTeam | undefined {
+	try {
+		const parsed = JSON.parse(raw) as Partial<SerializedArchivedTeam>;
+		if (
+			typeof parsed.name !== "string" ||
+			typeof parsed.archivedAt !== "number" ||
+			typeof parsed.taskCounter !== "number" ||
+			!Array.isArray(parsed.tasks) ||
+			!Array.isArray(parsed.messages)
+		) {
+			return undefined;
+		}
+		return {
+			archivedAt: parsed.archivedAt,
+			messages: parsed.messages.map((message) => deserializeTeamMessage(message)),
+			name: parsed.name,
+			taskCounter: parsed.taskCounter,
+			tasks: parsed.tasks,
+		};
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * Persist one archived team snapshot to disk.
+ *
+ * @param archived - Archived team snapshot to write
+ * @returns Nothing
+ */
+export function writeArchivedTeamToDisk(archived: ArchivedTeam): void {
+	const filePath = getArchiveFilePath(archived.name);
+	atomicWriteFileSync(filePath, JSON.stringify(serializeArchivedTeam(archived), null, 2));
+}
+
+/**
+ * Delete one archived team snapshot from disk.
+ *
+ * @param teamName - Team whose archive should be removed
+ * @returns Nothing
+ */
+export function deleteArchivedTeamFromDisk(teamName: string): void {
+	const filePath = getArchiveFilePath(teamName);
+	if (!existsSync(filePath)) return;
+	unlinkSync(filePath);
+}
+
+/**
+ * Load one archived team snapshot from disk.
+ *
+ * @param teamName - Team whose archive should be read
+ * @returns Archived snapshot, or undefined when missing or malformed
+ */
+export function loadArchivedTeamFromDisk(teamName: string): ArchivedTeam | undefined {
+	const filePath = getArchiveFilePath(teamName);
+	if (!existsSync(filePath)) return undefined;
+	try {
+		return deserializeArchivedTeam(readFileSync(filePath, "utf-8"));
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * Load all archived team snapshots from disk.
+ *
+ * Malformed files are skipped rather than crashing archive discovery.
+ * Results are sorted newest-first for status listings.
+ *
+ * @returns Archived team snapshots persisted on disk
+ */
+export function loadAllArchivedTeamsFromDisk(): ArchivedTeam[] {
+	const dir = ensureTeamArchivesDir();
+	const archives: ArchivedTeam[] = [];
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+		try {
+			const archive = deserializeArchivedTeam(readFileSync(join(dir, entry.name), "utf-8"));
+			if (!archive) continue;
+			archives.push(archive);
+		} catch {
+			// Skip unreadable archive files instead of breaking discovery.
+		}
+	}
+	return archives.sort((left, right) => right.archivedAt - left.archivedAt);
+}