@dungle-scrubs/tallow 0.9.4 → 0.9.6

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

@@ -1,7 +1,140 @@
-import { describe, expect, mock, test } from "bun:test";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { AssistantMessage, ToolResultMessage, Usage } from "@mariozechner/pi-ai";
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+	ExtensionUIContext,
+	TurnEndEvent,
+} from "@mariozechner/pi-coding-agent";
+import {
+	getResetDiagnosticsForTests,
+	resetResetDiagnosticsForTests,
+} from "../../../src/reset-diagnostics.js";
+import { ExtensionHarness } from "../../../test-utils/extension-harness.js";
+import { ManualTimerScheduler } from "../../../test-utils/manual-timer-scheduler.js";
+import { registerContextForkExtension } from "../../context-fork/index.js";
+import slashCommandBridge, {
+	resetSlashCommandBridgeStateForTests,
+	setSlashCommandBridgeSchedulerForTests,
+} from "../../slash-command-bridge/index.js";
 import registerClear from "../index.js";
 
+const ZERO_USAGE: Usage = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	totalTokens: 0,
+	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+
+let harness: ExtensionHarness;
+let scheduler: ManualTimerScheduler;
+
+beforeEach(() => {
+	scheduler = new ManualTimerScheduler();
+	setSlashCommandBridgeSchedulerForTests(scheduler.runtime);
+	harness = ExtensionHarness.create();
+});
+
+afterEach(() => {
+	resetResetDiagnosticsForTests();
+	resetSlashCommandBridgeStateForTests();
+});
+
+/**
+ * Build a compact-lifecycle test context.
+ *
+ * @param overrides - Context overrides
+ * @returns Extension context
+ */
+function buildContext(overrides: Partial<ExtensionContext> = {}): ExtensionContext {
+	return {
+		ui: {} as ExtensionContext["ui"],
+		hasUI: false,
+		cwd: process.cwd(),
+		sessionManager: {} as ExtensionContext["sessionManager"],
+		modelRegistry: {} as ExtensionContext["modelRegistry"],
+		model: undefined,
+		isIdle: () => true,
+		abort: () => {},
+		hasPendingMessages: () => false,
+		shutdown: () => {},
+		getContextUsage: () => ({ contextWindow: 100, tokens: 90 }),
+		compact: () => {},
+		getSystemPrompt: () => "",
+		...overrides,
+	};
+}
+
+/**
+ * Build a realistic assistant turn_end event for compact lifecycle tests.
+ *
+ * @param stopReason - Assistant stop reason for the completed turn
+ * @returns TurnEnd event payload
+ */
+function buildAssistantTurnEnd(stopReason: AssistantMessage["stopReason"]): TurnEndEvent {
+	return {
+		type: "turn_end",
+		turnIndex: 0,
+		message: {
+			role: "assistant",
+			content: [],
+			api: "anthropic-messages",
+			provider: "mock",
+			model: "mock-model",
+			stopReason,
+			timestamp: Date.now(),
+			usage: { ...ZERO_USAGE },
+		},
+		toolResults: stopReason === "toolUse" ? [buildCompactToolResult()] : [],
+	};
+}
+
+/**
+ * Build the compact tool result payload recorded on the tool-use turn.
+ *
+ * @returns Tool result message for `run_slash_command({ command: "compact" })`
+ */
+function buildCompactToolResult(): ToolResultMessage<{ command: string }> {
+	return {
+		role: "toolResult",
+		toolCallId: "mock-tool-call",
+		toolName: "run_slash_command",
+		content: [
+			{ type: "text", text: "Session compaction will begin after this response completes." },
+		],
+		details: { command: "compact" },
+		isError: false,
+		timestamp: Date.now(),
+	};
+}
+
+interface Deferred<T> {
+	readonly promise: Promise<T>;
+	readonly reject: (error?: unknown) => void;
+	readonly resolve: (value: T) => void;
+}
+
+/**
+ * Create a deferred promise for controlling async completion timing in tests.
+ *
+ * @template T
+ * @returns Deferred promise controls
+ */
+function createDeferred<T>(): Deferred<T> {
+	let reject!: (error?: unknown) => void;
+	let resolve!: (value: T) => void;
+	const promise = new Promise<T>((innerResolve, innerReject) => {
+		resolve = innerResolve;
+		reject = innerReject;
+	});
+	return { promise, reject, resolve };
+}
+
 describe("clear extension", () => {
 	test("registers /clear command", () => {
 		const commands: Array<{ name: string; description: string }> = [];
@@ -35,4 +168,138 @@ describe("clear extension", () => {
 		await handler?.("", { newSession });
 		expect(newSession).toHaveBeenCalledTimes(1);
 	});
+
+	test("/clear cancels pending compact continuation before it can restart work", async () => {
+		await harness.loadExtension(slashCommandBridge);
+		registerClear(harness.api);
+
+		const compactTool = harness.tools.get("run_slash_command");
+		const clearCommand = harness.commands.get("clear");
+		let compactOptions: Parameters<ExtensionContext["compact"]>[0];
+		const widgetUpdates: Array<{ key: string; content: string[] | undefined }> = [];
+		const workingMessages: Array<string | undefined> = [];
+		const ctx = buildContext({
+			hasUI: true,
+			ui: {
+				setWidget: (key: string, content?: string[]) => {
+					widgetUpdates.push({ key, content });
+				},
+				setWorkingMessage: (message?: string) => {
+					workingMessages.push(message);
+				},
+			} as ExtensionUIContext,
+			compact: (options) => {
+				compactOptions = options;
+			},
+			isIdle: () => true,
+		});
+
+		if (!compactTool?.execute || !clearCommand?.handler) {
+			throw new Error("expected compact tool and clear command to be registered");
+		}
+
+		await compactTool.execute("test-call-id", { command: "compact" }, undefined, undefined, ctx);
+		await harness.fireEvent("turn_end", buildAssistantTurnEnd("toolUse"), ctx);
+		await harness.fireEvent("turn_end", buildAssistantTurnEnd("stop"), ctx);
+		compactOptions?.onComplete?.();
+
+		const newSession = mock(async () => {
+			await harness.fireEvent(
+				"session_before_switch",
+				{ type: "session_before_switch", reason: "new" },
+				ctx
+			);
+		});
+		await clearCommand.handler("", { ...ctx, newSession } as never);
+		scheduler.advanceBy(200);
+
+		expect(newSession).toHaveBeenCalledTimes(1);
+		expect(harness.sentMessages.some((message) => message.customType === "compact-continue")).toBe(
+			false
+		);
+		expect(widgetUpdates.at(-1)).toEqual({ key: "compact-progress", content: undefined });
+		expect(workingMessages.at(-1)).toBeUndefined();
+	});
+
+	test("/clear after deferred fork completion leaves the replacement session idle", async () => {
+		const commandDir = mkdtempSync(join(tmpdir(), "clear-fork-command-"));
+		const commandPath = join(commandDir, "review.md");
+		const deferred = createDeferred<{ duration: number; exitCode: number; output: string }>();
+		const workingMessages: string[] = [];
+		writeFileSync(commandPath, "Review the code.\n", "utf-8");
+
+		try {
+			registerContextForkExtension(harness.api, {
+				buildFrontmatterIndex: () =>
+					new Map([
+						[
+							"review",
+							{
+								context: "fork",
+								filePath: commandPath,
+							},
+						],
+					]),
+				loadAllAgents: () => new Map(),
+				routeForkedModel: async () => undefined,
+				spawnForkSubprocess: () => deferred.promise,
+			});
+			registerClear(harness.api);
+
+			const clearCommand = harness.commands.get("clear");
+			const ctx = buildContext({
+				hasUI: true,
+				ui: {
+					notify: () => {},
+					setWorkingMessage: (message?: string) => {
+						workingMessages.push(message ?? "");
+					},
+				} as ExtensionUIContext,
+				isIdle: () => true,
+			});
+
+			if (!clearCommand?.handler) {
+				throw new Error("expected clear command to be registered");
+			}
+
+			const [forkResult] = await harness.fireEvent("input", { text: "/review" }, ctx);
+			expect(forkResult).toEqual({ action: "handled" });
+			expect(harness.sentMessages).toHaveLength(1);
+			expect(harness.sentMessages[0]?.content).toContain("🔀 /review");
+
+			const newSession = mock(async () => {
+				await harness.fireEvent(
+					"session_before_switch",
+					{ type: "session_before_switch", reason: "new" },
+					ctx
+				);
+			});
+			await clearCommand.handler("", { ...ctx, newSession } as never);
+			deferred.resolve({ duration: 5, exitCode: 0, output: "fork done" });
+			await Promise.resolve();
+			await new Promise((resolve) => setTimeout(resolve, 0));
+
+			expect(newSession).toHaveBeenCalledTimes(1);
+			expect(workingMessages).toContain("🔀 forking: /review");
+			expect(workingMessages.at(-1)).toBe("");
+			expect(harness.sentMessages).toHaveLength(1);
+			expect(harness.sentMessages.some((message) => message.options?.triggerTurn === true)).toBe(
+				false
+			);
+
+			const diagnostics = getResetDiagnosticsForTests();
+			expect(diagnostics.some((event) => event.kind === "deferred_cancelled")).toBe(true);
+			expect(
+				diagnostics.some(
+					(event) =>
+						event.kind === "deferred_dropped" &&
+						event.source === "context-fork" &&
+						event.reason === "session_generation_mismatch"
+				)
+			).toBe(true);
+		} finally {
+			deferred.reject(new Error("cleanup"));
+			rmSync(commandDir, { force: true, recursive: true });
+		}
+	});
 });

package/extensions/command-expansion/index.ts

@@ -418,7 +418,7 @@ export function registerCommandExpansionExtension(
 
 		// Only process if it looks like a command with arguments
 		const split = splitOuterCommand(text);
-		if (!split || !split.args) {
+		if (!split?.args) {
 			return { action: "continue" as const };
 		}
 

package/extensions/context-files/index.ts

@@ -943,7 +943,11 @@ export default function contextFilesExtension(pi: ExtensionAPI) {
 		resetSessionState();
 	});
 
-	pi.on("session_switch", async () => {
+	(
+		pi as unknown as {
+			on: (event: string, handler: () => Promise<void>) => void;
+		}
+	).on("session_switch", async () => {
 		resetSessionState();
 	});
 

package/extensions/context-fork/__tests__/context-fork.test.ts

@@ -6,7 +6,7 @@ import { ExtensionHarness } from "../../../test-utils/extension-harness.js";
 import { buildFrontmatterIndex } from "../frontmatter-index.js";
 import { registerContextForkExtension } from "../index.js";
 import { resolveModel } from "../model-resolver.js";
-import type { ForkOptions } from "../spawn.js";
+import type { ForkOptions, ForkResult } from "../spawn.js";
 import { buildForkArgs } from "../spawn.js";
 
 // ── Model Resolver ──────────────────────────────────────────
@@ -503,3 +503,96 @@ describe("context-fork lazy resource initialization", () => {
 		expect(agentLoads).toBe(2);
 	});
 });
+
+interface Deferred<T> {
+	readonly promise: Promise<T>;
+	readonly reject: (error?: unknown) => void;
+	readonly resolve: (value: T) => void;
+}
+
+/**
+ * Create a deferred promise for controlling async completion timing in tests.
+ *
+ * @template T
+ * @returns Deferred promise controls
+ */
+function createDeferred<T>(): Deferred<T> {
+	let reject!: (error?: unknown) => void;
+	let resolve!: (value: T) => void;
+	const promise = new Promise<T>((innerResolve, innerReject) => {
+		resolve = innerResolve;
+		reject = innerReject;
+	});
+	return { promise, reject, resolve };
+}
+
+/**
+ * Build a minimal extension context with a mutable working-message log.
+ *
+ * @param workingMessages - Collector for working-message updates
+ * @returns Minimal extension context for context-fork tests
+ */
+function buildTestContext(workingMessages: string[]): Record<string, unknown> {
+	return {
+		cwd: process.cwd(),
+		hasUI: true,
+		isIdle: () => true,
+		model: undefined,
+		ui: {
+			notify: () => {},
+			setWorkingMessage: (message?: string) => {
+				workingMessages.push(message ?? "");
+			},
+		},
+	};
+}
+
+describe("context-fork reset boundaries", () => {
+	test("ignores late fork completion after session_before_switch", async () => {
+		const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "fork-reset-test-"));
+		const commandPath = path.join(tmpDir, "review.md");
+		const deferred = createDeferred<ForkResult>();
+		const harness = ExtensionHarness.create();
+		const workingMessages: string[] = [];
+		fs.writeFileSync(commandPath, "Review the code.\n", "utf-8");
+
+		try {
+			registerContextForkExtension(harness.api, {
+				buildFrontmatterIndex: () =>
+					new Map([
+						[
+							"review",
+							{
+								context: "fork",
+								filePath: commandPath,
+							},
+						],
+					]),
+				loadAllAgents: () => new Map(),
+				routeForkedModel: async () => undefined,
+				spawnForkSubprocess: () => deferred.promise,
+			});
+
+			const ctx = buildTestContext(workingMessages);
+			const [result] = await harness.fireEvent("input", { text: "/review" }, ctx as never);
+			expect(result).toEqual({ action: "handled" });
+			expect(harness.sentMessages).toHaveLength(1);
+			expect(harness.sentMessages[0]?.content).toContain("🔀 /review");
+
+			await harness.fireEvent(
+				"session_before_switch",
+				{ type: "session_before_switch", reason: "new" },
+				ctx as never
+			);
+			deferred.resolve({ duration: 5, exitCode: 0, output: "fork done" });
+			await Promise.resolve();
+			await new Promise((resolve) => setTimeout(resolve, 0));
+
+			expect(workingMessages).toContain("🔀 forking: /review");
+			expect(harness.sentMessages).toHaveLength(1);
+		} finally {
+			deferred.reject(new Error("cleanup"));
+			fs.rmSync(tmpDir, { recursive: true, force: true });
+		}
+	});
+});

package/extensions/context-fork/extension.json

@@ -4,7 +4,7 @@
 	"description": "Runs commands/skills with context: fork frontmatter in isolated pi subprocesses",
 	"whenToUse": "Use when a command or skill must run in an isolated forked tallow subprocess.",
 	"capabilities": {
-		"events": ["input", "session_start"]
+		"events": ["input", "session_before_switch", "session_start"]
 	},
 	"permissionSurface": {
 		"filesystem": "write",

package/extensions/context-fork/index.ts

@@ -23,6 +23,7 @@ import * as path from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { stripFrontmatter } from "@mariozechner/pi-coding-agent";
 import { Text } from "@mariozechner/pi-tui";
+import { recordResetDiagnostic } from "../../src/reset-diagnostics.js";
 import { createLazyInitializer } from "../_shared/lazy-init.js";
 import { isProjectTrusted } from "../_shared/project-trust.js";
 import { isShellInterpolationEnabled } from "../_shared/shell-policy.js";
@@ -326,6 +327,7 @@ export function registerContextForkExtension(
 
 	let frontmatterIndex: FrontmatterIndex = new Map();
 	let agents: Map<string, AgentConfig> = new Map();
+	let sessionGeneration = 0;
 
 	const debug = (...args: unknown[]) => {
 		if (process.env.DEBUG) {
@@ -375,9 +377,21 @@ export function registerContextForkExtension(
 
 	// Reset lazy state on each session start so resources reflect on-disk changes.
 	pi.on("session_start", async () => {
+		sessionGeneration += 1;
 		resetResources();
 	});
 
+	// Invalidate any in-flight fork completions before switching sessions.
+	pi.on("session_before_switch", async (_event, ctx) => {
+		sessionGeneration += 1;
+		ctx.ui?.setWorkingMessage?.();
+		recordResetDiagnostic({
+			kind: "deferred_cancelled",
+			reason: "session_before_switch",
+			source: "context-fork",
+		});
+	});
+
 	// Register custom message renderer for fork results
 	pi.registerMessageRenderer<ForkResultDetails>("fork-result", (message, _options, theme) => {
 		const details = message.details;
@@ -505,6 +519,8 @@ export function registerContextForkExtension(
 
 		// Mark as handled — prevent command-prompt/minimal-skill-display from processing
 		// We continue the fork asynchronously via the promise below
+		const forkGeneration = sessionGeneration;
+		recordResetDiagnostic({ kind: "deferred_registered", source: "context-fork" });
 		const forkPromise = dependencies.spawnForkSubprocess({
 			content,
 			cwd: ctx.cwd,
@@ -516,6 +532,14 @@ export function registerContextForkExtension(
 
 		forkPromise
 			.then((result) => {
+				if (forkGeneration !== sessionGeneration) {
+					recordResetDiagnostic({
+						kind: "deferred_dropped",
+						reason: "session_generation_mismatch",
+						source: "context-fork",
+					});
+					return;
+				}
 				ctx.ui.setWorkingMessage();
 
 				if (result.exitCode !== 0 && !result.output) {
@@ -550,6 +574,14 @@ export function registerContextForkExtension(
 				);
 			})
 			.catch((err: unknown) => {
+				if (forkGeneration !== sessionGeneration) {
+					recordResetDiagnostic({
+						kind: "deferred_dropped",
+						reason: "session_generation_mismatch",
+						source: "context-fork",
+					});
+					return;
+				}
 				ctx.ui.setWorkingMessage();
 				const message = err instanceof Error ? err.message : String(err);
 				ctx.ui.notify(`Fork /${commandName} error: ${message}`, "error");

package/extensions/edit-tool-enhanced/index.ts

@@ -14,9 +14,10 @@ import {
 	renderDiff,
 	type ThemeColor,
 } from "@mariozechner/pi-coding-agent";
-import { fileLink, hyperlink, Text } from "@mariozechner/pi-tui";
+import { Text } from "@mariozechner/pi-tui";
 import { getIcon } from "../_icons/index.js";
 import { commandExistsOnPath, runGitCommandSync } from "../_shared/shell-policy.js";
+import { fileLink, hyperlink } from "../_shared/terminal-links.js";
 import {
 	appendSection,
 	dimProcessOutputLine,

package/extensions/hooks/index.ts

@@ -1610,11 +1610,40 @@ export default function (pi: ExtensionAPI) {
 		}
 	});
 
-	// Hook into session_switch — fires after switching sessions
-	pi.on("session_switch", async (event) => {
+	// session_switch/session_fork were removed upstream in favor of session_start
+	// with a reason discriminator. Preserve hook compatibility here.
+	pi.on("session_start", async (event) => {
+		if (event.reason === "resume" || event.reason === "new") {
+			await runHooks("session_switch", {
+				reason: event.reason,
+				previousSessionFile: event.previousSessionFile,
+			});
+		}
+		if (event.reason === "fork") {
+			await runHooks("session_fork", {
+				previousSessionFile: event.previousSessionFile,
+			});
+		}
+	});
+	(
+		pi as unknown as {
+			on: (event: string, handler: (event: Record<string, unknown>) => Promise<void>) => void;
+		}
+	).on("session_switch", async (event) => {
 		await runHooks("session_switch", {
-			reason: event.reason,
-			previousSessionFile: event.previousSessionFile,
+			reason: String(event.reason ?? "resume"),
+			previousSessionFile:
+				typeof event.previousSessionFile === "string" ? event.previousSessionFile : undefined,
+		});
+	});
+	(
+		pi as unknown as {
+			on: (event: string, handler: (event: Record<string, unknown>) => Promise<void>) => void;
+		}
+	).on("session_fork", async (event) => {
+		await runHooks("session_fork", {
+			previousSessionFile:
+				typeof event.previousSessionFile === "string" ? event.previousSessionFile : undefined,
 		});
 	});
 
@@ -1631,13 +1660,6 @@ export default function (pi: ExtensionAPI) {
 		}
 	});
 
-	// Hook into session_fork — fires after forking
-	pi.on("session_fork", async (event) => {
-		await runHooks("session_fork", {
-			previousSessionFile: event.previousSessionFile,
-		});
-	});
-
 	// Hook into session_before_tree — fires before tree navigation (can cancel)
 	pi.on("session_before_tree", async (event, ctx) => {
 		const result = await runHooks(

package/extensions/loop/index.ts

@@ -798,7 +798,20 @@ export default function loopExtension(pi: ExtensionAPI): void {
 		stopLoop(ctx, "Loop stopped (session shutdown)");
 	});
 
-	pi.on("session_switch", async (_event, ctx) => {
+	pi.on("session_start", async (event, ctx) => {
+		if (event.reason !== "startup") {
+			stopLoop(ctx, `Loop stopped (session ${event.reason})`);
+		}
+	});
+
+	(
+		pi as unknown as {
+			on: (
+				event: string,
+				handler: (event: unknown, ctx: ExtensionContext) => Promise<void>
+			) => void;
+		}
+	).on("session_switch", async (_event, ctx) => {
 		stopLoop(ctx, "Loop stopped (session switch)");
 	});
 }