scream-code 0.15.1 → 0.15.3

package/dist/{dispatch-Doe-DlpL.mjs → dispatch-CweYoXh3.mjs}

@@ -3,5 +3,5 @@ import { fileURLToPath as __cjsShimFileURLToPath } from 'node:url';
 import { dirname as __cjsShimDirname } from 'node:path';
 const __filename = __cjsShimFileURLToPath(import.meta.url);
 const __dirname = __cjsShimDirname(__filename);
-import { Kt as handleConnectCommand } from "./dispatch-ATQMQq1p.mjs";
+import { Kt as handleConnectCommand } from "./dispatch-DGeogib-.mjs";
 export { handleConnectCommand };

package/dist/{dispatch-ATQMQq1p.mjs → dispatch-DGeogib-.mjs}

@@ -34205,14 +34205,27 @@ function convertMediaUrl(url, fallbackMimeType) {
 function createAbortError() {
 	return new DOMException("The operation was aborted.", "AbortError");
 }
-async function abortPromise(signal) {
-	if (signal === void 0) return new Promise(() => {});
+/**
+* Race async work against an abort signal, ALWAYS detaching the listener.
+* The Google GenAI SDK does not accept an AbortSignal, so callers race the
+* SDK call against the signal manually. A bare `addEventListener({ once })`
+* inside a losing promise leaks the listener on the caller's signal for the
+* rest of its lifetime - with a session-scoped signal that accumulates one
+* listener per request. This wrapper guarantees cleanup in both outcomes.
+*/
+async function abortRace(signal, work) {
+	if (signal === void 0) return work;
 	if (signal.aborted) throw createAbortError();
-	return new Promise((_, reject) => {
-		signal.addEventListener("abort", () => {
-			reject(createAbortError());
-		}, { once: true });
+	let onAbort = void 0;
+	const abortPromise = new Promise((_, reject) => {
+		onAbort = () => reject(createAbortError());
+		signal.addEventListener("abort", onAbort, { once: true });
 	});
+	try {
+		return await Promise.race([work, abortPromise]);
+	} finally {
+		if (onAbort !== void 0) signal.removeEventListener("abort", onAbort);
+	}
 }
 function messageToGoogleGenAI(message) {
 	if (message.role === "tool") throw new ChatProviderError("Tool messages must be converted via messagesToGoogleGenAIContents.");
@@ -34582,8 +34595,8 @@ var GoogleGenAIChatProvider = class {
 				contents,
 				config
 			};
-			if (this._stream) return new GoogleGenAIStreamedMessage(await Promise.race([models.generateContentStream(params), abortPromise(options?.signal)]), true, options?.signal);
-			return new GoogleGenAIStreamedMessage(await Promise.race([models.generateContent(params), abortPromise(options?.signal)]), false, options?.signal);
+			if (this._stream) return new GoogleGenAIStreamedMessage(await abortRace(options?.signal, models.generateContentStream(params)), true, options?.signal);
+			return new GoogleGenAIStreamedMessage(await abortRace(options?.signal, models.generateContent(params)), false, options?.signal);
 		} catch (error) {
 			if (error instanceof DOMException && error.name === "AbortError") throw error;
 			throw convertGoogleGenAIError(error);
@@ -47619,9 +47632,41 @@ function estimateTokensForMessage(message) {
 	messageTokenCache.set(message, total);
 	return total;
 }
+/**
+* Media parts carry no width/height metadata, and providers differ on how they
+* tokenize media (image token counts range from a few hundred to ~1600 for a
+* single image depending on provider and resolution). There is no cross-
+* provider formula, so these estimates are deliberately conservative — for
+* watermark detection an OVERestimate only compacts slightly earlier
+* (harmless), whereas counting media as 0 systematically UNDERESTIMATED the
+* watermark and delayed compaction on media-heavy sessions.
+*
+* These estimates are consumed only by watermark detection and micro-compaction
+* recycling decisions — the real usage reported by the provider re-anchors the
+* context token count at each step end, so billing/usage accounting is
+* unaffected.
+*/
+const IMAGE_BASE_TOKENS = 1600;
+const IMAGE_MAX_TOKENS = 8e3;
+/** data-URI payloads above this many bytes are treated as high-resolution/long captures. */
+const IMAGE_LARGE_PAYLOAD_BYTES = 512e3;
+const AUDIO_TOKENS = 2e3;
+const VIDEO_TOKENS = 5e3;
+/** Long screenshots (large data URIs) carry more visual content than a single
+*  bounded-resolution image; grow the estimate linearly and cap it. */
+function estimateDataUriTokens(url, baseTokens, maxTokens) {
+	const start = url.indexOf("base64,");
+	if (start < 0) return baseTokens;
+	const bytes = Math.floor((url.length - start - 7) * 3 / 4);
+	if (bytes <= IMAGE_LARGE_PAYLOAD_BYTES) return baseTokens;
+	return Math.min(maxTokens, baseTokens + Math.floor((bytes - IMAGE_LARGE_PAYLOAD_BYTES) / 1e3));
+}
 function estimateTokensForContentPart(part) {
 	if (part.type === "text") return estimateTokens$1(part.text);
 	else if (part.type === "think") return estimateTokens$1(part.think);
+	else if (part.type === "image_url") return estimateDataUriTokens(part.imageUrl.url, IMAGE_BASE_TOKENS, IMAGE_MAX_TOKENS);
+	else if (part.type === "audio_url") return AUDIO_TOKENS;
+	else if (part.type === "video_url") return VIDEO_TOKENS;
 	return 0;
 }
 //#endregion
@@ -53403,6 +53448,17 @@ var MemoryMemoStore = class MemoryMemoStore {
 	async append(entry) {
 		return this.withWriteLock(() => this.appendInternal(entry));
 	}
+	/**
+	* True when a memo with the same source session + user need + approach
+	* already exists. Used by compaction-summary recovery to re-store memos
+	* idempotently after a crash between compaction apply and extraction.
+	* The approach field keeps two distinct memos that happen to share the
+	* same user need from being collapsed into one.
+	*/
+	existsBySourceAndNeed(sourceSessionId, userNeed, approach) {
+		if (this.db === void 0) return false;
+		return this.db.prepare("SELECT 1 FROM memos WHERE source_session_id = ? AND user_need = ? AND approach = ? LIMIT 1").get(sourceSessionId, userNeed, approach) !== void 0;
+	}
 	/** Delete a memo by id. */
 	async delete(id) {
 		return this.withWriteLock(() => this.deleteInternal(id));
@@ -78944,7 +79000,11 @@ var FullCompaction = class {
 			this.agent.context.applyCompaction(result);
 			this.lastCompactionFiles = fileLists;
 			this.lowWaterMark = Math.floor(this.effectiveTokenCount * 1.1);
-			await this.extractAndStoreMemos(processedSummary, messagesToCompactForOps);
+			try {
+				await this.extractAndStoreMemos(processedSummary, messagesToCompactForOps);
+			} catch (error) {
+				this.agent.log.warn("Memory memo extraction failed (compaction itself succeeded)", { error });
+			}
 			this.triggerPostCompactHook(data, result);
 			this.detectSkillCandidates(skillCandidateSummary);
 			this.consecutiveCompactionFailures = 0;
@@ -79164,6 +79224,31 @@ function extractPreviousSummary(history) {
 	const text = head.content.filter((p) => p.type === "text").map((p) => p.text).join("");
 	return text.length > 0 ? text : null;
 }
+/**
+* Crash-recovery path for compaction memos. `context.apply_compaction` is
+* written to wire before the extraction step runs; if the process dies in
+* that window the memos are lost forever (nothing re-extracts them). On wire
+* replay the summary is available again, so re-parse it and store anything
+* missing. Idempotent: a healthy replay finds the memos already stored
+* (existsBySourceAndNeed) and skips them, so recovery never duplicates.
+*/
+async function recoverMemosFromCompactionSummary(agent, summary) {
+	const memoStore = agent.memoStore;
+	if (!memoStore || summary === void 0 || summary.trim().length === 0) return;
+	const memos = parseMemoryMemos(summary);
+	if (memos.length === 0) return;
+	const sessionId = agent.homedir ? basename$1(dirname$2(dirname$2(agent.homedir))) : "unknown";
+	const sessionTitle = await agent.getSessionTitle().catch(() => void 0);
+	const projectDir = agent.config.cwd;
+	const failed = (await Promise.allSettled(memos.map(async (memo) => {
+		if (memoStore.existsBySourceAndNeed(sessionId, memo.userNeed, memo.approach)) return;
+		memo.sourceSessionId = sessionId;
+		memo.sourceSessionTitle = sessionTitle ?? "";
+		memo.projectDir = projectDir;
+		await memoStore.append(memo);
+	}))).filter((result) => result.status === "rejected").length;
+	if (failed > 0) agent.log.warn("Some recovered memory memos failed to store", { failed });
+}
 //#endregion
 //#region ../../packages/agent-core/src/flags/registry.ts
 /**
@@ -79382,7 +79467,7 @@ function findSupersededPaths(messages, cutoff) {
 /**
 * Lightweight compaction that truncates old tool results without an LLM call.
 *
-* When the context window is filling up (>= 50% by default), old tool result
+* When the context window is filling up (>= 30% by default), old tool result
 * messages are replaced with a short placeholder. This frees up tokens for the
 * model without the cost and latency of a full compaction.
 *
@@ -84844,6 +84929,7 @@ var FileSystemAgentRecordPersistence = class {
 	pendingRecords = [];
 	shouldClear = false;
 	directorySynced = false;
+	rewriteSeq = 0;
 	flushPromise;
 	error;
 	constructor(filePath, options = {}) {
@@ -84953,7 +85039,21 @@ var FileSystemAgentRecordPersistence = class {
 		const content = (this.options.blobStore !== void 0 ? await Promise.all(batch.map((record) => this.options.blobStore.offload(record))) : batch).map((e) => JSON.stringify(e) + "\n").join("");
 		const directory = dirname$2(this.filePath);
 		await mkdir(directory, { recursive: true });
-		const fh = await open(this.filePath, shouldClear ? "w" : "a");
+		if (shouldClear) {
+			const tmpPath = `${this.filePath}.${process.pid}.${this.rewriteSeq++}.tmp`;
+			const tmp = await open(tmpPath, "w");
+			try {
+				if (content.length > 0) await tmp.writeFile(content, "utf8");
+				await tmp.sync();
+			} finally {
+				await tmp.close();
+			}
+			await rename(tmpPath, this.filePath);
+			await syncDir(directory);
+			this.directorySynced = true;
+			return;
+		}
+		const fh = await open(this.filePath, "a");
 		try {
 			if (content.length > 0) await fh.writeFile(content, "utf8");
 			await fh.sync();
@@ -85310,6 +85410,7 @@ function restoreAgentRecord(agent, input) {
 			return;
 		case "context.apply_compaction":
 			agent.context.applyCompaction(input);
+			recoverMemosFromCompactionSummary(agent, input.summary);
 			return;
 		case "context.snapshot":
 			agent.context.restoreJSONSnapshot(input.snapshot);
@@ -85406,11 +85507,19 @@ var AgentRecords = class {
 			snapshotIndex = i;
 			break;
 		}
+		let foldedCompactionSummary;
 		for (let i = 0; i < replayedRecords.length; i++) {
 			const record = replayedRecords[i];
 			if (!record) continue;
-			if (i < snapshotIndex && isSnapshotFoldedContextRecord(record.type)) continue;
+			if (i < snapshotIndex && isSnapshotFoldedContextRecord(record.type)) {
+				if (record.type === "context.apply_compaction") foldedCompactionSummary = record.summary;
+				continue;
+			}
 			this.restore(record);
+			if (record.type === "context.snapshot" && foldedCompactionSummary !== void 0) {
+				recoverMemosFromCompactionSummary(this.agent, foldedCompactionSummary);
+				foldedCompactionSummary = void 0;
+			}
 		}
 		this.agent.context.dropVacuousOpenMessages();
 		if (shouldRewrite) {
@@ -105566,6 +105675,9 @@ var SessionSubagentHost = class {
 	backgroundTaskTimeoutMs;
 	modelBindings;
 	activeChildren = /* @__PURE__ */ new Map();
+	/** Per-child per-model usage already folded into the parent totals, so a
+	* resumed child's aggregation only adds the delta. */
+	aggregatedChildUsage = /* @__PURE__ */ new WeakMap();
 	constructor(session, ownerAgentId, backgroundTaskTimeoutMs, modelBindings) {
 		this.session = session;
 		this.ownerAgentId = ownerAgentId;
@@ -105709,6 +105821,21 @@ var SessionSubagentHost = class {
 				result = lastAssistantText$1(child);
 			}
 			const usage = child.usage.data().total;
+			const childByModel = child.usage.data().byModel ?? {};
+			const previous = this.aggregatedChildUsage.get(child) ?? {};
+			for (const [model, childUsage] of Object.entries(childByModel)) {
+				const delta = previous[model] === void 0 ? childUsage : subtractUsage(childUsage, previous[model]);
+				if (isZeroUsage(delta)) continue;
+				try {
+					parent.usage.record(model, delta, "session");
+				} catch (error) {
+					parent.log.warn("Failed to aggregate subagent usage", {
+						model,
+						error: String(error)
+					});
+				}
+			}
+			this.aggregatedChildUsage.set(child, childByModel);
 			let findingsBlock = "";
 			if (profileName === "reviewer") {
 				const findings = getFindingsFromStore(child.tools.toolStore);
@@ -105813,6 +105940,18 @@ var SessionSubagentHost = class {
 		});
 	}
 };
+/** Element-wise subtraction clamped at zero (usage can never go negative). */
+function subtractUsage(current, previous) {
+	return {
+		inputOther: Math.max(0, current.inputOther - previous.inputOther),
+		output: Math.max(0, current.output - previous.output),
+		inputCacheRead: Math.max(0, current.inputCacheRead - previous.inputCacheRead),
+		inputCacheCreation: Math.max(0, current.inputCacheCreation - previous.inputCacheCreation)
+	};
+}
+function isZeroUsage(usage) {
+	return usage.inputOther === 0 && usage.output === 0 && usage.inputCacheRead === 0 && usage.inputCacheCreation === 0;
+}
 async function runChildTurnToCompletion(child, signal) {
 	const completion = await child.turn.waitForCurrentTurn(signal);
 	const turnEnded = completion.event;
@@ -123049,28 +123188,24 @@ var ScreamCore = class {
 		return this.config;
 	}
 	async setScreamConfig(input) {
-		return this.enqueueConfigMutation(async () => {
-			const config = mergeConfigPatch(readConfigFile(this.configPath), input);
-			await writeConfigFile(this.configPath, config);
-			return this.config = loadRuntimeConfig(this.configPath);
-		});
+		const config = mergeConfigPatch(readConfigFile(this.configPath), input);
+		await writeConfigFile(this.configPath, config);
+		return this.config = loadRuntimeConfig(this.configPath);
 	}
 	async removeScreamProvider(input) {
-		return this.enqueueConfigMutation(async () => {
-			const config = readConfigFile(this.configPath);
-			delete config.providers[input.providerId];
-			let removedDefault = false;
-			const existingModels = config.models ?? {};
-			for (const [key, model] of Object.entries(existingModels)) if (typeof model === "object" && model !== null && !Array.isArray(model) && model["provider"] === input.providerId) {
-				delete existingModels[key];
-				if (config.defaultModel === key) removedDefault = true;
-			}
-			config.models = existingModels;
-			if (removedDefault) config.defaultModel = void 0;
-			if (config.defaultProvider === input.providerId) config.defaultProvider = void 0;
-			await writeConfigFile(this.configPath, config);
-			return this.config = loadRuntimeConfig(this.configPath);
-		});
+		const config = readConfigFile(this.configPath);
+		delete config.providers[input.providerId];
+		let removedDefault = false;
+		const existingModels = config.models ?? {};
+		for (const [key, model] of Object.entries(existingModels)) if (typeof model === "object" && model !== null && !Array.isArray(model) && model["provider"] === input.providerId) {
+			delete existingModels[key];
+			if (config.defaultModel === key) removedDefault = true;
+		}
+		config.models = existingModels;
+		if (removedDefault) config.defaultModel = void 0;
+		if (config.defaultProvider === input.providerId) config.defaultProvider = void 0;
+		await writeConfigFile(this.configPath, config);
+		return this.config = loadRuntimeConfig(this.configPath);
 	}
 	setRuntimeSystemPrompt({ sessionId, ...payload }) {
 		return this.sessionApi(sessionId).setRuntimeSystemPrompt(payload);
@@ -123612,23 +123747,6 @@ var ScreamCore = class {
 	reloadProviderManager() {
 		return this.config = loadRuntimeConfig(this.configPath);
 	}
-	/**
-	* Serialize config-file mutations. Both setScreamConfig and
-	* removeScreamProvider are read-modify-write cycles that read the file
-	* synchronously and then await the write; two calls issued together (e.g.
-	* cycling thinking levels plus confirming a model in the picker fire
-	* back-to-back setConfig patches) would otherwise read the SAME stale
-	* snapshot, and the later write silently reverts the earlier patch — a
-	* lost update that makes e.g. a just-selected default model flip back to
-	* the old one. The queue guarantees each cycle re-reads after the
-	* previous write completed.
-	*/
-	configMutationQueue = Promise.resolve();
-	enqueueConfigMutation(mutate) {
-		const run = this.configMutationQueue.then(mutate, mutate);
-		this.configMutationQueue = run.catch(() => void 0);
-		return run;
-	}
 	async refreshSessionRuntimeConfig(session, config) {
 		const api = new SessionAPIImpl(session);
 		const requested = (await api.getModel({ agentId: "main" })).trim();
@@ -125559,24 +125677,15 @@ const PIXEL_PULSE_FRAMES = [
 	"▒",
 	"▓"
 ];
-const PULSE_WAVE_FRAMES = [
-	{
-		active: 0,
-		forward: true
-	},
-	{
-		active: 1,
-		forward: true
-	},
-	{
-		active: 2,
-		forward: true
-	},
-	{
-		active: 1,
-		forward: false
-	}
-];
+const forwardFrames = Array.from({ length: 8 }, (_, active) => ({
+	active,
+	forward: true
+}));
+const backwardFrames = Array.from({ length: 6 }, (_, i) => ({
+	active: 6 - i,
+	forward: false
+}));
+const PULSE_WAVE_FRAMES = [...forwardFrames, ...backwardFrames];
 //#endregion
 //#region src/tui/commands/knowledge-store.ts
 let knowledgeStoreInstance;
@@ -129362,13 +129471,22 @@ var FooterComponent = class {
 		this.#stopStatusTimer();
 		if (phase === "idle" && !goalActive) return;
 		const intervalMs = 1e3 / 30;
-		this.statusTimer = setInterval(() => {
+		this.#scheduleStatusTick(intervalMs, intervalMs);
+	}
+	#scheduleStatusTick(intervalMs, delayMs) {
+		const timer = setTimeout(() => {
+			if (this.statusTimer !== timer) return;
+			const startedAt = performance.now();
 			this.ui.requestRender();
-		}, intervalMs);
+			const tickCostMs = performance.now() - startedAt;
+			if (this.statusTimer !== timer) return;
+			this.#scheduleStatusTick(intervalMs, Math.max(0, intervalMs - tickCostMs));
+		}, delayMs);
+		this.statusTimer = timer;
 	}
 	#stopStatusTimer() {
 		if (!this.statusTimer) return;
-		clearInterval(this.statusTimer);
+		clearTimeout(this.statusTimer);
 		this.statusTimer = null;
 	}
 	render(width) {
@@ -130817,10 +130935,11 @@ async function changeThinkingLevel(host, alias, level) {
 	}
 	const prevLevel = host.state.appState.thinkingLevel;
 	const isActiveModel = alias === host.state.appState.model;
-	const session = host.session;
 	if (isActiveModel && level !== prevLevel) {
+		const session = host.session;
 		try {
-			if (session !== void 0) await session.setThinking(level);
+			if (session === void 0) await host.authFlow.activateModelAfterLogin(alias, level);
+			else await session.setThinking(level);
 		} catch (error) {
 			const msg = formatErrorMessage(error);
 			host.showError(`Failed to set thinking: ${msg}`);
@@ -130836,7 +130955,7 @@ async function changeThinkingLevel(host, alias, level) {
 		host.showError(`Failed to save thinking default: ${msg}`);
 		return;
 	}
-	const status = isActiveModel && level !== prevLevel ? session === void 0 ? persisted ? `No active session - thinking ${level} for ${alias} saved as default.` : `No active session - thinking ${level} was NOT saved (${alias} is not the default model, so its level applies only when a new session selects it).` : `Thinking set to ${level} for ${alias}.` : persisted ? `Saved thinking ${level} as default for ${alias}.` : `Thinking already ${level} for ${alias}.`;
+	const status = isActiveModel && level !== prevLevel ? `Thinking set to ${level} for ${alias}.` : persisted ? `Saved thinking ${level} as default for ${alias}.` : `Thinking already ${level} for ${alias}.`;
 	host.showStatus(status, host.state.theme.colors.success);
 }
 async function persistThinkingDefault(host, alias, level) {
@@ -130865,16 +130984,18 @@ async function performModelSwitch(host, alias, thinkingLevel) {
 	const prevThinkingLevel = host.state.appState.thinkingLevel;
 	const modelChanged = alias !== prevModel;
 	const thinkingChanged = thinkingLevel !== prevThinkingLevel;
-	const session = host.session;
-	const overflow = session !== void 0 && alias !== prevModel ? contextOverflowForModel(host.state.appState, alias) : null;
+	const needsSessionActivation = modelChanged || thinkingChanged;
+	const overflow = alias !== prevModel ? contextOverflowForModel(host.state.appState, alias) : null;
 	if (overflow !== null) {
 		host.showNotice("Storm Breaker（风暴守护者）", `无法切换到模型「${alias}」：当前会话上下文 ${formatTokenCount$1(overflow.currentTokens)} 已超出该模型上限 ${formatTokenCount$1(overflow.maxContextTokens)}。建议先执行 /compact 压缩上下文，或选择上下文窗口更大的模型。`);
 		return;
 	}
+	const session = host.session;
 	let effectiveAlias = alias;
 	let effectiveThinking = thinkingLevel;
 	try {
-		if (session !== void 0) {
+		if (session === void 0 && needsSessionActivation) await host.authFlow.activateModelAfterLogin(alias, thinkingLevel);
+		else if (session !== void 0) {
 			if (modelChanged) await session.setModel(alias);
 			if (thinkingChanged) await session.setThinking(thinkingLevel);
 			const confirmed = await session.getStatus().catch(() => null);
@@ -130897,13 +131018,12 @@ async function performModelSwitch(host, alias, thinkingLevel) {
 		persisted = await persistModelSelection(host, alias, thinkingLevel);
 	} catch (error) {
 		const msg = formatErrorMessage(error);
-		host.showError(`${session === void 0 ? "Selected" : "Switched to"} ${effectiveAlias}, but failed to save default: ${msg}`);
+		host.showError(`Switched to ${effectiveAlias}, but failed to save default: ${msg}`);
 		return;
 	}
 	const hasHistory = host.state.appState.contextTokens > 0;
 	const cacheWarning = modelChanged && hasHistory ? " Note: switching models invalidates the existing prompt cache - use /new to avoid extra token costs." : "";
 	const status = (() => {
-		if (session === void 0 && (modelChanged || thinkingChanged)) return `No active session - ${effectiveAlias} (thinking ${effectiveThinking}) saved as default. It applies when you start a new session.`;
 		if (modelChanged) return `Switched to ${effectiveAlias} with thinking ${effectiveThinking}.${cacheWarning}`;
 		if (thinkingChanged) return `Thinking set to ${effectiveThinking} for ${effectiveAlias}.`;
 		if (persisted) return `Saved ${effectiveAlias} with thinking ${effectiveThinking} as default.`;
@@ -133042,7 +133162,8 @@ var ThinkingComponent = class {
 	expanded = false;
 	ui;
 	spinnerFrame = 0;
-	spinnerInterval;
+	spinnerTimer;
+	lastSpinnerTickAt = 0;
 	textComponent;
 	cachedWidth;
 	cachedLines;
@@ -133126,17 +133247,41 @@ var ThinkingComponent = class {
 		}
 		return truncated;
 	}
+	/**
+	* setTimeout self-rescheduling chain with drift-free frame advancement and
+	* paint-cost backpressure (same pattern as the pi-tui Loader): a slow tick
+	* defers the next one instead of stacking intervals, keeping the live
+	* thinking indicator ≤ ~10% CPU even under slow terminal writes.
+	*/
+	scheduleSpinnerTick(delayMs) {
+		if (this.ui === void 0) return;
+		const timer = setTimeout(() => {
+			if (this.spinnerTimer !== timer) return;
+			const startedAt = performance.now();
+			const elapsed = startedAt - this.lastSpinnerTickAt;
+			if (elapsed >= 80) {
+				const steps = Math.floor(elapsed / 80);
+				this.spinnerFrame = (this.spinnerFrame + steps) % BRAILLE_SPINNER_FRAMES.length;
+				this.lastSpinnerTickAt += steps * 80;
+				this.ui?.requestRender();
+			}
+			const frameCostMs = performance.now() - startedAt;
+			if (this.spinnerTimer !== timer) return;
+			const cadenceDelayMs = Math.max(0, 80 - frameCostMs);
+			const backpressureDelayMs = frameCostMs * 9;
+			this.scheduleSpinnerTick(Math.max(cadenceDelayMs, backpressureDelayMs));
+		}, delayMs);
+		this.spinnerTimer = timer;
+	}
 	startSpinner() {
-		if (this.ui === void 0 || this.spinnerInterval !== void 0) return;
-		this.spinnerInterval = setInterval(() => {
-			this.spinnerFrame = (this.spinnerFrame + 1) % BRAILLE_SPINNER_FRAMES.length;
-			this.ui?.requestRender();
-		}, 80);
+		if (this.ui === void 0 || this.spinnerTimer !== void 0) return;
+		this.lastSpinnerTickAt = performance.now();
+		this.scheduleSpinnerTick(80);
 	}
 	stopSpinner() {
-		if (this.spinnerInterval === void 0) return;
-		clearInterval(this.spinnerInterval);
-		this.spinnerInterval = void 0;
+		if (this.spinnerTimer === void 0) return;
+		clearTimeout(this.spinnerTimer);
+		this.spinnerTimer = void 0;
 	}
 };
 //#endregion
@@ -136028,7 +136173,11 @@ function findRevokeAnchorComponentIndex(children, count) {
 function removeRevokeContextComponents(children, startIndex) {
 	for (let i = children.length - 1; i >= startIndex; i--) {
 		const child = children[i];
-		if (child !== void 0 && isRevokeContextComponent(child)) children.splice(i, 1);
+		if (child !== void 0 && isRevokeContextComponent(child)) {
+			const disposable = child;
+			if (typeof disposable.dispose === "function") disposable.dispose();
+			children.splice(i, 1);
+		}
 	}
 }
 function isRevokeAnchorComponent(child) {
@@ -137890,6 +138039,8 @@ var MoonLoader = class extends Text {
 	ui;
 	colorFn;
 	label;
+	/** Wall-clock time of the last frame advance, for drift-free scheduling. */
+	lastTickAt = 0;
 	constructor(ui, colorFn, label = "") {
 		super("", 1, 0);
 		this.ui = ui;
@@ -137898,18 +138049,44 @@ var MoonLoader = class extends Text {
 		this.start();
 	}
 	start() {
+		this.lastTickAt = performance.now();
 		this.updateDisplay();
-		this.intervalId = setInterval(() => {
-			this.currentFrame = (this.currentFrame + 1) % BRAILLE_SPINNER_FRAMES.length;
-			this.updateDisplay();
-		}, 80);
+		this.scheduleTick(80, 80);
 	}
 	stop() {
 		if (this.intervalId) {
-			clearInterval(this.intervalId);
+			clearTimeout(this.intervalId);
 			this.intervalId = null;
 		}
 	}
+	dispose() {
+		this.stop();
+	}
+	/**
+	* setTimeout self-rescheduling chain with drift-free frame advancement and
+	* paint-cost backpressure (same pattern as the pi-tui Loader): a slow tick
+	* defers the next one by `max(0, interval - cost, cost × 9)` instead of
+	* stacking intervals, keeping the spinner ≤ ~10% CPU under slow writes.
+	*/
+	scheduleTick(intervalMs, delayMs) {
+		const timer = setTimeout(() => {
+			if (this.intervalId !== timer) return;
+			const startedAt = performance.now();
+			const elapsed = startedAt - this.lastTickAt;
+			if (elapsed >= intervalMs) {
+				const steps = Math.floor(elapsed / intervalMs);
+				this.currentFrame = (this.currentFrame + steps) % BRAILLE_SPINNER_FRAMES.length;
+				this.lastTickAt += steps * intervalMs;
+				this.updateDisplay();
+			}
+			const frameCostMs = performance.now() - startedAt;
+			if (this.intervalId !== timer) return;
+			const cadenceDelayMs = Math.max(0, intervalMs - frameCostMs);
+			const backpressureDelayMs = frameCostMs * 9;
+			this.scheduleTick(intervalMs, Math.max(cadenceDelayMs, backpressureDelayMs));
+		}, delayMs);
+		this.intervalId = timer;
+	}
 	setLabel(label) {
 		this.label = label;
 		this.updateDisplay();

package/dist/main.mjs

@@ -6,7 +6,7 @@ const __dirname = __cjsShimDirname(__filename);
 import "./suppress-sqlite-warning-C2VB0doZ.mjs";
 //#region src/main.ts
 try {
-	(await import("./app-C3aR5fdI.mjs")).main();
+	(await import("./app-Bqc3MVGh.mjs")).main();
 } catch (error) {
 	process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
 	process.exit(1);