@dungle-scrubs/tallow 0.8.26 → 0.8.27

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

package/extensions/upstream-check/__tests__/upstream-check.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import registerUpstream from "../index.js";
+
+describe("upstream-check extension", () => {
+	test("does not register command when packages/tallow-tui is absent", () => {
+		const tmpDir = mkdtempSync(join(tmpdir(), "upstream-test-"));
+		const originalCwd = process.cwd();
+		try {
+			process.chdir(tmpDir);
+			const commands: string[] = [];
+			const pi = {
+				registerCommand: (name: string) => {
+					commands.push(name);
+				},
+			} as unknown as ExtensionAPI;
+
+			registerUpstream(pi);
+			expect(commands).not.toContain("upstream");
+		} finally {
+			process.chdir(originalCwd);
+			rmSync(tmpDir, { recursive: true, force: true });
+		}
+	});
+
+	test("registers upstream command when packages/tallow-tui exists", () => {
+		const tmpDir = mkdtempSync(join(tmpdir(), "upstream-test-"));
+		mkdirSync(join(tmpDir, "packages", "tallow-tui"), { recursive: true });
+		const originalCwd = process.cwd();
+		try {
+			process.chdir(tmpDir);
+			const commands: string[] = [];
+			const pi = {
+				registerCommand: (name: string) => {
+					commands.push(name);
+				},
+			} as unknown as ExtensionAPI;
+
+			registerUpstream(pi);
+			expect(commands).toContain("upstream");
+		} finally {
+			process.chdir(originalCwd);
+			rmSync(tmpDir, { recursive: true, force: true });
+		}
+	});
+});

package/extensions/wezterm-notify/__tests__/index.test.ts

@@ -157,13 +157,44 @@ describe("wezterm-notify lifecycle", () => {
 		const inputResult = rig.lifecycle.onInput();
 
 		expect(inputResult).toEqual({ action: "continue" });
-		expect(getStatusWrites(rig)).toEqual(["", "working", "done", ""]);
+		// agent_end is a no-op; input transitions working → done
+		expect(getStatusWrites(rig)).toEqual(["", "working", "done"]);
 		expect(getHeartbeatWrites(rig)).toEqual(["0"]);
 		expect(rig.heartbeatStartCount).toBe(1);
 		expect(rig.heartbeatStopCount).toBe(1);
 		expect(rig.activeHeartbeatCount).toBe(0);
 	});
 
+	it("stays working through tool execution between agent_end and next agent_start", () => {
+		const rig = createLifecycleRig();
+
+		rig.lifecycle.onSessionStart();
+		rig.lifecycle.onBeforeAgentStart();
+		rig.lifecycle.onAgentStart();
+		// Model returns a tool call — agent_end fires but tool is still executing
+		rig.lifecycle.onAgentEnd();
+		rig.tickHeartbeat();
+		rig.tickHeartbeat();
+
+		// Status should still be "working" — heartbeat should still be active
+		expect(getStatusWrites(rig)).toEqual(["", "working"]);
+		expect(rig.activeHeartbeatCount).toBe(1);
+
+		// Tool finishes, next turn starts
+		rig.lifecycle.onBeforeAgentStart();
+		rig.lifecycle.onAgentStart();
+		rig.lifecycle.onAgentEnd();
+
+		// Still working — no flicker to "done" between turns
+		expect(getStatusWrites(rig)).toEqual(["", "working"]);
+		expect(rig.activeHeartbeatCount).toBe(1);
+
+		// Final input prompt appears
+		rig.lifecycle.onInput();
+		expect(getStatusWrites(rig)).toEqual(["", "working", "done"]);
+		expect(rig.activeHeartbeatCount).toBe(0);
+	});
+
 	it("coalesces duplicate starts without clear flicker", () => {
 		const rig = createLifecycleRig();
 
@@ -173,26 +204,30 @@ describe("wezterm-notify lifecycle", () => {
 		rig.lifecycle.onAgentStart();
 		rig.tickHeartbeat();
 		rig.tickHeartbeat();
+		// agent_end is a no-op — heartbeat keeps running
 		rig.lifecycle.onAgentEnd();
 
-		expect(getStatusWrites(rig)).toEqual(["", "working", "done"]);
+		expect(getStatusWrites(rig)).toEqual(["", "working"]);
 		expect(getHeartbeatWrites(rig)).toEqual(["0", "1", "2"]);
 		expect(rig.heartbeatStartCount).toBe(1);
-		expect(rig.heartbeatStopCount).toBe(1);
-		expect(rig.activeHeartbeatCount).toBe(0);
+		// Heartbeat still active (only input/shutdown stops it)
+		expect(rig.heartbeatStopCount).toBe(0);
+		expect(rig.activeHeartbeatCount).toBe(1);
 	});
 
 	it("does not permanently clear when input arrives before start", () => {
 		const rig = createLifecycleRig();
 
 		rig.lifecycle.onSessionStart();
+		// Input arrives while not working — no-op (already idle)
 		const inputResult = rig.lifecycle.onInput();
 		rig.lifecycle.onBeforeAgentStart();
 		rig.lifecycle.onAgentStart();
 		rig.lifecycle.onAgentEnd();
 
 		expect(inputResult).toEqual({ action: "continue" });
-		expect(getStatusWrites(rig)).toEqual(["", "working", "done"]);
+		// agent_end is a no-op, so status stays "working"
+		expect(getStatusWrites(rig)).toEqual(["", "working"]);
 	});
 
 	it("starts heartbeat once per interval and leaves no orphan timers", () => {
@@ -205,18 +240,21 @@ describe("wezterm-notify lifecycle", () => {
 		expect(rig.heartbeatStartCount).toBe(1);
 		expect(rig.activeHeartbeatCount).toBe(1);
 
+		// agent_end no longer stops heartbeat — stays active through tool execution
 		rig.lifecycle.onAgentEnd();
+		expect(rig.heartbeatStopCount).toBe(0);
+		expect(rig.activeHeartbeatCount).toBe(1);
+
+		// input stops the heartbeat
+		rig.lifecycle.onInput();
 		expect(rig.heartbeatStopCount).toBe(1);
 		expect(rig.activeHeartbeatCount).toBe(0);
 
-		const heartbeatAfterCompletion = getHeartbeatWrites(rig).length;
+		const heartbeatAfterInput = getHeartbeatWrites(rig).length;
 		rig.tickHeartbeat();
-		expect(getHeartbeatWrites(rig)).toHaveLength(heartbeatAfterCompletion);
-
-		rig.lifecycle.onSessionShutdown();
-		expect(rig.heartbeatStopCount).toBe(1);
-		expect(rig.activeHeartbeatCount).toBe(0);
+		expect(getHeartbeatWrites(rig)).toHaveLength(heartbeatAfterInput);
 
+		// Session shutdown also stops heartbeat cleanly
 		rig.lifecycle.onBeforeAgentStart();
 		expect(rig.heartbeatStartCount).toBe(2);
 		expect(rig.activeHeartbeatCount).toBe(1);

package/extensions/wezterm-notify/index.ts

@@ -175,11 +175,13 @@ export function createWeztermNotifyLifecycle(
 			enterWorking();
 		},
 		onAgentEnd: () => {
-			leaveWorking("done");
+			// Intentional no-op: tools may still be executing after the model
+			// finishes generating (e.g. subagent parallel runs). Stay "working"
+			// until the input prompt appears, which signals the turn is truly done.
 		},
 		onInput: () => {
-			if (!isWorking) {
-				leaveWorking("");
+			if (isWorking) {
+				leaveWorking("done");
 			}
 
 			return { action: "continue" as const };