@dungle-scrubs/tallow 0.8.26 → 0.8.27

package/extensions/__integration__/tasks-runtime.test.ts

@@ -1,18 +1,26 @@
 import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { rmSync } from "node:fs";
+import { join } from "node:path";
 import type { ExtensionContext, ToolDefinition } from "@mariozechner/pi-coding-agent";
 import { ExtensionHarness } from "../../test-utils/extension-harness.js";
 import { registerTasksExtension } from "../tasks/commands/register-tasks-extension.js";
-import { TaskListStore } from "../tasks/state/index.js";
+import { buildSessionTaskGroupName, TASK_GROUPS_DIR, TaskListStore } from "../tasks/state/index.js";
 
 const ORIGINAL_PI_IS_SUBAGENT = process.env.PI_IS_SUBAGENT;
 const ORIGINAL_PI_TEAM_NAME = process.env.PI_TEAM_NAME;
+const TEST_TASK_GROUPS = new Set<string>();
 
 /**
  * Build a minimal extension context for direct tool execution in tests.
  *
+ * @param options - Optional session/cwd overrides
  * @returns Stub extension context
  */
-function createContext(): ExtensionContext {
+function createContext(options?: {
+	cwd?: string;
+	entries?: Array<{ type: string; customType?: string; data?: unknown }>;
+	sessionId?: string;
+}): ExtensionContext {
 	return {
 		ui: {
 			async select() {
@@ -61,10 +69,11 @@ function createContext(): ExtensionContext {
 			setToolsExpanded() {},
 		} as ExtensionContext["ui"],
 		hasUI: false,
-		cwd: process.cwd(),
+		cwd: options?.cwd ?? process.cwd(),
 		sessionManager: {
-			getEntries: () => [],
+			getEntries: () => options?.entries ?? [],
 			appendEntry: () => {},
+			getSessionId: () => options?.sessionId ?? "test-session",
 		} as never,
 		modelRegistry: {
 			getApiKeyForProvider: async () => undefined,
@@ -110,19 +119,18 @@ function getTool(harness: ExtensionHarness, name: string): ToolDefinition {
  *
  * @param tool - Registered manage_tasks tool
  * @param params - Tool parameters
+ * @param ctx - Optional extension context override
  * @returns Tool execution result
  */
 async function execManage(
 	tool: ToolDefinition,
-	params: Record<string, unknown>
+	params: Record<string, unknown>,
+	ctx = createContext()
 ): Promise<{ content: Array<{ type: string; text?: string }>; details: unknown }> {
-	return (await tool.execute(
-		"test-tool-call",
-		params as never,
-		undefined,
-		undefined,
-		createContext()
-	)) as { content: Array<{ type: string; text?: string }>; details: unknown };
+	return (await tool.execute("test-tool-call", params as never, undefined, undefined, ctx)) as {
+		content: Array<{ type: string; text?: string }>;
+		details: unknown;
+	};
 }
 
 beforeEach(() => {
@@ -131,6 +139,10 @@ beforeEach(() => {
 });
 
 afterEach(() => {
+	for (const groupName of TEST_TASK_GROUPS) {
+		rmSync(join(TASK_GROUPS_DIR, groupName), { force: true, recursive: true });
+	}
+	TEST_TASK_GROUPS.clear();
 	if (ORIGINAL_PI_IS_SUBAGENT === undefined) delete process.env.PI_IS_SUBAGENT;
 	else process.env.PI_IS_SUBAGENT = ORIGINAL_PI_IS_SUBAGENT;
 	if (ORIGINAL_PI_TEAM_NAME === undefined) delete process.env.PI_TEAM_NAME;
@@ -205,6 +217,45 @@ describe("Tasks runtime wiring", () => {
 		expect(listText).toContain("2. [in_progress] Deploy fix");
 	});
 
+	it("isolates file-backed task groups per session and reloads them on session_switch", async () => {
+		process.env.PI_IS_SUBAGENT = "0";
+		process.env.PI_TEAM_NAME = "foreign-shared-group";
+		const harness = ExtensionHarness.create();
+		registerTasksExtension(harness.api, new TaskListStore(null), null);
+		const manage = getTool(harness, "manage_tasks");
+		const ctxA = createContext({
+			cwd: "/tmp/workspace-a",
+			sessionId: "session-a",
+		});
+		const ctxB = createContext({
+			cwd: "/tmp/workspace-b",
+			sessionId: "session-b",
+		});
+		const groupA = buildSessionTaskGroupName("session-a", "/tmp/workspace-a");
+		const groupB = buildSessionTaskGroupName("session-b", "/tmp/workspace-b");
+		TEST_TASK_GROUPS.add(groupA);
+		TEST_TASK_GROUPS.add(groupB);
+
+		await harness.fireEvent("session_start", {}, ctxA);
+		expect(process.env.PI_TEAM_NAME).toBe(groupA);
+		await execManage(manage, { action: "add", task: "Task from session A" }, ctxA);
+		await execManage(manage, { action: "update", index: 1, status: "pending" }, ctxA);
+		expect(firstText(await execManage(manage, { action: "list" }, ctxA))).toContain(
+			"Task from session A"
+		);
+
+		await harness.fireEvent("session_switch", {}, ctxB);
+		expect(process.env.PI_TEAM_NAME).toBe(groupB);
+		expect(firstText(await execManage(manage, { action: "list" }, ctxB))).toBe("No tasks.");
+		await execManage(manage, { action: "add", task: "Task from session B" }, ctxB);
+		await execManage(manage, { action: "update", index: 1, status: "pending" }, ctxB);
+
+		await harness.fireEvent("session_switch", {}, ctxA);
+		const listA = firstText(await execManage(manage, { action: "list" }, ctxA));
+		expect(listA).toContain("Task from session A");
+		expect(listA).not.toContain("Task from session B");
+	});
+
 	it("injects active-task context before agent start and clears orphaned in-progress tasks on agent_end", async () => {
 		const harness = ExtensionHarness.create();
 		registerTasksExtension(harness.api, new TaskListStore(null), null);

package/extensions/_shared/lazy-init.ts

@@ -7,6 +7,9 @@ const STARTUP_TIMING_ENV = "TALLOW_STARTUP_TIMING";
 /** String values that disable startup timing when set in the env var. */
 const DISABLED_TIMING_VALUES = new Set(["0", "false", "off", "no"]);
 
+/** Maximum backoff delay in milliseconds regardless of failure count. */
+const MAX_BACKOFF_MS = 30_000;
+
 /** Initialization outcome used in timing metadata. */
 type LazyInitStatus = "ok" | "error";
 
@@ -22,9 +25,21 @@ export interface LazyInitializerOptions<TContext> {
 	readonly name: string;
 	/** One-time async initializer invoked on first use. */
 	readonly initialize: (input: LazyInitInput<TContext>) => Promise<void>;
+	/**
+	 * Maximum number of consecutive failures before the initializer is permanently
+	 * failed. Once exhausted, `ensureInitialized()` rejects immediately without
+	 * attempting initialization again. Defaults to 3.
+	 */
+	readonly maxRetries?: number;
+	/**
+	 * Base delay in milliseconds used for exponential backoff between retries.
+	 * When a retry is attempted, the remaining portion of `retryBackoffMs * 2^(failureCount - 1)`
+	 * (capped at 30 seconds) is waited before running `initialize`. Defaults to 1000.
+	 */
+	readonly retryBackoffMs?: number;
 }
 
-/** One-time lazy initializer with in-flight dedupe. */
+/** One-time lazy initializer with in-flight dedupe and circuit-breaker. */
 export interface LazyInitializer<TContext> {
 	/**
 	 * Run initialization if needed.
@@ -32,7 +47,9 @@ export interface LazyInitializer<TContext> {
 	 * - First caller executes initialize().
 	 * - Concurrent callers await the same in-flight promise.
 	 * - After success, all callers resolve immediately.
-	 * - After failure, future callers retry.
+	 * - After failure, future callers retry (respecting backoff).
+	 * - After `maxRetries` consecutive failures, rejects immediately with the last
+	 *   error and makes no further attempts until `reset()` is called.
 	 *
 	 * @param input - Trigger + context payload for initialization
 	 * @returns Promise resolved when initialization is complete
@@ -40,6 +57,8 @@ export interface LazyInitializer<TContext> {
 	ensureInitialized(input: LazyInitInput<TContext>): Promise<void>;
 	/**
 	 * Reset completion state so the next ensureInitialized() call reruns init.
+	 * Also resets the consecutive failure counter, the backoff clock, and any
+	 * permanent failure state, allowing retries to begin again from scratch.
 	 * Does not cancel an in-flight initialization.
 	 *
 	 * @returns Nothing
@@ -51,6 +70,14 @@ export interface LazyInitializer<TContext> {
 	 * @returns True when initialized
 	 */
 	isInitialized(): boolean;
+	/**
+	 * Check whether the initializer has permanently failed after exhausting all
+	 * retries. When true, `ensureInitialized()` rejects immediately without making
+	 * any further initialization attempts. Call `reset()` to clear this state.
+	 *
+	 * @returns True when permanently failed
+	 */
+	isPermanentlyFailed(): boolean;
 }
 
 /**
@@ -122,7 +149,13 @@ function emitLazyInitTiming(
 }
 
 /**
- * Create a race-safe lazy initializer with one-time execution semantics.
+ * Create a race-safe lazy initializer with one-time execution semantics,
+ * exponential backoff between retries, and a circuit-breaker that permanently
+ * fails after `maxRetries` consecutive failures.
+ *
+ * Each call to `ensureInitialized` is a single attempt. On failure the promise
+ * rejects immediately, but the next caller will wait out the remaining backoff
+ * window before running `initialize` again.
  *
  * @param options - Initializer configuration
  * @returns Lazy initializer controller
@@ -130,18 +163,58 @@ function emitLazyInitTiming(
 export function createLazyInitializer<TContext>(
 	options: LazyInitializerOptions<TContext>
 ): LazyInitializer<TContext> {
+	const maxRetries = options.maxRetries ?? 3;
+	const retryBackoffMs = options.retryBackoffMs ?? 1000;
+
 	let initialized = false;
 	let inFlight: Promise<void> | null = null;
+	let failureCount = 0;
+	let permanentError: Error | null = null;
+	/** Timestamp (via performance.now) of the most recent failure, or null. */
+	let lastFailureTimeMs: number | null = null;
 
+	/**
+	 * Compute how many milliseconds remain in the current backoff window.
+	 * Returns 0 when no backoff is needed (first call or backoff already elapsed).
+	 *
+	 * @returns Remaining backoff delay in milliseconds
+	 */
+	const remainingBackoffMs = (): number => {
+		if (failureCount === 0 || lastFailureTimeMs === null) return 0;
+		const totalBackoff = Math.min(retryBackoffMs * 2 ** (failureCount - 1), MAX_BACKOFF_MS);
+		const elapsed = performance.now() - lastFailureTimeMs;
+		return Math.max(0, totalBackoff - elapsed);
+	};
+
+	/**
+	 * Execute one initialization attempt. Waits out any remaining backoff from
+	 * the previous failure before calling `initialize`. Timing is measured over
+	 * the `initialize` call only (backoff wait is excluded). On success, resets
+	 * the failure counter. On failure, increments it and sets `permanentError`
+	 * once `maxRetries` is exhausted.
+	 *
+	 * @param input - Trigger + context payload
+	 * @returns Promise that resolves on success or rejects with a normalized Error
+	 */
 	const runInitialization = async (input: LazyInitInput<TContext>): Promise<void> => {
+		// Wait out remaining backoff from the previous failure before attempting.
+		const backoff = remainingBackoffMs();
+		if (backoff > 0) {
+			await new Promise<void>((resolve) => setTimeout(resolve, backoff));
+		}
+
 		const startedAtMs = performance.now();
 		try {
 			await options.initialize(input);
 			initialized = true;
+			failureCount = 0;
+			lastFailureTimeMs = null;
 			emitLazyInitTiming(options.name, input.trigger, performance.now() - startedAtMs, "ok");
 		} catch (error) {
 			const normalized = toError(error);
 			initialized = false;
+			failureCount++;
+			lastFailureTimeMs = performance.now();
 			emitLazyInitTiming(
 				options.name,
 				input.trigger,
@@ -149,12 +222,18 @@ export function createLazyInitializer<TContext>(
 				"error",
 				normalized
 			);
+			if (failureCount >= maxRetries) {
+				permanentError = normalized;
+			}
 			throw normalized;
 		}
 	};
 
 	return {
 		ensureInitialized(input: LazyInitInput<TContext>): Promise<void> {
+			if (permanentError) {
+				return Promise.reject(permanentError);
+			}
 			if (initialized) {
 				return Promise.resolve();
 			}
@@ -169,9 +248,15 @@ export function createLazyInitializer<TContext>(
 		},
 		reset(): void {
 			initialized = false;
+			failureCount = 0;
+			permanentError = null;
+			lastFailureTimeMs = null;
 		},
 		isInitialized(): boolean {
 			return initialized;
 		},
+		isPermanentlyFailed(): boolean {
+			return permanentError !== null;
+		},
 	};
 }

package/extensions/_shared/pid-registry.ts

@@ -16,34 +16,17 @@ import {
 	createRuntimePathProvider,
 	type RuntimePathProvider,
 } from "../../runtime/runtime-path-provider.js";
+import {
+	isPidEntry,
+	isSessionOwner,
+	type PidEntry,
+	type SessionOwner,
+	type SessionPidFile,
+	toOwnerKey,
+} from "../../src/pid-schema.js";
 import { atomicWriteFileSync } from "./atomic-write.js";
 import { acquireFileLock } from "./file-lock.js";
 
-// ─── Types (mirror src/pid-manager.ts) ──────────────────────────────────────
-
-/** Session owner identity used for per-session PID files. */
-interface SessionOwner {
-	pid: number;
-	startedAt?: string;
-}
-
-/** A single tracked child process entry. */
-interface PidEntry {
-	pid: number;
-	command: string;
-	ownerPid?: number;
-	ownerStartedAt?: string;
-	processStartedAt?: string;
-	startedAt: number;
-}
-
-/** On-disk session PID file schema (version 2). */
-interface SessionPidFile {
-	version: 2;
-	owner: SessionOwner;
-	entries: PidEntry[];
-}
-
 // ─── Owner/session path helpers ─────────────────────────────────────────────
 
 /** Cached owner identity for this process. */
@@ -89,21 +72,6 @@ function getSessionPidDir(): string {
 	return pidRegistryPathProvider.getSessionPidDir();
 }
 
-/**
- * Convert owner metadata into a filesystem-safe key.
- *
- * @param owner - Session owner identity
- * @returns Filename-safe owner key
- */
-function toOwnerKey(owner: SessionOwner): string {
-	const startedAtSlug = (owner.startedAt ?? "unknown")
-		.replace(/[^A-Za-z0-9._-]+/g, "-")
-		.replace(/-+/g, "-")
-		.replace(/^-+|-+$/g, "");
-	const normalizedStartedAt = startedAtSlug.length > 0 ? startedAtSlug : "unknown";
-	return `${owner.pid}-${normalizedStartedAt}`;
-}
-
 /**
  * Resolve the current session PID file path.
  *
@@ -150,48 +118,6 @@ function getCurrentOwnerIdentity(): SessionOwner {
 
 // ─── Validation ──────────────────────────────────────────────────────────────
 
-/**
- * Check whether a value matches the session-owner schema.
- *
- * @param value - Unknown JSON value to validate
- * @returns True when value is a valid session owner
- */
-function isSessionOwner(value: unknown): value is SessionOwner {
-	if (!value || typeof value !== "object") return false;
-	const candidate = value as Record<string, unknown>;
-	if (typeof candidate.pid !== "number") return false;
-	if (candidate.startedAt != null && typeof candidate.startedAt !== "string") {
-		return false;
-	}
-	return true;
-}
-
-/**
- * Check whether a value matches the PID entry schema.
- *
- * Supports legacy entries without owner/process identity metadata.
- *
- * @param value - Unknown JSON value to validate
- * @returns True when the value is a supported PID entry
- */
-function isPidEntry(value: unknown): value is PidEntry {
-	if (!value || typeof value !== "object") return false;
-	const candidate = value as Record<string, unknown>;
-	if (typeof candidate.pid !== "number") return false;
-	if (typeof candidate.command !== "string") return false;
-	if (typeof candidate.startedAt !== "number") return false;
-	if (candidate.ownerPid != null && typeof candidate.ownerPid !== "number") {
-		return false;
-	}
-	if (candidate.ownerStartedAt != null && typeof candidate.ownerStartedAt !== "string") {
-		return false;
-	}
-	if (candidate.processStartedAt != null && typeof candidate.processStartedAt !== "string") {
-		return false;
-	}
-	return true;
-}
-
 /**
  * Validate and normalize raw session PID file JSON.
  *

package/extensions/cheatsheet/__tests__/cheatsheet.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, test } from "bun:test";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import cheatsheet from "../index.js";
+
+describe("cheatsheet extension", () => {
+	function collectRegistrations() {
+		const commands: Array<{ name: string; description: string }> = [];
+		const pi = {
+			registerCommand: (name: string, opts: { description: string }) => {
+				commands.push({ name, description: opts.description });
+			},
+			registerMessageRenderer: () => {},
+			registerShortcut: () => {},
+			on: () => {},
+		} as unknown as ExtensionAPI;
+
+		cheatsheet(pi);
+		return { commands };
+	}
+
+	test("registers /cheatsheet command", () => {
+		const { commands } = collectRegistrations();
+		expect(commands.some((c) => c.name === "cheatsheet")).toBe(true);
+	});
+
+	test("registers /keys alias", () => {
+		const { commands } = collectRegistrations();
+		expect(commands.some((c) => c.name === "keys")).toBe(true);
+	});
+
+	test("registers /keymap alias", () => {
+		const { commands } = collectRegistrations();
+		expect(commands.some((c) => c.name === "keymap")).toBe(true);
+	});
+
+	test("registers /keybindings alias", () => {
+		const { commands } = collectRegistrations();
+		expect(commands.some((c) => c.name === "keybindings")).toBe(true);
+	});
+
+	test("all aliases have descriptions", () => {
+		const { commands } = collectRegistrations();
+		for (const cmd of commands) {
+			expect(cmd.description.length).toBeGreaterThan(0);
+		}
+	});
+});

package/extensions/clear/__tests__/clear.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, mock, test } from "bun:test";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import registerClear from "../index.js";
+
+describe("clear extension", () => {
+	test("registers /clear command", () => {
+		const commands: Array<{ name: string; description: string }> = [];
+		const pi = {
+			registerCommand: (name: string, opts: { description: string }) => {
+				commands.push({ name, description: opts.description });
+			},
+		} as unknown as ExtensionAPI;
+
+		registerClear(pi);
+
+		expect(commands).toHaveLength(1);
+		expect(commands[0].name).toBe("clear");
+		expect(commands[0].description).toContain("new session");
+	});
+
+	test("handler calls ctx.newSession()", async () => {
+		let handler: ((args: string, ctx: unknown) => Promise<void>) | undefined;
+		const pi = {
+			registerCommand: (
+				_name: string,
+				opts: { handler: (args: string, ctx: unknown) => Promise<void> }
+			) => {
+				handler = opts.handler;
+			},
+		} as unknown as ExtensionAPI;
+
+		registerClear(pi);
+
+		const newSession = mock(() => Promise.resolve());
+		await handler!("", { newSession });
+		expect(newSession).toHaveBeenCalledTimes(1);
+	});
+});

package/extensions/git-status/__tests__/git-status.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, test } from "bun:test";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import gitStatus from "../index.js";
+
+describe("git-status extension", () => {
+	test("registers session_start, tool_result, and session_shutdown handlers", () => {
+		const events: string[] = [];
+		const pi = {
+			on: (event: string) => {
+				events.push(event);
+			},
+		} as unknown as ExtensionAPI;
+
+		gitStatus(pi);
+		expect(events).toContain("session_start");
+		expect(events).toContain("tool_result");
+		expect(events).toContain("session_shutdown");
+	});
+
+	test("does not register any commands", () => {
+		const commands: string[] = [];
+		const pi = {
+			on: () => {},
+			registerCommand: (name: string) => {
+				commands.push(name);
+			},
+		} as unknown as ExtensionAPI;
+
+		gitStatus(pi);
+		expect(commands).toHaveLength(0);
+	});
+});

package/extensions/mcp-adapter-tool/index.ts

@@ -1752,7 +1752,7 @@ export default function mcpAdapter(pi: ExtensionAPI) {
 		return { systemPrompt: event.systemPrompt + lines.join("\n") };
 	});
 
-	pi.on("session_shutdown" as never, async () => {
+	pi.on("session_shutdown", async () => {
 		resetRuntimeState();
 	});
 

package/extensions/minimal-skill-display/__tests__/minimal-skill-display.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, test } from "bun:test";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import minimalSkillDisplay from "../index.js";
+
+describe("minimal-skill-display extension", () => {
+	test("registers session_start and input handlers", () => {
+		const events: string[] = [];
+		const pi = {
+			on: (event: string) => {
+				events.push(event);
+			},
+			registerCommand: () => {},
+			registerMessageRenderer: () => {},
+		} as unknown as ExtensionAPI;
+
+		minimalSkillDisplay(pi);
+		expect(events).toContain("session_start");
+		expect(events).toContain("input");
+	});
+});