@dungle-scrubs/tallow 0.9.4 → 0.9.7

package/extensions/_shared/shell-policy.ts

@@ -14,7 +14,7 @@
  * - audit trail recording
  */
 
-import { spawnSync } from "node:child_process";
+import { execFile, spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join } from "node:path";
@@ -1106,6 +1106,102 @@ export function runCommandSync(options: RunCommandOptions): ProcessRunResult {
 	};
 }
 
+/**
+ * Run a non-shell process asynchronously with centralized policy and audit logging.
+ *
+ * @param options - Process invocation options
+ * @returns Structured process result including policy-blocked state
+ */
+export async function runCommand(options: RunCommandOptions): Promise<ProcessRunResult> {
+	const commandLine = [options.command, ...options.args].join(" ").trim();
+	const verdict = evaluateCommand(commandLine, options.source, options.cwd);
+	if (!verdict.allowed) {
+		recordAudit({
+			timestamp: Date.now(),
+			command: verdict.normalizedCommand,
+			source: options.source,
+			trustLevel: verdict.trustLevel,
+			cwd: options.cwd,
+			outcome: "blocked",
+			reason: verdict.reason,
+		});
+		return {
+			ok: false,
+			blocked: true,
+			stdout: "",
+			stderr: "",
+			exitCode: null,
+			reason: verdict.reason,
+		};
+	}
+
+	const timeoutMs = clampTimeout(options.timeoutMs);
+	const startedAt = Date.now();
+
+	return await new Promise((resolve) => {
+		execFile(
+			options.command,
+			[...options.args],
+			{
+				cwd: options.cwd,
+				encoding: "utf-8",
+				timeout: timeoutMs,
+				maxBuffer: options.maxBuffer ?? DEFAULT_MAX_BUFFER,
+			},
+			(error, stdout = "", stderr = "") => {
+				const exitCode = typeof error?.code === "number" ? error.code : 0;
+				const durationMs = Date.now() - startedAt;
+				const normalizedStdout = stdout.toString();
+				const normalizedStderr = stderr.toString();
+				if (error) {
+					const reason =
+						error.killed && error.signal === "SIGTERM"
+							? `Command timed out after ${timeoutMs}ms`
+							: error.message;
+					recordAudit({
+						timestamp: Date.now(),
+						command: verdict.normalizedCommand,
+						source: options.source,
+						trustLevel: verdict.trustLevel,
+						cwd: options.cwd,
+						outcome: "failed",
+						reason,
+						exitCode: typeof error?.code === "number" ? error.code : null,
+						durationMs,
+					});
+					resolve({
+						ok: false,
+						blocked: false,
+						stdout: normalizedStdout,
+						stderr: normalizedStderr,
+						exitCode: typeof error?.code === "number" ? error.code : null,
+						reason,
+					});
+					return;
+				}
+
+				recordAudit({
+					timestamp: Date.now(),
+					command: verdict.normalizedCommand,
+					source: options.source,
+					trustLevel: verdict.trustLevel,
+					cwd: options.cwd,
+					outcome: "executed",
+					exitCode,
+					durationMs,
+				});
+				resolve({
+					ok: true,
+					blocked: false,
+					stdout: normalizedStdout,
+					stderr: normalizedStderr,
+					exitCode,
+				});
+			}
+		);
+	});
+}
+
 /**
  * Run a git command through centralized policy and process wrapper.
  *
@@ -1130,6 +1226,30 @@ export function runGitCommandSync(
 	return result.stdout.trim();
 }
 
+/**
+ * Run a git command asynchronously through centralized policy and process wrapper.
+ *
+ * @param args - Git arguments
+ * @param cwd - Working directory
+ * @param timeoutMs - Optional timeout override
+ * @returns Trimmed stdout on success, null otherwise
+ */
+export async function runGitCommand(
+	args: readonly string[],
+	cwd: string,
+	timeoutMs?: number
+): Promise<string | null> {
+	const result = await runCommand({
+		command: "git",
+		args,
+		cwd,
+		source: "git-helper",
+		timeoutMs,
+	});
+	if (!result.ok) return null;
+	return result.stdout.trim();
+}
+
 /**
  * Check whether an executable exists on PATH using policy-wrapped process execution.
  *

package/extensions/_shared/terminal-links.ts

@@ -0,0 +1,22 @@
+/**
+ * Wrap visible text in an OSC 8 terminal hyperlink.
+ *
+ * @param url - Target URL
+ * @param text - Visible link text
+ * @returns OSC 8 hyperlink sequence
+ */
+export function hyperlink(url: string, text: string): string {
+	return `\u001b]8;;${url}\u0007${text}\u001b]8;;\u0007`;
+}
+
+/**
+ * Wrap a file path in an OSC 8 hyperlink using the file:// protocol.
+ *
+ * @param filePath - Absolute or relative file path
+ * @param displayText - Optional visible text override
+ * @returns File path wrapped in a file:// OSC 8 hyperlink
+ */
+export function fileLink(filePath: string, displayText?: string): string {
+	const url = `file://${encodeURI(filePath)}`;
+	return hyperlink(url, displayText ?? filePath);
+}

package/extensions/ask-user-question-tool/index.ts

@@ -9,7 +9,6 @@ import {
 	Editor,
 	type EditorTheme,
 	Key,
-	Loader,
 	matchesKey,
 	Text,
 	truncateToWidth,
@@ -153,8 +152,6 @@ WHEN NOT TO USE:
 				{ label: "Type something.", isOther: true },
 			];
 
-			ctx.ui.setWorkingMessage(Loader.HIDE);
-
 			const result = await ctx.ui.custom<{
 				answer: string;
 				wasCustom: boolean;

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

@@ -19,7 +19,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { loadSkills, stripFrontmatter } from "@mariozechner/pi-coding-agent";
+import { getAgentDir, loadSkills, stripFrontmatter } from "@mariozechner/pi-coding-agent";
 import { createLazyInitializer } from "../_shared/lazy-init.js";
 import { isProjectTrusted } from "../_shared/project-trust.js";
 
@@ -52,7 +52,13 @@ interface CommandExpansionDependencies {
 
 /** Default dependency implementation for production runtime. */
 const DEFAULT_COMMAND_EXPANSION_DEPENDENCIES: CommandExpansionDependencies = {
-	loadSkills,
+	loadSkills: () =>
+		loadSkills({
+			cwd: process.cwd(),
+			agentDir: getAgentDir(),
+			skillPaths: [],
+			includeDefaults: true,
+		}),
 	loadPromptTemplates,
 };
 
@@ -418,7 +424,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/frontmatter-index.ts

@@ -297,7 +297,12 @@ export function buildFrontmatterIndex(debugLog?: (msg: string) => void): Frontma
 
 	// Skills: skill name as-is
 	try {
-		const { skills } = loadSkills();
+		const { skills } = loadSkills({
+			cwd: process.cwd(),
+			agentDir: getAgentDir(),
+			skillPaths: [],
+			includeDefaults: true,
+		});
 		for (const skill of skills) {
 			maybeAdd(skill.name, skill.filePath);
 		}