@vanillagreen/pi-qol 1.5.0 → 1.7.0

package/extensions/qol/schedule.ts

@@ -0,0 +1,344 @@
+import { truncateToWidth, type AutocompleteItem } from "@earendil-works/pi-tui";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { ansiGreen } from "./ansi.js";
+import { stringifyError } from "./util.js";
+
+export const SCHEDULE_ENTRY_TYPE = "qol-schedule";
+
+const MAX_TIMER_DELAY_MS = 2_147_000_000;
+const MAX_SCHEDULE_DELAY_MS = 30 * 24 * 60 * 60 * 1000;
+const MAX_ACTIVE_SCHEDULES = 100;
+
+interface ScheduleTimer {
+	unref?: () => void;
+}
+
+export interface ScheduleClock {
+	now(): number;
+	setTimeout(callback: () => void, delayMs: number): ScheduleTimer;
+	clearTimeout(timer: ScheduleTimer): void;
+}
+
+interface ScheduledMessage {
+	createdAt: number;
+	dueAt: number;
+	id: string;
+	message: string;
+	timer?: ScheduleTimer;
+}
+
+type ScheduleEntryAction = "scheduled" | "delivered" | "cancelled" | "failed";
+
+interface ScheduleEntryData {
+	action: ScheduleEntryAction;
+	cancelledAt?: number;
+	createdAt?: number;
+	deliveredAt?: number;
+	dueAt?: number;
+	failedAt?: number;
+	id: string;
+	message?: string;
+}
+
+export type ParsedScheduleCommand =
+	| { kind: "list" }
+	| { kind: "cancel"; all: boolean; id?: string }
+	| { kind: "schedule"; delayMs: number; message: string }
+	| { kind: "usage"; error?: string };
+
+const DEFAULT_CLOCK: ScheduleClock = {
+	now: () => Date.now(),
+	setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+	clearTimeout: (timer) => clearTimeout(timer as ReturnType<typeof setTimeout>),
+};
+
+const SCHEDULE_COMPLETIONS: AutocompleteItem[] = [
+	{ value: "list", label: "list", description: "Show pending scheduled messages" },
+	{ value: "cancel ", label: "cancel <id|all>", description: "Cancel one scheduled message or all pending messages" },
+	{ value: "20m ", label: "20m <message>", description: "Send a message after 20 minutes" },
+	{ value: "1h30m ", label: "1h30m <message>", description: "Send a message after 1 hour 30 minutes" },
+	{ value: "1h ", label: "1h <message>", description: "Send a message after 1 hour" },
+];
+
+export function getScheduleArgumentCompletions(prefix: string): AutocompleteItem[] | null {
+	const query = prefix.trimStart().toLowerCase();
+	const filtered = SCHEDULE_COMPLETIONS.filter((item) => item.value.toLowerCase().startsWith(query) || (item.label ?? item.value).toLowerCase().startsWith(query));
+	return filtered.length > 0 ? filtered : null;
+}
+
+export function parseDurationMs(input: string): number | undefined {
+	const text = input.trim().toLowerCase();
+	if (!text) return undefined;
+	if (/^\d+(?:\.\d+)?$/.test(text)) return clampScheduleDelay(Number(text) * 60 * 1000);
+
+	let totalMs = 0;
+	let matched = false;
+	let previousRank = Number.POSITIVE_INFINITY;
+	const seenUnits = new Set<string>();
+	const re = /(\d+(?:\.\d+)?)(ms|seconds?|secs?|s|minutes?|mins?|min|m|hours?|hrs?|hr|h|days?|d)/gy;
+
+	while (re.lastIndex < text.length) {
+		const match = re.exec(text);
+		if (!match) return undefined;
+		const amount = Number(match[1]);
+		const unit = scheduleUnit(match[2]);
+		if (!Number.isFinite(amount) || amount < 0 || !unit) return undefined;
+		if (seenUnits.has(unit.name) || unit.rank >= previousRank) return undefined;
+		seenUnits.add(unit.name);
+		previousRank = unit.rank;
+		totalMs += amount * unit.multiplier;
+		matched = true;
+	}
+
+	const delayMs = Math.round(totalMs);
+	return matched ? clampScheduleDelay(delayMs) : undefined;
+}
+
+function clampScheduleDelay(delayMs: number): number | undefined {
+	if (!Number.isFinite(delayMs) || delayMs <= 0 || delayMs > MAX_SCHEDULE_DELAY_MS) return undefined;
+	return delayMs;
+}
+
+function scheduleUnit(unit: string): { multiplier: number; name: string; rank: number } | undefined {
+	if (unit === "ms") return { multiplier: 1, name: "ms", rank: 0 };
+	if (["s", "sec", "secs", "second", "seconds"].includes(unit)) return { multiplier: 1000, name: "s", rank: 1 };
+	if (["m", "min", "mins", "minute", "minutes"].includes(unit)) return { multiplier: 60 * 1000, name: "m", rank: 2 };
+	if (["h", "hr", "hrs", "hour", "hours"].includes(unit)) return { multiplier: 60 * 60 * 1000, name: "h", rank: 3 };
+	if (["d", "day", "days"].includes(unit)) return { multiplier: 24 * 60 * 60 * 1000, name: "d", rank: 4 };
+	return undefined;
+}
+
+export function parseScheduleCommandArgs(args: string): ParsedScheduleCommand {
+	const trimmed = args.trim();
+	if (!trimmed) return { kind: "list" };
+	const firstSpace = trimmed.search(/\s/);
+	const head = (firstSpace < 0 ? trimmed : trimmed.slice(0, firstSpace)).toLowerCase();
+	const rest = firstSpace < 0 ? "" : trimmed.slice(firstSpace + 1).trim();
+	if (head === "list" || head === "ls" || head === "status") return { kind: "list" };
+	if (head === "cancel" || head === "clear") {
+		if (!rest) return { kind: "usage", error: "Usage: /schedule cancel <id|all>" };
+		if (rest.toLowerCase() === "all") return { kind: "cancel", all: true };
+		return { kind: "cancel", all: false, id: rest };
+	}
+	const delayMs = parseDurationMs(head);
+	if (delayMs === undefined) return { kind: "usage", error: "Usage: /schedule <duration> <message>" };
+	if (!rest) return { kind: "usage", error: "Usage: /schedule <duration> <message>" };
+	return { kind: "schedule", delayMs, message: rest };
+}
+
+export function formatScheduleDuration(ms: number): string {
+	const totalSeconds = Math.max(0, Math.round(ms / 1000));
+	const days = Math.floor(totalSeconds / 86_400);
+	const hours = Math.floor((totalSeconds % 86_400) / 3600);
+	const minutes = Math.floor((totalSeconds % 3600) / 60);
+	const seconds = totalSeconds % 60;
+	const parts: string[] = [];
+	if (days) parts.push(`${days}d`);
+	if (hours) parts.push(`${hours}h`);
+	if (minutes) parts.push(`${minutes}m`);
+	if (seconds || parts.length === 0) parts.push(`${seconds}s`);
+	return parts.slice(0, 2).join(" ");
+}
+
+function previewMessage(message: string, max = 80): string {
+	const singleLine = message.replace(/\s+/g, " ").trim();
+	if (singleLine.length <= max) return singleLine;
+	return `${singleLine.slice(0, Math.max(0, max - 1))}…`;
+}
+
+function formatDueTime(timestamp: number): string {
+	return new Date(timestamp).toLocaleString();
+}
+
+function usageText(): string {
+	return [
+		"Usage: /schedule <duration> <message>",
+		"Examples: /schedule 20m retry the previous request",
+		"          /schedule 1h30m retry after the rate limit reset",
+		"Durations: 20, 20m, 90s, 500ms, 1h45m30s (bare numbers mean minutes)",
+		"Manage: /schedule list, /schedule cancel <id|all>",
+	].join("\n");
+}
+
+function dataToJob(data: ScheduleEntryData): ScheduledMessage | undefined {
+	if (data.action !== "scheduled") return undefined;
+	if (!data.id || typeof data.id !== "string") return undefined;
+	if (!data.message || typeof data.message !== "string") return undefined;
+	if (typeof data.createdAt !== "number" || typeof data.dueAt !== "number") return undefined;
+	if (!Number.isFinite(data.createdAt) || !Number.isFinite(data.dueAt)) return undefined;
+	return { createdAt: data.createdAt, dueAt: data.dueAt, id: data.id, message: data.message };
+}
+
+export function createScheduleController(pi: ExtensionAPI, clock: ScheduleClock = DEFAULT_CLOCK) {
+	let onChange: (() => void) | undefined;
+	let sequence = 0;
+	const jobs = new Map<string, ScheduledMessage>();
+
+	const notifyChanged = (): void => {
+		try {
+			onChange?.();
+		} catch {
+			// UI refresh hooks must never break schedule state transitions.
+		}
+	};
+
+	const nextId = (): string => {
+		let id = "";
+		do {
+			sequence += 1;
+			id = `${clock.now().toString(36)}-${sequence.toString(36)}`;
+		} while (jobs.has(id));
+		return id;
+	};
+
+	const appendEntry = (data: ScheduleEntryData): void => {
+		try {
+			pi.appendEntry?.(SCHEDULE_ENTRY_TYPE, data);
+		} catch {
+			// Scheduling still works in-memory if session persistence is unavailable.
+		}
+	};
+
+	const clearJobTimer = (job: ScheduledMessage): void => {
+		if (!job.timer) return;
+		clock.clearTimeout(job.timer);
+		job.timer = undefined;
+	};
+
+	const armJob = (job: ScheduledMessage, ctx: ExtensionContext): void => {
+		clearJobTimer(job);
+		const remaining = Math.max(0, job.dueAt - clock.now());
+		job.timer = clock.setTimeout(() => {
+			if (!jobs.has(job.id)) return;
+			if (clock.now() < job.dueAt) {
+				armJob(job, ctx);
+				return;
+			}
+			void deliver(job, ctx);
+		}, Math.min(remaining, MAX_TIMER_DELAY_MS));
+		job.timer.unref?.();
+	};
+
+	const deliver = async (job: ScheduledMessage, ctx: ExtensionContext): Promise<void> => {
+		if (!jobs.has(job.id)) return;
+		jobs.delete(job.id);
+		clearJobTimer(job);
+		notifyChanged();
+		try {
+			let idle = true;
+			try {
+				idle = ctx.isIdle?.() ?? true;
+			} catch {
+				idle = false;
+			}
+			await Promise.resolve(idle ? pi.sendUserMessage(job.message) : pi.sendUserMessage(job.message, { deliverAs: "followUp" }));
+			appendEntry({ action: "delivered", deliveredAt: clock.now(), id: job.id });
+			if (ctx.hasUI) ctx.ui.notify(`Scheduled message sent (${job.id}).`, "info");
+		} catch (error) {
+			appendEntry({ action: "failed", failedAt: clock.now(), id: job.id, message: stringifyError(error) });
+			if (ctx.hasUI) ctx.ui.notify(`Scheduled message failed (${job.id}): ${stringifyError(error)}`, "error");
+		}
+	};
+
+	const listText = (): string => {
+		const now = clock.now();
+		const pending = [...jobs.values()].sort((a, b) => a.dueAt - b.dueAt);
+		if (pending.length === 0) return "No scheduled messages.";
+		return [
+			"Scheduled messages:",
+			...pending.map((job) => `${job.id} — in ${formatScheduleDuration(job.dueAt - now)} (${formatDueTime(job.dueAt)}) — ${previewMessage(job.message)}`),
+		].join("\n");
+	};
+
+	const schedule = (delayMs: number, message: string, ctx: ExtensionCommandContext): void => {
+		if (jobs.size >= MAX_ACTIVE_SCHEDULES) {
+			ctx.ui.notify(`Too many scheduled messages (${MAX_ACTIVE_SCHEDULES}). Cancel one before adding another.`, "warning");
+			return;
+		}
+		const createdAt = clock.now();
+		const job: ScheduledMessage = { createdAt, dueAt: createdAt + delayMs, id: nextId(), message };
+		jobs.set(job.id, job);
+		appendEntry({ action: "scheduled", createdAt: job.createdAt, dueAt: job.dueAt, id: job.id, message: job.message });
+		armJob(job, ctx);
+		notifyChanged();
+		ctx.ui.notify(`Scheduled ${job.id} in ${formatScheduleDuration(delayMs)} (${formatDueTime(job.dueAt)}): ${previewMessage(message)}`, "info");
+	};
+
+	const cancel = (id: string): boolean => {
+		const job = jobs.get(id);
+		if (!job) return false;
+		clearJobTimer(job);
+		jobs.delete(id);
+		appendEntry({ action: "cancelled", cancelledAt: clock.now(), id });
+		notifyChanged();
+		return true;
+	};
+
+	return {
+		activeCount(): number {
+			return jobs.size;
+		},
+		clearTimers(): void {
+			for (const job of jobs.values()) clearJobTimer(job);
+			const changed = jobs.size > 0;
+			jobs.clear();
+			if (changed) notifyChanged();
+		},
+		async handleCommand(args: string, ctx: ExtensionCommandContext): Promise<void> {
+			const parsed = parseScheduleCommandArgs(args);
+			if (parsed.kind === "usage") {
+				ctx.ui.notify(`${parsed.error ?? "Invalid schedule command"}\n${usageText()}`, "warning");
+				return;
+			}
+			if (parsed.kind === "list") {
+				ctx.ui.notify(`${listText()}\n\n${usageText()}`, "info");
+				return;
+			}
+			if (parsed.kind === "cancel") {
+				if (parsed.all) {
+					const count = jobs.size;
+					for (const job of [...jobs.values()]) cancel(job.id);
+					ctx.ui.notify(`Cancelled ${count} scheduled message(s).`, "info");
+					return;
+				}
+				if (!parsed.id || !cancel(parsed.id)) {
+					ctx.ui.notify(`No scheduled message found for ${parsed.id ?? "<missing id>"}.`, "warning");
+					return;
+				}
+				ctx.ui.notify(`Cancelled scheduled message ${parsed.id}.`, "info");
+				return;
+			}
+			schedule(parsed.delayMs, parsed.message, ctx);
+		},
+		restoreFromBranch(ctx: ExtensionContext): void {
+			for (const job of jobs.values()) clearJobTimer(job);
+			jobs.clear();
+			const branch = ctx.sessionManager.getBranch?.() ?? [];
+			for (const entry of branch as any[]) {
+				if (entry?.type !== "custom" || entry.customType !== SCHEDULE_ENTRY_TYPE) continue;
+				const data = entry.data as ScheduleEntryData | undefined;
+				if (!data || typeof data !== "object") continue;
+				if (data.action === "scheduled") {
+					const job = dataToJob(data);
+					if (job) jobs.set(job.id, job);
+					continue;
+				}
+				if (typeof data.id === "string") jobs.delete(data.id);
+			}
+			for (const job of jobs.values()) armJob(job, ctx);
+			notifyChanged();
+		},
+		renderPreviewLines(width: number): string[] {
+			const pending = [...jobs.values()].sort((a, b) => a.dueAt - b.dueAt);
+			const shown = pending.slice(0, 3).map((job) => {
+				const line = `┃ Scheduled ${formatDueTime(job.dueAt)} — ${previewMessage(job.message, 120)}`;
+				return truncateToWidth(ansiGreen(line), width, "");
+			});
+			if (pending.length > shown.length) shown.push(truncateToWidth(ansiGreen(`┃ Scheduled: +${pending.length - shown.length} more`), width, ""));
+			return shown;
+		},
+		setOnChange(callback: (() => void) | undefined): void {
+			onChange = callback;
+		},
+	};
+}

