@vanillagreen/pi-qol 1.5.0 → 1.6.0

package/README.md

@@ -5,16 +5,18 @@
 ![Session search popup](https://raw.githubusercontent.com/vanillagreencom/vstack/main/pi-extensions/pi-qol/assets/session-search.gif)
 ![/context usage breakdown](https://raw.githubusercontent.com/vanillagreencom/vstack/main/pi-extensions/pi-qol/assets/context-usage.png)
 
-Quality-of-life extension for Pi: compact statusline, multiline input, session naming and search, notifications, and a permission gate.
+Quality-of-life extension for Pi: compact statusline, multiline input, session naming and search, scheduled prompts, notifications, and a permission gate.
 
 ## Highlights
 
-- Compact statusline with repo, branch, model, thinking level, and context percent.
+- Compact statusline with repo, branch, model, thinking level, and context percent; can be disabled.
 - Newline-insert in the editor (multi-line drafts without auto-submit), with a fallback binding for terminals that can't distinguish the primary key.
 - Sessions auto-name from your first prompt. `/rename` overrides anytime.
 - `/search` browses previous sessions with snippet previews; the configured shortcut opens it instantly.
 - `/context` shows a Claude-style context-window breakdown.
 - `/handoff <goal>` drafts a focused prompt for a new session.
+- `/schedule 20m <message>` sends a delayed prompt without invoking the model until the timer fires.
+- Optional rate-limit auto-resume sends a configurable continuation after reset.
 - Permission gate prompts before risky `bash` commands. Default match: `rm -Rf`.
 - Notifications for ready, questions, blocked states, and task completion.
 - Thinking timer next to collapsed `Thinking...` labels.
@@ -51,9 +53,12 @@ Restart Pi after installation.
 | `/search [query]` | Open previous-session search. |
 | `/search:refresh` | Refresh the session search cache. |
 | `/handoff <goal>` | Draft a handoff prompt for a new session. |
+| `/schedule <delay> <message>` | Send a user message after a timer without invoking the model now. Example: `/schedule 20m retry the previous request`. |
 
 Arguments support autocomplete.
 
+`/schedule` accepts `ms`, `s`, `m`, `h`, and `d` units; bare numbers mean minutes. Pending prompts render above the statusline like steering/follow-up previews until they are sent or cancelled. Manage pending prompts with `/schedule list` and `/schedule cancel <id|all>`. Schedules are stored in the Pi session and re-armed on reload/resume; if Pi is not running at the due time, an overdue prompt sends when that session is next loaded.
+
 ## Settings
 
 Open `/extensions:settings`; settings appear under the **QOL** tab. Names below match the labels shown there.
@@ -65,7 +70,8 @@ Glyph style: each package exposes `glyphStyle` (`unicode` default, `ascii` for t
 | Setting | What it does |
 | --- | --- |
 | Enable QOL editor helpers | Master toggle for QOL statusline, commands, notifications, search, compaction, and editor helpers. |
-| Replace built-in footer | Hide Pi's default footer while the QOL statusline is active. |
+| Show compact statusline | Render or disable the QOL statusline row. |
+| Replace built-in footer | Hide Pi's default footer while the QOL statusline is enabled. |
 | Use π prompt editor | Use the compact prompt editor. |
 | Show session name title | Show the session name above the prompt and in the tmux pane title. |
 | Sync session name to tmux window name | Rename the tmux window to `π <session>`. |
@@ -82,11 +88,13 @@ Glyph style: each package exposes `glyphStyle` (`unicode` default, `ascii` for t
 | Style image chips | Render `[Image #N]` placeholders as distinct chips. |
 | Show attachment count | Show a status badge when the draft has image placeholders. |
 
-### Session naming
+### Session
 
 | Setting | What it does |
 | --- | --- |
 | Enable /rename command | Register the `/rename` command. |
+| Enable /schedule command | Register `/schedule` for timer-based prompts, useful for retrying after rate limits reset. |
+| Auto-resume after rate limits | Send the configured continuation after a detected reset; cancels on newer turn. |
 | Auto-name new sessions | Generate a friendly session name from the first prompt. |
 | Auto-rename model | Model used for title generation. |
 | Auto-rename fallback model | Model tried when the primary fails. |

package/extensions/qol/rate-limit-auto-resume.ts

@@ -0,0 +1,447 @@
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { ansiRed } from "./ansi.js";
+import { boundedSettingNumber, settingBoolean, settingString } from "./settings.js";
+import { stringifyError } from "./util.js";
+
+export const RATE_LIMIT_AUTO_RESUME_EVENT = "vstack:rate-limit";
+export const DEFAULT_RATE_LIMIT_RESUME_MESSAGE = "Hit API rate limit. It has been reset. Continue";
+
+const MAX_TIMER_DELAY_MS = 2_147_000_000;
+const DEFAULT_BUFFER_SECONDS = 10;
+const DEFAULT_MAX_DELAY_MINUTES = 24 * 60;
+const RATE_LIMIT_TOKEN = "[rate-limit]";
+
+interface RateLimitTimer {
+	unref?: () => void;
+}
+
+export interface RateLimitClock {
+	now(): number;
+	setTimeout(callback: () => void, delayMs: number): RateLimitTimer;
+	clearTimeout(timer: RateLimitTimer): void;
+}
+
+export interface RateLimitHint {
+	message?: string;
+	model?: string;
+	observedAt: number;
+	provider?: string;
+	reason?: string;
+	resetAt?: number;
+	source: string;
+	turnId: number;
+}
+
+interface PendingRateLimitResume {
+	dueAt: number;
+	message: string;
+	reason?: string;
+	resetAt: number;
+	source: string;
+	timer?: RateLimitTimer;
+	turnId: number;
+}
+
+const DEFAULT_CLOCK: RateLimitClock = {
+	now: () => Date.now(),
+	setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+	clearTimeout: (timer) => clearTimeout(timer as ReturnType<typeof setTimeout>),
+};
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
+}
+
+function stringValue(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+
+function numberValue(value: unknown): number | undefined {
+	const parsed = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : Number.NaN;
+	return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+function allHeaderValues(headers: unknown, key: string): string[] {
+	const wanted = key.toLowerCase();
+	if (!headers || typeof headers !== "object") return [];
+	const anyHeaders = headers as any;
+	try {
+		if (typeof anyHeaders.get === "function") {
+			const value = anyHeaders.get(key) ?? anyHeaders.get(wanted);
+			if (typeof value === "string" && value.trim()) return [value.trim()];
+		}
+	} catch {
+		// Fall through to object form.
+	}
+	const out: string[] = [];
+	for (const [rawKey, rawValue] of Object.entries(headers as Record<string, unknown>)) {
+		if (rawKey.toLowerCase() !== wanted) continue;
+		if (Array.isArray(rawValue)) {
+			for (const item of rawValue) if (typeof item === "string" && item.trim()) out.push(item.trim());
+		} else if (typeof rawValue === "string" && rawValue.trim()) out.push(rawValue.trim());
+		else if (typeof rawValue === "number" && Number.isFinite(rawValue)) out.push(String(rawValue));
+	}
+	return out;
+}
+
+export function looksLikeRateLimitText(text: string): boolean {
+	return /\b(rate[-\s]?limit(?:ed)?|too many requests|\b429\b|quota exceeded|resource exhausted|try again later|retry[-\s]?after|out of extra usage|extra usage)\b/i.test(text);
+}
+
+function parseUnitDurationMs(amount: number, unit: string | undefined, defaultUnit: "ms" | "s" | "m" = "s"): number | undefined {
+	if (!Number.isFinite(amount) || amount < 0) return undefined;
+	const normalized = (unit ?? defaultUnit).toLowerCase();
+	const multiplier = ["ms", "msec", "msecs", "millisecond", "milliseconds"].includes(normalized)
+		? 1
+		: ["s", "sec", "secs", "second", "seconds"].includes(normalized)
+			? 1000
+			: ["m", "min", "mins", "minute", "minutes"].includes(normalized)
+				? 60 * 1000
+				: ["h", "hr", "hrs", "hour", "hours"].includes(normalized)
+					? 60 * 60 * 1000
+					: ["d", "day", "days"].includes(normalized)
+						? 24 * 60 * 60 * 1000
+						: undefined;
+	if (!multiplier) return undefined;
+	const delay = Math.round(amount * multiplier);
+	return Number.isFinite(delay) ? delay : undefined;
+}
+
+export function parseDurationLikeMs(value: string, defaultUnit: "ms" | "s" | "m" = "s"): number | undefined {
+	const text = value.trim().toLowerCase();
+	if (!text) return undefined;
+	if (/^\d+(?:\.\d+)?$/.test(text)) return parseUnitDurationMs(Number(text), undefined, defaultUnit);
+	const single = text.match(/^(\d+(?:\.\d+)?)\s*(ms|msec|msecs|milliseconds?|s|sec|secs|seconds?|m|min|mins|minutes?|h|hr|hrs|hours?|d|days?)$/i);
+	if (single) return parseUnitDurationMs(Number(single[1]), single[2], defaultUnit);
+	let total = 0;
+	let matched = false;
+	const re = /(\d+(?:\.\d+)?)\s*(ms|msec|msecs|milliseconds?|s|sec|secs|seconds?|m|min|mins|minutes?|h|hr|hrs|hours?|d|days?)/gi;
+	for (const match of text.matchAll(re)) {
+		const part = parseUnitDurationMs(Number(match[1]), match[2], defaultUnit);
+		if (part === undefined) return undefined;
+		total += part;
+		matched = true;
+	}
+	return matched && Number.isFinite(total) ? Math.round(total) : undefined;
+}
+
+export function parseRetryAfterMs(value: string, now = Date.now(), defaultUnit: "ms" | "s" | "m" = "s"): number | undefined {
+	const duration = parseDurationLikeMs(value, defaultUnit);
+	if (duration !== undefined) return now + duration;
+	const parsedDate = Date.parse(value);
+	return Number.isFinite(parsedDate) ? parsedDate : undefined;
+}
+
+export function parseResetValueMs(value: string, now = Date.now()): number | undefined {
+	const trimmed = value.trim();
+	if (!trimmed) return undefined;
+	const numeric = Number(trimmed);
+	if (Number.isFinite(numeric)) {
+		if (numeric > 1_000_000_000_000) return numeric;
+		if (numeric > 1_000_000_000) return numeric * 1000;
+		return now + numeric * 1000;
+	}
+	const parsedDate = Date.parse(trimmed);
+	if (Number.isFinite(parsedDate)) return parsedDate;
+	const duration = parseDurationLikeMs(trimmed, "s");
+	return duration !== undefined ? now + duration : undefined;
+}
+
+export function extractResetAtFromHeaders(headers: unknown, now = Date.now()): { resetAt: number; source: string } | undefined {
+	for (const value of allHeaderValues(headers, "retry-after-ms")) {
+		const resetAt = parseRetryAfterMs(value, now, "ms");
+		if (resetAt !== undefined) return { resetAt, source: "retry-after-ms" };
+	}
+	for (const value of allHeaderValues(headers, "retry-after")) {
+		const resetAt = parseRetryAfterMs(value, now, "s");
+		if (resetAt !== undefined) return { resetAt, source: "retry-after" };
+	}
+	const resetHeaders = [
+		"x-ratelimit-reset",
+		"x-rate-limit-reset",
+		"ratelimit-reset",
+		"x-ratelimit-reset-requests",
+		"x-ratelimit-reset-tokens",
+		"anthropic-ratelimit-requests-reset",
+		"anthropic-ratelimit-tokens-reset",
+		"anthropic-ratelimit-input-tokens-reset",
+		"anthropic-ratelimit-output-tokens-reset",
+	];
+	for (const header of resetHeaders) {
+		for (const value of allHeaderValues(headers, header)) {
+			const resetAt = parseResetValueMs(value, now);
+			if (resetAt !== undefined) return { resetAt, source: header };
+		}
+	}
+	return undefined;
+}
+
+function parseClockReset(text: string, now = Date.now()): number | undefined {
+	const match = text.match(/\bresets?(?:\s+at)?\s+(\d{1,2})(?::(\d{2}))?(?::(\d{2}))?\s*(am|pm)?\b/i);
+	if (!match) return undefined;
+	let hour = Number(match[1]);
+	const minute = Number(match[2] ?? "0");
+	const second = Number(match[3] ?? "0");
+	const meridiem = match[4]?.toLowerCase();
+	if (!Number.isInteger(hour) || !Number.isInteger(minute) || !Number.isInteger(second)) return undefined;
+	if (minute > 59 || second > 59) return undefined;
+	if (meridiem) {
+		if (hour < 1 || hour > 12) return undefined;
+		if (meridiem === "pm" && hour !== 12) hour += 12;
+		if (meridiem === "am" && hour === 12) hour = 0;
+	} else if (hour > 23) return undefined;
+	const date = new Date(now);
+	date.setHours(hour, minute, second, 0);
+	if (date.getTime() <= now) date.setDate(date.getDate() + 1);
+	return date.getTime();
+}
+
+export function extractResetAtFromText(text: string, now = Date.now()): { resetAt: number; source: string } | undefined {
+	const iso = text.match(/\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})\b/);
+	if (iso) {
+		const resetAt = Date.parse(iso[0]);
+		if (Number.isFinite(resetAt)) return { resetAt, source: "text-iso" };
+	}
+	const durationMatch = text.match(/\b(?:retry(?:\s+after|\s+in)?|try again in|wait)\s+(\d+(?:\.\d+)?\s*(?:ms|msec|msecs|milliseconds?|s|sec|secs|seconds?|m|min|mins|minutes?|h|hr|hrs|hours?|d|days?)(?:\s*\d+(?:\.\d+)?\s*(?:ms|msec|msecs|milliseconds?|s|sec|secs|seconds?|m|min|mins|minutes?|h|hr|hrs|hours?|d|days?))*)\b/i);
+	if (durationMatch) {
+		const duration = parseDurationLikeMs(durationMatch[1], "s");
+		if (duration !== undefined) return { resetAt: now + duration, source: "text-duration" };
+	}
+	const clock = parseClockReset(text, now);
+	return clock !== undefined ? { resetAt: clock, source: "text-clock" } : undefined;
+}
+
+function messageText(message: any): string {
+	const parts: string[] = [];
+	if (typeof message?.errorMessage === "string") parts.push(message.errorMessage);
+	if (typeof message?.content === "string") parts.push(message.content);
+	else if (Array.isArray(message?.content)) {
+		for (const block of message.content) {
+			if (typeof block === "string") parts.push(block);
+			else if (block?.type === "text" && typeof block.text === "string") parts.push(block.text);
+		}
+	}
+	return parts.filter(Boolean).join("\n");
+}
+
+function lastAssistantMessage(event: any, ctx: ExtensionContext): any | undefined {
+	const eventMessages = Array.isArray(event?.messages) ? event.messages : [];
+	for (let index = eventMessages.length - 1; index >= 0; index -= 1) {
+		const message = eventMessages[index];
+		if (message?.role === "assistant") return message;
+	}
+	const branch = ctx.sessionManager.getBranch?.() ?? [];
+	for (let index = branch.length - 1; index >= 0; index -= 1) {
+		const entry = branch[index] as any;
+		if (entry?.type === "message" && entry.message?.role === "assistant") return entry.message;
+	}
+	return undefined;
+}
+
+function formatDueTime(timestamp: number): string {
+	return new Date(timestamp).toLocaleString(undefined, {
+		day: "numeric",
+		hour: "numeric",
+		minute: "2-digit",
+		month: "short",
+		timeZoneName: "short",
+	});
+}
+
+function previewMessage(message: string, max = 72): string {
+	const singleLine = message.replace(/\s+/g, " ").trim();
+	return singleLine.length <= max ? singleLine : `${singleLine.slice(0, Math.max(0, max - 1))}…`;
+}
+
+function settingsEnabled(ctx: ExtensionContext): boolean {
+	return settingBoolean("rateLimitAutoResume.enabled", false, ctx.cwd);
+}
+
+function settingsNotify(ctx: ExtensionContext): boolean {
+	return settingBoolean("rateLimitAutoResume.notify", true, ctx.cwd);
+}
+
+function settingsMessage(ctx: ExtensionContext): string {
+	return settingString("rateLimitAutoResume.message", DEFAULT_RATE_LIMIT_RESUME_MESSAGE, ctx.cwd);
+}
+
+function settingsBufferMs(ctx: ExtensionContext): number {
+	return boundedSettingNumber("rateLimitAutoResume.bufferSeconds", DEFAULT_BUFFER_SECONDS, 0, 600, ctx.cwd) * 1000;
+}
+
+function settingsMaxDelayMs(ctx: ExtensionContext): number {
+	return boundedSettingNumber("rateLimitAutoResume.maxDelayMinutes", DEFAULT_MAX_DELAY_MINUTES, 1, 30 * 24 * 60, ctx.cwd) * 60 * 1000;
+}
+
+export function createRateLimitAutoResumeController(pi: ExtensionAPI, clock: RateLimitClock = DEFAULT_CLOCK) {
+	let onChange: (() => void) | undefined;
+	let turnId = 0;
+	let latestHint: RateLimitHint | undefined;
+	let pending: PendingRateLimitResume | undefined;
+
+	const notifyChanged = (): void => {
+		try { onChange?.(); }
+		catch { /* UI refresh must never break recovery state. */ }
+	};
+
+	const clearPendingTimer = (): void => {
+		if (!pending?.timer) return;
+		clock.clearTimeout(pending.timer);
+		pending.timer = undefined;
+	};
+
+	const clearPending = (): void => {
+		const hadPending = Boolean(pending);
+		clearPendingTimer();
+		pending = undefined;
+		if (hadPending) notifyChanged();
+	};
+
+	const noteHint = (hint: Omit<RateLimitHint, "observedAt" | "turnId"> & { observedAt?: number; turnId?: number }): void => {
+		if (hint.resetAt !== undefined && (!Number.isFinite(hint.resetAt) || hint.resetAt <= 0)) return;
+		latestHint = {
+			...hint,
+			observedAt: hint.observedAt ?? clock.now(),
+			turnId: hint.turnId ?? turnId,
+		};
+	};
+
+	const deliverPending = async (snapshot: PendingRateLimitResume, ctx: ExtensionContext): Promise<void> => {
+		if (pending !== snapshot) return;
+		if (snapshot.turnId !== turnId || !settingsEnabled(ctx)) {
+			clearPending();
+			return;
+		}
+		if (clock.now() < snapshot.dueAt) {
+			armPending(snapshot, ctx);
+			return;
+		}
+		clearPending();
+		try {
+			let idle = true;
+			try { idle = ctx.isIdle?.() ?? true; }
+			catch { idle = false; }
+			await Promise.resolve(idle ? pi.sendUserMessage(snapshot.message) : pi.sendUserMessage(snapshot.message, { deliverAs: "followUp" }));
+			if (ctx.hasUI && settingsNotify(ctx)) ctx.ui.notify(`${RATE_LIMIT_TOKEN} Auto-resume sent after rate-limit reset.`, "info");
+		} catch (error) {
+			if (ctx.hasUI) ctx.ui.notify(`${RATE_LIMIT_TOKEN} Auto-resume failed: ${stringifyError(error)}`, "error");
+		}
+	};
+
+	function armPending(snapshot: PendingRateLimitResume, ctx: ExtensionContext): void {
+		clearPendingTimer();
+		const remaining = Math.max(0, snapshot.dueAt - clock.now());
+		snapshot.timer = clock.setTimeout(() => { void deliverPending(snapshot, ctx); }, Math.min(remaining, MAX_TIMER_DELAY_MS));
+		snapshot.timer.unref?.();
+	}
+
+	const scheduleFromHint = (hint: RateLimitHint, ctx: ExtensionContext): boolean => {
+		if (!settingsEnabled(ctx)) return false;
+		if (hint.turnId !== turnId) return false;
+		if (ctx.hasPendingMessages?.()) return false;
+		if (hint.resetAt === undefined || !Number.isFinite(hint.resetAt)) return false;
+		const dueAt = Math.max(clock.now() + 1000, hint.resetAt + settingsBufferMs(ctx));
+		const delay = dueAt - clock.now();
+		if (delay > settingsMaxDelayMs(ctx)) return false;
+		const message = settingsMessage(ctx);
+		clearPendingTimer();
+		pending = { dueAt, message, reason: hint.reason, resetAt: hint.resetAt, source: hint.source, turnId };
+		armPending(pending, ctx);
+		notifyChanged();
+		if (ctx.hasUI && settingsNotify(ctx)) {
+			ctx.ui.notify(`${RATE_LIMIT_TOKEN} Rate limit hit. Auto-resume scheduled for ${formatDueTime(dueAt)}.`, "warning");
+		}
+		return true;
+	};
+
+	return {
+		enabled(ctx: ExtensionContext): boolean {
+			return settingsEnabled(ctx);
+		},
+		clearTimers(): void {
+			clearPending();
+		},
+		noteAgentStart(_ctx: ExtensionContext): void {
+			turnId += 1;
+			latestHint = undefined;
+			clearPending();
+		},
+		noteAgentEnd(event: any, ctx: ExtensionContext): boolean {
+			const assistant = lastAssistantMessage(event, ctx);
+			const text = messageText(assistant);
+			const textShowsRateLimit = Boolean(text && looksLikeRateLimitText(text));
+			if (textShowsRateLimit) {
+				const reset = extractResetAtFromText(text, clock.now());
+				noteHint({
+					message: text,
+					model: stringValue(assistant?.model),
+					provider: stringValue(assistant?.provider),
+					reason: "assistant error",
+					resetAt: reset?.resetAt ?? latestHint?.resetAt,
+					source: reset?.source ?? latestHint?.source ?? "assistant-message",
+				});
+			}
+			const stoppedOnHint = !assistant || assistant?.stopReason === "error" || assistant?.stopReason === "aborted";
+			if (!textShowsRateLimit && !stoppedOnHint) return false;
+			return latestHint ? scheduleFromHint(latestHint, ctx) : false;
+		},
+		noteMessageEnd(event: any, _ctx: ExtensionContext): void {
+			const message = event?.message;
+			if (!message || message.role !== "assistant") return;
+			const text = messageText(message);
+			if (!looksLikeRateLimitText(text)) return;
+			const reset = extractResetAtFromText(text, clock.now());
+			noteHint({
+				message: text,
+				model: stringValue(message.model),
+				provider: stringValue(message.provider),
+				reason: "assistant message",
+				resetAt: reset?.resetAt ?? latestHint?.resetAt,
+				source: reset?.source ?? latestHint?.source ?? "message_end",
+			});
+		},
+		noteProviderResponse(event: any, _ctx: ExtensionContext): void {
+			if (Number(event?.status) !== 429) return;
+			const reset = extractResetAtFromHeaders(event?.headers, clock.now());
+			noteHint({
+				model: stringValue(event?.model?.id) ?? stringValue(event?.model),
+				provider: stringValue(event?.provider?.id) ?? stringValue(event?.provider),
+				reason: "HTTP 429",
+				resetAt: reset?.resetAt ?? latestHint?.resetAt,
+				source: reset?.source ?? latestHint?.source ?? "after_provider_response",
+			});
+		},
+		noteExternalRateLimitEvent(payload: unknown, _ctx: ExtensionContext): void {
+			const event = asRecord(payload);
+			if (!event) return;
+			const status = stringValue(event.status);
+			if (status && status !== "rejected" && status !== "rate_limited" && status !== "error") return;
+			const rawReset = numberValue(event.resetAtMs) ?? numberValue(event.resetAtUnixMs);
+			const textReset = stringValue(event.resetAt) ?? stringValue(event.resetsAt);
+			const parsedTextReset = textReset ? parseResetValueMs(textReset, clock.now()) : undefined;
+			const resetAt = rawReset ?? parsedTextReset;
+			noteHint({
+				message: stringValue(event.message),
+				model: stringValue(event.model),
+				provider: stringValue(event.provider),
+				reason: stringValue(event.reason) ?? stringValue(event.rateLimitType),
+				resetAt: resetAt ?? latestHint?.resetAt,
+				source: stringValue(event.source) ?? latestHint?.source ?? RATE_LIMIT_AUTO_RESUME_EVENT,
+			});
+		},
+		renderPreviewLines(width: number): string[] {
+			if (!pending) return [];
+			const line = `| ${RATE_LIMIT_TOKEN} Auto-resume ${formatDueTime(pending.dueAt)} — ${previewMessage(pending.message)}`;
+			return [truncateToWidth(ansiRed(line), width, "")];
+		},
+		setOnChange(callback: (() => void) | undefined): void {
+			onChange = callback;
+		},
+		// Test helper / low-level extension bridge.
+		scheduleForHint(hint: RateLimitHint, ctx: ExtensionContext): boolean {
+			latestHint = hint;
+			return scheduleFromHint(hint, ctx);
+		},
+	};
+}

package/extensions/qol/schedule.ts

@@ -0,0 +1,320 @@
+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: "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 match = input.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)(ms|s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours|d|day|days)?$/);
+	if (!match) return undefined;
+	const amount = Number(match[1]);
+	if (!Number.isFinite(amount) || amount <= 0) return undefined;
+	const unit = match[2] ?? "m";
+	const multiplier = unit === "ms"
+		? 1
+		: ["s", "sec", "secs", "second", "seconds"].includes(unit)
+			? 1000
+			: ["h", "hr", "hrs", "hour", "hours"].includes(unit)
+				? 60 * 60 * 1000
+				: ["d", "day", "days"].includes(unit)
+					? 24 * 60 * 60 * 1000
+					: 60 * 1000;
+	const delayMs = Math.round(amount * multiplier);
+	if (!Number.isFinite(delayMs) || delayMs <= 0 || delayMs > MAX_SCHEDULE_DELAY_MS) return undefined;
+	return delayMs;
+}
+
+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 1h retry after the rate limit reset",
+		"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,6 +33,7 @@ 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)"}`,

package/extensions/qol.ts

@@ -46,6 +46,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 +56,7 @@ import {
 	isStaleCtxError,
 	withAutoRenamePrefix,
 } from "./qol/session-rename.js";
+import { createScheduleController, getScheduleArgumentCompletions } from "./qol/schedule.js";
 import {
 	consumePendingSessionSearchContext,
 	openQolSessionSearch,
@@ -375,7 +377,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 +542,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 +554,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 +565,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 +575,32 @@ 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 (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 +622,8 @@ export default function qol(pi: ExtensionAPI): void {
 	pi.on("session_shutdown", (_event, ctx) => {
 		cavemanUnsubscribe?.();
 		cavemanUnsubscribe = undefined;
+		scheduleController.clearTimers();
+		rateLimitAutoResumeController.clearTimers();
 		resetAutoRename();
 		resetBudgetGuard();
 		clearIdleCompactionTimer();
@@ -631,6 +655,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 +682,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 +696,7 @@ export default function qol(pi: ExtensionAPI): void {
 			void refreshStatusline(ctx);
 			requestRender();
 		}
+		rateLimitAutoResumeController.noteAgentEnd(event, ctx);
 		maybeFireBudgetGuard(ctx);
 		scheduleIdleCompaction(ctx);
 		void attemptAutoRename(ctx);
@@ -701,6 +728,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 +793,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", {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vanillagreen/pi-qol",
-  "version": "1.5.0",
-  "description": "Pi quality-of-life extension: compact statusline/π prompt, reliable multiline input, styled pasted-image chips, session naming/search/context import, handoff, permission prompts, notifications, custom compaction, and a collapsed-thinking timer.",
+  "version": "1.6.0",
+  "description": "Pi quality-of-life extension: compact statusline/π prompt, reliable multiline input, styled pasted-image chips, session naming/search/context import, scheduled prompts, handoff, permission prompts, notifications, custom compaction, and a collapsed-thinking timer.",
   "license": "MIT",
   "keywords": [
     "pi-package",
@@ -46,10 +46,20 @@
           "category": "Rendering",
           "apply": "live"
         },
+        {
+          "key": "statusline.enabled",
+          "label": "Show compact statusline",
+          "description": "Render the QOL statusline row with repo, branch, model, thinking level, and context percentage. Disable when another statusline/footer extension owns this UI.",
+          "type": "boolean",
+          "default": true,
+          "category": "Statusline",
+          "apply": "reload",
+          "requiresReload": true
+        },
         {
           "key": "replaceFooter",
           "label": "Replace built-in footer",
-          "description": "Hide Pi default footer while the compact QOL statusline is active.",
+          "description": "Hide Pi default footer while the compact QOL statusline is enabled.",
           "type": "boolean",
           "default": true,
           "category": "Statusline",
@@ -334,6 +344,61 @@
           "apply": "reload",
           "requiresReload": true
         },
+        {
+          "key": "enableScheduleCommand",
+          "label": "Enable /schedule command",
+          "description": "Register /schedule for timer-based user messages, e.g. /schedule 20m retry after rate reset. The timer runs in the extension without invoking the model immediately.",
+          "type": "boolean",
+          "default": true,
+          "category": "Session",
+          "apply": "reload",
+          "requiresReload": true
+        },
+        {
+          "key": "rateLimitAutoResume.enabled",
+          "label": "Auto-resume after rate limits",
+          "description": "When Pi detects a rate-limit stop with a reset time, schedule a follow-up user message at the reset time so the agent can continue if nothing else has continued since.",
+          "type": "boolean",
+          "default": false,
+          "category": "Rate Limit Recovery",
+          "apply": "live"
+        },
+        {
+          "key": "rateLimitAutoResume.message",
+          "label": "Auto-resume message",
+          "description": "User message sent after a detected rate limit resets.",
+          "type": "string",
+          "default": "Hit API rate limit. It has been reset. Continue",
+          "category": "Rate Limit Recovery",
+          "apply": "live"
+        },
+        {
+          "key": "rateLimitAutoResume.bufferSeconds",
+          "label": "Reset buffer seconds",
+          "description": "Seconds to wait after the reported reset time before sending the auto-resume message.",
+          "type": "number",
+          "default": 10,
+          "category": "Rate Limit Recovery",
+          "apply": "live"
+        },
+        {
+          "key": "rateLimitAutoResume.maxDelayMinutes",
+          "label": "Maximum auto-resume delay",
+          "description": "Ignore detected reset times farther away than this many minutes, to avoid stale or malformed schedules.",
+          "type": "number",
+          "default": 1440,
+          "category": "Rate Limit Recovery",
+          "apply": "live"
+        },
+        {
+          "key": "rateLimitAutoResume.notify",
+          "label": "Notify on auto-resume",
+          "description": "Show Pi UI notices when rate-limit auto-resume is scheduled, sent, or fails.",
+          "type": "boolean",
+          "default": true,
+          "category": "Rate Limit Recovery",
+          "apply": "live"
+        },
         {
           "key": "handoffReviewPrompt",
           "label": "Review handoff prompt",