@dungle-scrubs/tallow 0.8.21 → 0.8.23

package/extensions/slash-command-bridge/extension.json

@@ -5,7 +5,7 @@
 	"whenToUse": "Use when the model should invoke slash commands through a tool.",
 	"capabilities": {
 		"tools": ["run_slash_command"],
-		"events": ["agent_end", "before_agent_start", "session_before_switch"]
+		"events": ["before_agent_start", "session_before_switch", "turn_end", "turn_start"]
 	},
 	"permissionSurface": {
 		"filesystem": "none",

package/extensions/slash-command-bridge/index.ts

@@ -9,15 +9,20 @@
  * registration, with auto-generated tool schemas and full command handler access.
  */
 
-import type { ContextUsage, ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type {
+	ContextUsage,
+	ExtensionAPI,
+	ExtensionContext,
+	TurnEndEvent,
+} from "@mariozechner/pi-coding-agent";
 import { Text } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
 
 /**
- * Deferred compact request — set by the tool handler, consumed by the
- * `agent_end` hook. Deferring avoids the spinner-hang bug where
- * `ctx.compact()` aborts the agent mid-tool-call, orphaning the tool
- * execution UI component. See plans 95 and 98 for full analysis.
+ * Deferred compact request — set by the tool handler, consumed on the first
+ * safe assistant `turn_end` after the tool result. Deferring avoids the
+ * spinner-hang bug where `ctx.compact()` aborts the agent mid-tool-call,
+ * orphaning the tool execution UI component. See plans 95, 98, and 191.
  */
 let pendingCompact: { customInstructions?: string } | null = null;
 
@@ -35,7 +40,7 @@ let resumingAfterCompact = false;
  * `flushCompactionQueue` or user input already prompted the agent), or
  * on session switch. See plan 159, bug 1.
  */
-let continuationTimer: ReturnType<typeof setTimeout> | null = null;
+let continuationTimer: SchedulerHandle | null = null;
 
 /** Spinner frames for compact progress status updates. */
 const COMPACT_PROGRESS_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
@@ -43,9 +48,39 @@ const COMPACT_PROGRESS_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦"
 /** Interval cadence for compact progress status updates. */
 const COMPACT_PROGRESS_INTERVAL_MS = 1000;
 
+type SchedulerHandle = unknown;
+
+/** Timer scheduler used by compact UI and continuation timers. */
+export interface SlashCommandBridgeTimerScheduler {
+	readonly now: () => number;
+	readonly setInterval: (callback: () => void, intervalMs: number) => SchedulerHandle;
+	readonly clearInterval: (handle: SchedulerHandle | null) => void;
+	readonly setTimeout: (callback: () => void, delayMs: number) => SchedulerHandle;
+	readonly clearTimeout: (handle: SchedulerHandle | null) => void;
+}
+
+/** Default runtime timer scheduler. */
+const DEFAULT_TIMER_SCHEDULER: SlashCommandBridgeTimerScheduler = {
+	now: () => Date.now(),
+	setInterval: (callback, intervalMs) => setInterval(callback, intervalMs),
+	clearInterval: (handle) => {
+		if (handle) {
+			clearInterval(handle as ReturnType<typeof setInterval>);
+		}
+	},
+	setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+	clearTimeout: (handle) => {
+		if (handle) {
+			clearTimeout(handle as ReturnType<typeof setTimeout>);
+		}
+	},
+};
+
+let timerScheduler: SlashCommandBridgeTimerScheduler = DEFAULT_TIMER_SCHEDULER;
+
 /** Module-level heartbeat state for deferred compact UI updates. */
 const compactProgressState: {
-	interval: ReturnType<typeof setInterval> | null;
+	interval: SchedulerHandle | null;
 	spinnerIndex: number;
 	startedAt: number;
 } = {
@@ -55,52 +90,114 @@ const compactProgressState: {
 };
 
 /**
- * Starts compact progress heartbeat updates in the footer status.
+ * Starts compact progress heartbeat updates as an inline widget above the editor.
  *
  * This helper is idempotent: it always clears any previous heartbeat before
  * starting a new one, preventing duplicate intervals after retries.
  *
- * @param ctx - Extension context used to update footer status
+ * @param ctx - Extension context used to render the compact progress widget
  * @returns Nothing
  */
 function startCompactProgress(ctx: ExtensionContext): void {
-	stopCompactProgress();
+	stopCompactProgress(ctx);
 
-	if (!ctx.ui?.setStatus) {
+	if (!ctx.ui?.setWidget) {
 		return;
 	}
 
-	compactProgressState.startedAt = Date.now();
+	compactProgressState.startedAt = timerScheduler.now();
 	compactProgressState.spinnerIndex = 0;
 
-	const renderStatus = () => {
-		const elapsedSeconds = Math.floor((Date.now() - compactProgressState.startedAt) / 1000);
+	const renderWidget = () => {
+		const elapsedSeconds = Math.floor(
+			(timerScheduler.now() - compactProgressState.startedAt) / 1000
+		);
 		const frame =
 			COMPACT_PROGRESS_FRAMES[compactProgressState.spinnerIndex] ?? COMPACT_PROGRESS_FRAMES[0];
-		ctx.ui?.setStatus?.("compact", `🧹 ${frame} compacting · ${elapsedSeconds}s`);
+		ctx.ui?.setWidget?.("compact-progress", [
+			`🧹 ${frame} Compacting session · ${elapsedSeconds}s`,
+		]);
 		compactProgressState.spinnerIndex =
 			(compactProgressState.spinnerIndex + 1) % COMPACT_PROGRESS_FRAMES.length;
 	};
 
-	renderStatus();
-	compactProgressState.interval = setInterval(renderStatus, COMPACT_PROGRESS_INTERVAL_MS);
+	renderWidget();
+	compactProgressState.interval = timerScheduler.setInterval(
+		renderWidget,
+		COMPACT_PROGRESS_INTERVAL_MS
+	);
 }
 
 /**
- * Stops compact progress heartbeat updates and resets module-level state.
+ * Stops compact progress heartbeat updates, clears the inline widget, and
+ * resets module-level state.
  *
+ * @param ctx - Extension context used to clear the widget (optional for test/cleanup paths)
  * @returns Nothing
  */
-function stopCompactProgress(): void {
+function stopCompactProgress(ctx?: ExtensionContext): void {
 	if (compactProgressState.interval) {
-		clearInterval(compactProgressState.interval);
+		timerScheduler.clearInterval(compactProgressState.interval);
 		compactProgressState.interval = null;
+		// Only clear the widget when a heartbeat was actually running.
+		// Avoids a spurious undefined update when startCompactProgress
+		// calls this as an idempotent reset before starting fresh.
+		ctx?.ui?.setWidget?.("compact-progress", undefined);
 	}
 
 	compactProgressState.startedAt = 0;
 	compactProgressState.spinnerIndex = 0;
 }
 
+/**
+ * Cancels the pending continuation timer, if one exists.
+ *
+ * @returns Nothing
+ */
+function clearContinuationTimer(): void {
+	if (!continuationTimer) {
+		return;
+	}
+
+	timerScheduler.clearTimeout(continuationTimer);
+	continuationTimer = null;
+}
+
+/**
+ * Resets module-level compact state between runs or tests.
+ *
+ * @returns Nothing
+ */
+function clearCompactRuntimeState(): void {
+	pendingCompact = null;
+	resumingAfterCompact = false;
+	stopCompactProgress();
+	clearContinuationTimer();
+}
+
+/**
+ * Installs a deterministic timer scheduler for tests.
+ *
+ * @param scheduler - Test scheduler implementation
+ * @returns Nothing
+ */
+export function setSlashCommandBridgeSchedulerForTests(
+	scheduler: SlashCommandBridgeTimerScheduler
+): void {
+	clearCompactRuntimeState();
+	timerScheduler = scheduler;
+}
+
+/**
+ * Resets test scheduler/state overrides back to runtime defaults.
+ *
+ * @returns Nothing
+ */
+export function resetSlashCommandBridgeStateForTests(): void {
+	clearCompactRuntimeState();
+	timerScheduler = DEFAULT_TIMER_SCHEDULER;
+}
+
 /**
  * Commands the model is allowed to invoke.
  * Maps command name → whether it's executable from tool context.
@@ -177,6 +274,101 @@ function formatContextUsage(usage: KnownContextUsage): string {
 	return lines.join("\n");
 }
 
+/**
+ * Returns true when the current turn_end is the first safe compaction boundary.
+ *
+ * The compact tool always finishes on a `toolUse` turn first. The model then
+ * gets one more assistant turn to finish its response after seeing the tool
+ * result. Consuming the request on `agent_end` is too late: `session.prompt()`
+ * returns before prior `agent_end` extension work fully drains, so a stale
+ * `agent_end` from the previous run can steal a newer compact request. The
+ * first assistant `turn_end` whose stop reason is not `toolUse` is the proven
+ * boundary for starting deferred compaction exactly once.
+ *
+ * @param event - Turn lifecycle event
+ * @returns True when deferred compaction should start now
+ */
+function shouldStartDeferredCompactOnTurnEnd(event: TurnEndEvent): boolean {
+	return event.message.role === "assistant" && event.message.stopReason !== "toolUse";
+}
+
+/**
+ * Starts the deferred compact flow and wires continuation/error cleanup.
+ *
+ * @param pi - Extension API used to enqueue the hidden continuation message
+ * @param ctx - Extension context with compact/UI capabilities
+ * @param options - Deferred compact request options
+ * @returns Nothing
+ */
+function startDeferredCompact(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	options: { customInstructions?: string }
+): void {
+	// Show explicit UI feedback while compaction runs. Without this,
+	// users only see the deferred tool message and no live progress signal.
+	ctx.ui?.setWorkingMessage?.("Compacting session…");
+	startCompactProgress(ctx);
+
+	ctx.compact({
+		customInstructions: options.customInstructions,
+		onComplete: () => {
+			stopCompactProgress(ctx);
+
+			// Transition from compaction indicators to resuming indicators.
+			// setWorkingMessage queues as pendingWorkingMessage (no loader
+			// exists after executeCompaction stops it). Applied automatically
+			// when agent_start creates the loader. The inline widget covers
+			// the brief gap before the loader appears.
+			resumingAfterCompact = true;
+			ctx.ui?.setWorkingMessage?.("Resuming task…");
+			ctx.ui?.setWidget?.("compact-progress", ["⏳ Resuming after compaction…"]);
+
+			// Always schedule continuation. Safety nets prevent duplicate prompts:
+			// 1. turn_start listener cancels if flushCompactionQueue already started a turn
+			// 2. isIdle() check at timer expiry skips if agent is streaming
+			// 3. sendCustomMessage queues as steering if agent started mid-delay
+			//
+			// Previously gated on hasCompactionQueuedMessages(), but that method
+			// checked both the compaction queue AND session steering — causing a
+			// false positive when steering messages were queued before compact.
+			// flushCompactionQueue only processes compactionQueuedMessages, so
+			// session steering messages were orphaned. See plan 160.
+			//
+			// 200ms gives session.prompt()'s async setup (API key resolution,
+			// compaction check) time to settle. The turn_start listener cancels
+			// this timer if a turn starts before it fires (defense-in-depth).
+			continuationTimer = timerScheduler.setTimeout(() => {
+				continuationTimer = null;
+				if (ctx.isIdle()) {
+					pi.sendMessage(
+						{
+							customType: "compact-continue",
+							content:
+								"Session compaction is complete. Continue with the task " +
+								"you were working on before compaction was triggered.",
+							display: false,
+						},
+						{ triggerTurn: true }
+					);
+				} else {
+					// User sent a message during compaction — their turn is
+					// handling things, clean up our indicators.
+					resumingAfterCompact = false;
+					ctx.ui?.setWidget?.("compact-progress", undefined);
+					ctx.ui?.setWorkingMessage?.();
+				}
+			}, 200);
+		},
+		onError: () => {
+			stopCompactProgress(ctx);
+			ctx.ui?.setWorkingMessage?.();
+			// Framework's executeCompaction handles error/cancel
+			// display. No continuation on failure — user decides.
+		},
+	});
+}
+
 /**
  * Registers the slash-command-bridge tool and context injection.
  *
@@ -299,8 +491,8 @@ WHEN NOT TO USE:
 
 				case "compact": {
 					// Don't call ctx.compact() here — it aborts the agent mid-tool-call,
-					// orphaning the tool execution spinner (plan 95/98). Defer to the
-					// agent_end hook so the tool completes normally first.
+					// orphaning the tool execution spinner (plan 95/98). Defer to a
+					// proven turn_end boundary so the tool completes normally first.
 					pendingCompact = { customInstructions: undefined };
 
 					return {
@@ -350,93 +542,23 @@ WHEN NOT TO USE:
 	// ── Deferred compact ─────────────────────────────────────────
 
 	/**
-	 * Fires compact after the agent finishes its turn. This avoids the
-	 * spinner-hang caused by aborting the agent mid-tool-execution.
-	 * The tool sets `pendingCompact`, then agent_end picks it up.
-	 *
-	 * After compaction completes, checks whether the agent is idle. When the
-	 * model triggered compaction (vs. the user typing during it), the
-	 * framework's `flushCompactionQueue` finds no queued messages and the
-	 * agent sits at the input prompt — even though the model promised to
-	 * continue. We fix this by sending a hidden continuation message via
-	 * `pi.sendMessage()` with `triggerTurn: true` to re-prompt the agent.
+	 * Fires compact on the first safe assistant `turn_end` after the compact tool
+	 * returns. The immediate `toolUse` turn is too early because the model has not
+	 * finished its post-tool response yet, while `agent_end` is too late because a
+	 * stale `agent_end` from the previous run can steal a newer pending request.
 	 *
-	 * A short `setTimeout` allows `flushCompactionQueue`'s fire-and-forget
-	 * async path to settle first, so we don't conflict with user-queued
-	 * messages that already restarted the agent.
-	 *
-	 * @see Plan 98 — deferred compact to agent_end (introduced idle-after-compact)
+	 * @see Plan 98 — deferred compact moved out of the tool handler
 	 * @see Plan 157 — auto-continue after model-triggered compaction
+	 * @see Plan 191 — stale prior agent_end could consume a later compact request
 	 */
-	pi.on("agent_end", (_event, ctx) => {
-		if (!pendingCompact) return;
+	pi.on("turn_end", (event, ctx) => {
+		if (!pendingCompact || !shouldStartDeferredCompactOnTurnEnd(event)) {
+			return;
+		}
 
 		const options = pendingCompact;
 		pendingCompact = null;
-
-		// Show explicit UI feedback while compaction runs. Without this,
-		// users only see the deferred tool message and no live progress signal.
-		ctx.ui?.setWorkingMessage?.("Compacting session…");
-		startCompactProgress(ctx);
-
-		ctx.compact({
-			customInstructions: options.customInstructions,
-			onComplete: () => {
-				stopCompactProgress();
-
-				// Transition from compaction indicators to resuming indicators.
-				// setWorkingMessage queues as pendingWorkingMessage (no loader
-				// exists after executeCompaction stops it). Applied automatically
-				// when agent_start creates the loader. Footer status is visible
-				// immediately — covers the brief gap before the loader appears.
-				resumingAfterCompact = true;
-				ctx.ui?.setWorkingMessage?.("Resuming task…");
-				ctx.ui?.setStatus?.("compact", "⏳ resuming");
-
-				// Always schedule continuation. Safety nets prevent duplicate prompts:
-				// 1. turn_start listener cancels if flushCompactionQueue already started a turn
-				// 2. isIdle() check at timer expiry skips if agent is streaming
-				// 3. sendCustomMessage queues as steering if agent started mid-delay
-				//
-				// Previously gated on hasCompactionQueuedMessages(), but that method
-				// checked both the compaction queue AND session steering — causing a
-				// false positive when steering messages were queued before compact.
-				// flushCompactionQueue only processes compactionQueuedMessages, so
-				// session steering messages were orphaned. See plan 160.
-				//
-				// 200ms gives session.prompt()'s async setup (API key resolution,
-				// compaction check) time to settle. The turn_start listener cancels
-				// this timer if a turn starts before it fires (defense-in-depth).
-				continuationTimer = setTimeout(() => {
-					continuationTimer = null;
-					if (ctx.isIdle()) {
-						pi.sendMessage(
-							{
-								customType: "compact-continue",
-								content:
-									"Session compaction is complete. Continue with the task " +
-									"you were working on before compaction was triggered.",
-								display: false,
-							},
-							{ triggerTurn: true }
-						);
-					} else {
-						// User sent a message during compaction — their turn is
-						// handling things, clean up our indicators.
-						resumingAfterCompact = false;
-						ctx.ui?.setStatus?.("compact", undefined);
-						ctx.ui?.setWorkingMessage?.();
-					}
-				}, 200);
-			},
-			onError: () => {
-				stopCompactProgress();
-				ctx.ui?.setWorkingMessage?.();
-				ctx.ui?.setStatus?.("compact", undefined);
-				// Framework's executeCompaction handles error/cancel
-				// display. No continuation on failure — user decides.
-			},
-		});
+		startDeferredCompact(pi, ctx, options);
 	});
 
 	/**
@@ -450,13 +572,10 @@ WHEN NOT TO USE:
 	 * now active and showing the pending working message ("Resuming task…").
 	 */
 	pi.on("turn_start", (_event, ctx) => {
-		if (continuationTimer) {
-			clearTimeout(continuationTimer);
-			continuationTimer = null;
-		}
+		clearContinuationTimer();
 		if (!resumingAfterCompact) return;
 		resumingAfterCompact = false;
-		ctx.ui?.setStatus?.("compact", undefined);
+		ctx.ui?.setWidget?.("compact-progress", undefined);
 	});
 
 	/**
@@ -464,13 +583,8 @@ WHEN NOT TO USE:
 	 * session switches before the turn ends.
 	 */
 	pi.on("session_before_switch", (_event, ctx) => {
-		pendingCompact = null;
-		resumingAfterCompact = false;
-		stopCompactProgress();
-		if (continuationTimer) {
-			clearTimeout(continuationTimer);
-			continuationTimer = null;
-		}
-		ctx.ui?.setStatus?.("compact", undefined);
+		clearCompactRuntimeState();
+		ctx.ui?.setWidget?.("compact-progress", undefined);
+		ctx.ui?.setWorkingMessage?.();
 	});
 }

package/extensions/subagent-tool/index.ts

@@ -143,11 +143,11 @@ export default function (pi: ExtensionAPI) {
 		publishSubagentSnapshot(pi.events);
 
 		// Request telemetry handle for subprocess trace context injection.
-		const { TELEMETRY_API_CHANNELS } = await import("../../src/otel.js");
+		const { TELEMETRY_API_CHANNELS } = await import("../../runtime/otel.js");
 		const onTelemetryApi = (payload: unknown): void => {
 			if (payload && typeof payload === "object" && "handle" in payload) {
 				setTelemetryHandle(
-					(payload as { handle: import("../../src/otel.js").TelemetryHandle }).handle
+					(payload as { handle: import("../../runtime/otel.js").TelemetryHandle }).handle
 				);
 			}
 		};

package/extensions/subagent-tool/process.ts

@@ -12,12 +12,11 @@ import * as path from "node:path";
 import type { AgentToolResult } from "@mariozechner/pi-agent-core";
 import type { Message } from "@mariozechner/pi-ai";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { DEFAULT_AGENT_RUNNER_ENV, spawnWithResolvedAgentRunner } from "../../src/agent-runner.js";
 import {
-	injectTraceContextToEnv,
-	TELEMETRY_API_CHANNELS,
-	type TelemetryHandle,
-} from "../../src/otel.js";
+	DEFAULT_AGENT_RUNNER_ENV,
+	spawnWithResolvedAgentRunner,
+} from "../../runtime/agent-runner.js";
+import { injectTraceContextToEnv, type TelemetryHandle } from "../../runtime/otel.js";
 import { extractPreview, isInlineResultsEnabled } from "../_shared/inline-preview.js";
 import {
 	emitWorktreeLifecycleEvent,

package/extensions/tasks/commands/register-tasks-extension.ts

@@ -11,6 +11,7 @@ import { Key, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { getIcon, getSpinner } from "../../_icons/index.js";
 import {
+	emitInteropEvent,
 	INTEROP_EVENT_NAMES,
 	onInteropEvent,
 	requestInteropState,
@@ -106,6 +107,7 @@ export function registerTasksExtension(
 	let backgroundTasks: BgTaskView[] = [];
 	let activeTeams: TeamWidgetView[] = [];
 	let teamDashboardActive = false;
+	let lastBackgroundTaskPresenterState: boolean | null = null;
 
 	if (tasksAnimationInterval) clearInterval(tasksAnimationInterval);
 	tasksAnimationInterval = undefined;
@@ -573,10 +575,40 @@ export function registerTasksExtension(
 		);
 	}
 
+	/**
+	 * Determine whether the tasks extension currently owns background-task
+	 * widget presentation.
+	 *
+	 * The tasks widget can safely suppress the standalone background-task-tool
+	 * widget whenever this main dashboard is visible and the team dashboard is
+	 * not active.
+	 *
+	 * @returns True when the tasks widget should be the canonical presenter
+	 */
+	function shouldPresentBackgroundTasks(): boolean {
+		return !isSubagent && state.visible && !teamDashboardActive;
+	}
+
+	/**
+	 * Publish background-task presenter ownership for background-task-tool.
+	 *
+	 * @returns void
+	 */
+	function publishBackgroundTaskPresenterState(): void {
+		const nextState = shouldPresentBackgroundTasks();
+		if (lastBackgroundTaskPresenterState === nextState) return;
+		lastBackgroundTaskPresenterState = nextState;
+		emitInteropEvent(pi.events, INTEROP_EVENT_NAMES.backgroundTasksPresenterState, {
+			active: nextState,
+		});
+	}
+
 	function updateWidget(ctx: ExtensionContext): void {
 		// Subagents have no UI — skip all widget rendering
 		if (isSubagent) return;
 
+		publishBackgroundTaskPresenterState();
+
 		// If every task is completed and the 2s completion window has passed,
 		// clear the list. This covers extension reloads where the original
 		// setTimeout callback was lost before it could run.
@@ -1891,6 +1923,7 @@ Before calling manage_tasks complete/update, call manage_tasks list first so ind
 		backgroundTasks = [];
 		activeTeams = [];
 		teamDashboardActive = false;
+		lastBackgroundTaskPresenterState = null;
 		lastBgCount = 0;
 		lastBgTaskCount = 0;
 
@@ -1990,11 +2023,15 @@ Before calling manage_tasks complete/update, call manage_tasks list first so ind
 					updateWidget(ctx);
 				}
 			);
+			const unsubStateRequest = onInteropEvent(pi.events, INTEROP_EVENT_NAMES.stateRequest, () => {
+				publishBackgroundTaskPresenterState();
+			});
 			interopEventsCleanup = () => {
 				unsubSubagents();
 				unsubBackgroundTasks();
 				unsubTeams();
 				unsubDashboardState();
+				unsubStateRequest();
 			};
 
 			legacyInteropBridgeCleanup?.();
@@ -2098,6 +2135,10 @@ Before calling manage_tasks complete/update, call manage_tasks list first so ind
 
 	// Cleanup on session end
 	pi.on("session_shutdown", async () => {
+		emitInteropEvent(pi.events, INTEROP_EVENT_NAMES.backgroundTasksPresenterState, {
+			active: false,
+		});
+		lastBackgroundTaskPresenterState = false;
 		if (tasksAnimationInterval) {
 			clearInterval(tasksAnimationInterval);
 			tasksAnimationInterval = undefined;