package/extensions/qol/status-message.ts

@@ -18,9 +18,13 @@ import { boundedSettingNumber, newlineFallbackKey, settingBoolean, settingNumber
 export function statusMessage(ctx: ExtensionContext): string {
 	const labels = attachmentLabels(currentEditorText(ctx), ctx.cwd);
 	const searchShortcut = sessionSearchShortcut(ctx.cwd);
+	const statuslineEnabled = settingBoolean("statusline.enabled", true, ctx.cwd);
+	const statuslineMode = statuslineEnabled
+		? (settingBoolean("replaceFooter", true, ctx.cwd) ? "enabled, replaces footer" : "enabled, footer preserved")
+		: "disabled";
 	return [
 		"Pi QOL status",
-		`Statusline: ${settingBoolean("replaceFooter", true, ctx.cwd) ? "replaces footer" : "footer preserved"}; prompt=${settingBoolean("compactPrompt", true, ctx.cwd) ? `${glyphs(ctx.cwd).prompt} compact` : "default chrome"}`,
+		`Statusline: ${statuslineMode}; prompt=${settingBoolean("compactPrompt", true, ctx.cwd) ? `${glyphs(ctx.cwd).prompt} compact` : "default chrome"}`,
 		`shift+enter newline: ${settingBoolean("newlineOnShiftEnter", true, ctx.cwd) ? "enabled" : "disabled"}`,
 		`Fallback newline key: ${newlineFallbackKey(ctx.cwd)}`,
 		`Pending queue preview: ${settingBoolean("pendingQueue.asciiGreen", true, ctx.cwd) ? "ANSI green" : "Pi default"}`,
@@ -29,12 +33,13 @@ export function statusMessage(ctx: ExtensionContext): string {
 		`Rename command: ${settingBoolean("enableSessionNameCommand", true, ctx.cwd) ? "enabled (/rename)" : "disabled"}`,
 		`Auto session rename: ${autoRenameEnabled(ctx.cwd) ? `enabled (${settingString("sessionAutoRename.model", DEFAULT_AUTO_RENAME_MODEL, ctx.cwd)})` : "disabled"}`,
 		`Handoff command: ${settingBoolean("enableHandoffCommand", true, ctx.cwd) ? "enabled" : "disabled"}`,
+		`Schedule command: ${settingBoolean("enableScheduleCommand", true, ctx.cwd) ? "enabled (/schedule)" : "disabled"}`,
 		`Handoff prompt review: ${settingBoolean("handoffReviewPrompt", true, ctx.cwd) ? "enabled" : "disabled"}`,
 		`Session search: ${settingBoolean("sessionSearch.enabled", true, ctx.cwd) ? `enabled (/search${searchShortcut ? `, ${searchShortcut}` : ""})` : "disabled"}`,
 		`Custom compaction: ${settingBoolean("compaction.customEnabled", false, ctx.cwd) ? `enabled (${settingString("compaction.model", DEFAULT_COMPACTION_MODEL, ctx.cwd)}, ${compactionProfile(ctx.cwd)})` : "disabled (Pi default)"}`,
 		`Idle compaction: ${settingBoolean("compaction.idleEnabled", false, ctx.cwd) ? `enabled after ${Math.max(1, Math.floor(settingNumber("compaction.idleTimeoutSeconds", DEFAULT_IDLE_COMPACTION_SECONDS, ctx.cwd)))}s idle` : "disabled"}`,
 		`Branch summary override: ${settingBoolean("compaction.branchSummaryEnabled", false, ctx.cwd) ? "enabled" : "disabled"}`,
-		`Notifications: ${settingBoolean("notification.enabled", true, ctx.cwd) ? `enabled (bell=${settingBoolean("notification.bell", true, ctx.cwd)}, native=${settingBoolean("notification.native", true, ctx.cwd)}, tmuxClientTty=${settingBoolean("notification.tmuxNativeClientTty", true, ctx.cwd)}, tmuxMessage=${settingBoolean("notification.tmux", false, ctx.cwd)})` : "disabled"}`,
+		`Notifications: ${settingBoolean("notification.enabled", true, ctx.cwd) ? `enabled (bell=${settingBoolean("notification.bell", true, ctx.cwd)}, muteBell=${settingBoolean("notification.muteBellSound", false, ctx.cwd)}, native=${settingBoolean("notification.native", true, ctx.cwd)}, tmuxClientTty=${settingBoolean("notification.tmuxNativeClientTty", true, ctx.cwd)}, tmuxMessage=${settingBoolean("notification.tmux", false, ctx.cwd)})` : "disabled"}`,
 		`Permission gate: ${settingBoolean("permissionGate.enabled", false, ctx.cwd) ? `enabled (${permissionGateCommands(ctx.cwd).join(", ") || "none configured"}; preview ${boundedSettingNumber("permissionGate.previewLines", DEFAULT_PERMISSION_GATE_PREVIEW_LINES, 4, 40, ctx.cwd)} lines/${boundedSettingNumber("permissionGate.previewChars", DEFAULT_PERMISSION_GATE_PREVIEW_CHARS, 200, 5000, ctx.cwd)} chars)` : "disabled"}`,
 		`Thinking timer: ${settingBoolean("thinkingTimer.enabled", true, ctx.cwd) ? "enabled" : "disabled"}`,
 		"If shift+enter still submits, configure your terminal/tmux to send a distinct shift+enter sequence or use the fallback key.",

package/extensions/qol.ts

@@ -1,8 +1,9 @@
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { TUI } from "@earendil-works/pi-tui";
+import { truncateToWidth, type TUI } from "@earendil-works/pi-tui";
 import { criticalInfo, lastAssistantTextFromAgentEnd, needsDirection, taskStats } from "./qol/agent-end.js";
 import { getQuestionService, readCavemanBridge, type QuestionOpenedEventLike } from "./qol/bridges.js";
 import { BudgetGuardDriver } from "./qol/budget-guard-runtime.js";
+import { ansiGreen } from "./qol/ansi.js";
 import {
 	budgetGuardTrigger,
 	compactionTriggerReason,
@@ -46,6 +47,7 @@ import {
 	restorePendingQueueThemePatch,
 } from "./qol/pending-queue.js";
 import { permissionGateMatch, permissionGatePrompt } from "./qol/permission-gate.js";
+import { createRateLimitAutoResumeController, RATE_LIMIT_AUTO_RESUME_EVENT } from "./qol/rate-limit-auto-resume.js";
 import {
 	autoRenameEnabled,
 	autoRenameNotify,
@@ -55,6 +57,7 @@ import {
 	isStaleCtxError,
 	withAutoRenamePrefix,
 } from "./qol/session-rename.js";
+import { createScheduleController, getScheduleArgumentCompletions } from "./qol/schedule.js";
 import {
 	consumePendingSessionSearchContext,
 	openQolSessionSearch,
@@ -260,9 +263,19 @@ export default function qol(pi: ExtensionAPI): void {
 	};
 
 	const budgetGuardDriver = new BudgetGuardDriver();
+	let budgetGuardStatus: string | undefined;
+
+	const setBudgetGuardStatus = (ctx: ExtensionContext, message: string | undefined) => {
+		budgetGuardStatus = message;
+		if (ctx.hasUI) {
+			ctx.ui.setStatus("qol-budget-guard", message ? ctx.ui.theme.fg("accent", message) : undefined);
+			requestRender();
+		}
+	};
 
 	const resetBudgetGuard = () => {
 		budgetGuardDriver.reset();
+		budgetGuardStatus = undefined;
 	};
 
 	const maybeFireBudgetGuard = (ctx: ExtensionContext) => {
@@ -284,6 +297,7 @@ export default function qol(pi: ExtensionAPI): void {
 		budgetGuardDriver.dispatch({
 			compact: typeof ctx.compact === "function" ? ctx.compact.bind(ctx) : undefined,
 			notify: notifySafely,
+			onStatus: (message) => setBudgetGuardStatus(ctx, message),
 			trigger,
 		});
 	};
@@ -375,7 +389,13 @@ export default function qol(pi: ExtensionAPI): void {
 	let lastSessionTitle: string | undefined;
 
 	const requestRender = () => activeTui?.requestRender();
+	const scheduleController = createScheduleController(pi);
+	scheduleController.setOnChange(requestRender);
+	const rateLimitAutoResumeController = createRateLimitAutoResumeController(pi);
+	rateLimitAutoResumeController.setOnChange(requestRender);
+	const statuslineEnabled = (ctx: ExtensionContext): boolean => settingBoolean("statusline.enabled", true, ctx.cwd);
 	const refreshStatusline = (ctx: ExtensionContext) => {
+		if (!statuslineEnabled(ctx)) return Promise.resolve();
 		if (refreshInFlight) return refreshInFlight;
 		refreshInFlight = refreshGitState(pi, ctx)
 			.then((next) => {
@@ -534,6 +554,10 @@ export default function qol(pi: ExtensionAPI): void {
 		const event = data as QuestionOpenedEventLike;
 		notifyQuestionOpened(currentCtx, event, "question");
 	});
+	pi.events.on(RATE_LIMIT_AUTO_RESUME_EVENT, (payload: unknown) => {
+		if (!currentCtx) return;
+		rateLimitAutoResumeController.noteExternalRateLimitEvent(payload, currentCtx);
+	});
 
 	pi.on("session_start", (event, ctx) => {
 		currentCtx = ctx;
@@ -542,6 +566,10 @@ export default function qol(pi: ExtensionAPI): void {
 		resetAutoRename();
 		resetBudgetGuard();
 		resetThinkingTimer(ctx);
+		const scheduleEnabled = settingBoolean("enableScheduleCommand", true, ctx.cwd);
+		const rateLimitAutoResumeEnabled = rateLimitAutoResumeController.enabled(ctx);
+		if (scheduleEnabled) scheduleController.restoreFromBranch(ctx);
+		else scheduleController.clearTimers();
 		void consumePendingSessionSearchContext(pi, ctx, event.reason);
 		installAutocompleteHintStyling(ctx);
 		installPendingQueueThemePatch(ctx);
@@ -549,7 +577,8 @@ export default function qol(pi: ExtensionAPI): void {
 			ctx.ui.setHiddenThinkingLabel(hiddenThinkingLabel(ctx.ui.theme, ctx.cwd));
 			applyWorkingIndicatorMode(ctx);
 			gitState = makeFallbackGitState(ctx.cwd);
-			void refreshStatusline(ctx);
+			const showStatusline = statuslineEnabled(ctx);
+			if (showStatusline) void refreshStatusline(ctx);
 			installSessionTitle(ctx);
 			installSessionTitleSync(ctx);
 			ctx.ui.setEditorComponent((tui, theme, keybindings) => {
@@ -558,27 +587,33 @@ export default function qol(pi: ExtensionAPI): void {
 					? new QolCompactPromptEditor(tui, theme, keybindings, Math.max(0, Math.floor(settingNumber("inputBottomPaddingLines", DEFAULT_INPUT_BOTTOM_PADDING_LINES, ctx.cwd))), ctx)
 					: new QolEditor(tui, theme, keybindings, ctx);
 			});
-			const statusWidgetTimer = setTimeout(() => {
-				ctx.ui.setWidget("statusline", (tui, theme) => {
-					activeTui = tui;
-					return {
-						invalidate() {},
-						render(width: number): string[] {
-							return [renderStatusLine(width, ctx, gitState ?? makeFallbackGitState(ctx.cwd), pi, theme)];
-						},
-					};
-				});
-			}, 0);
-			statusWidgetTimer.unref?.();
-			if (settingBoolean("replaceFooter", true, ctx.cwd)) {
-				ctx.ui.setFooter((tui, _theme, footerData) => {
-					activeTui = tui;
-					const unsubscribe = footerData.onBranchChange(() => {
-						void refreshStatusline(ctx);
-						requestRender();
+			if (showStatusline || scheduleEnabled || rateLimitAutoResumeEnabled) {
+				const statusWidgetTimer = setTimeout(() => {
+					ctx.ui.setWidget("statusline", (tui, theme) => {
+						activeTui = tui;
+						return {
+							invalidate() {},
+							render(width: number): string[] {
+								const lines = rateLimitAutoResumeController.enabled(ctx) ? rateLimitAutoResumeController.renderPreviewLines(width) : [];
+								if (scheduleEnabled) lines.push(...scheduleController.renderPreviewLines(width));
+								if (budgetGuardStatus) lines.push(truncateToWidth(ansiGreen(`┃ ${budgetGuardStatus}`), width, ""));
+								if (showStatusline) lines.push(renderStatusLine(width, ctx, gitState ?? makeFallbackGitState(ctx.cwd), pi, theme));
+								return lines;
+							},
+						};
 					});
-					return { dispose: unsubscribe, invalidate() {}, render: () => [] };
-				});
+				}, 0);
+				statusWidgetTimer.unref?.();
+				if (showStatusline && settingBoolean("replaceFooter", true, ctx.cwd)) {
+					ctx.ui.setFooter((tui, _theme, footerData) => {
+						activeTui = tui;
+						const unsubscribe = footerData.onBranchChange(() => {
+							void refreshStatusline(ctx);
+							requestRender();
+						});
+						return { dispose: unsubscribe, invalidate() {}, render: () => [] };
+					});
+				}
 			}
 		}
 		startQuestionSubscription(ctx);
@@ -600,6 +635,8 @@ export default function qol(pi: ExtensionAPI): void {
 	pi.on("session_shutdown", (_event, ctx) => {
 		cavemanUnsubscribe?.();
 		cavemanUnsubscribe = undefined;
+		scheduleController.clearTimers();
+		rateLimitAutoResumeController.clearTimers();
 		resetAutoRename();
 		resetBudgetGuard();
 		clearIdleCompactionTimer();
@@ -611,10 +648,12 @@ export default function qol(pi: ExtensionAPI): void {
 		questionUnsubscribe?.();
 		questionUnsubscribe = undefined;
 		currentCtx = undefined;
+		budgetGuardStatus = undefined;
 		const host = globalThis as unknown as Record<PropertyKey, unknown>;
 		if (host[QOL_NOTIFICATION_SERVICE_SYMBOL] === notificationService) delete host[QOL_NOTIFICATION_SERVICE_SYMBOL];
 		ctx.ui.setStatus(STATUS_KEY, undefined);
 		ctx.ui.setStatus(SESSION_SEARCH_STATUS_KEY, undefined);
+		ctx.ui.setStatus("qol-budget-guard", undefined);
 		restorePendingQueueThemePatch(ctx);
 		resetStatuslineUi(ctx);
 		ctx.ui.setEditorComponent(undefined);
@@ -631,6 +670,7 @@ export default function qol(pi: ExtensionAPI): void {
 	pi.on("agent_start", (_event, ctx) => {
 		clearIdleCompactionTimer();
 		clearTmuxWindowMark();
+		rateLimitAutoResumeController.noteAgentStart(ctx);
 		if (ctx.hasUI) {
 			void refreshStatusline(ctx);
 			requestRender();
@@ -657,6 +697,7 @@ export default function qol(pi: ExtensionAPI): void {
 		}
 	});
 	pi.on("message_end", (event, ctx) => {
+		rateLimitAutoResumeController.noteMessageEnd(event, ctx);
 		if (!updateThinkingTimerEnabled(ctx)) return;
 		const message = event.message as any;
 		if (!message || message.role !== "assistant" || !Array.isArray(message.content)) return;
@@ -670,6 +711,7 @@ export default function qol(pi: ExtensionAPI): void {
 			void refreshStatusline(ctx);
 			requestRender();
 		}
+		rateLimitAutoResumeController.noteAgentEnd(event, ctx);
 		maybeFireBudgetGuard(ctx);
 		scheduleIdleCompaction(ctx);
 		void attemptAutoRename(ctx);
@@ -694,6 +736,7 @@ export default function qol(pi: ExtensionAPI): void {
 		sendQolNotification(ctx, "ready", settingString("notification.readyMessage", "Ready for input", ctx.cwd), "info", "ready");
 	});
 	pi.on("session_compact", (_event, ctx) => {
+		if (budgetGuardStatus) setBudgetGuardStatus(ctx, "QOL budget guard finalizing compaction…");
 		// After a successful compaction usage drops below the budget, so reset the
 		// crossing key so the next threshold crossing re-fires the guard.
 		budgetGuardDriver.noteSessionCompacted();
@@ -701,6 +744,14 @@ export default function qol(pi: ExtensionAPI): void {
 		void refreshStatusline(ctx);
 		requestRender();
 	});
+	pi.on("session_tree", (_event, ctx) => {
+		currentCtx = ctx;
+		if (settingBoolean("enableScheduleCommand", true, ctx.cwd)) scheduleController.restoreFromBranch(ctx);
+		else scheduleController.clearTimers();
+	});
+	pi.on("after_provider_response", (event, ctx) => {
+		rateLimitAutoResumeController.noteProviderResponse(event, ctx);
+	});
 	pi.on("session_before_compact", (event, ctx) => handleQolCompaction(event, ctx));
 	pi.on("session_before_tree", (event, ctx) => handleQolBranchSummary(event, ctx));
 	pi.on("tool_call", async (event: any, ctx) => {
@@ -758,6 +809,14 @@ export default function qol(pi: ExtensionAPI): void {
 		});
 	}
 
+	if (settingBoolean("enableScheduleCommand", true)) {
+		pi.registerCommand("schedule", {
+			description: "Send a user message after a timer without invoking the model now.",
+			getArgumentCompletions: getScheduleArgumentCompletions,
+			handler: async (args, ctx) => scheduleController.handleCommand(args, ctx),
+		});
+	}
+
 	if (settingBoolean("enableContextCommand", true)) {
 		pi.registerMessageRenderer(CONTEXT_USAGE_MESSAGE_TYPE, renderQolContextUsageMessage);
 		pi.registerCommand("context", {