@norman-else/dsh-claude 0.1.41 → 0.1.43

package/lib/index.mjs

@@ -1,6 +1,6 @@
-import { A as CLAUDE_REPOSITORY_STATUS_PATH, B as isClaudeAlertMode, C as CLAUDE_PROJECTION_PATH, D as CLAUDE_REPOSITORY_FEEDBACK_PATH, E as CLAUDE_REPOSITORY_ACTION_PATH, F as CLAUDE_USAGE_PATH, H as isClaudeRenderMode, I as DEFAULT_CLAUDE_PROSE_MODE, L as DEFAULT_CLAUDE_RENDER_MODE, M as CLAUDE_REWIND_PATH, N as CLAUDE_UPDATE_CHECK_PATH, O as CLAUDE_REPOSITORY_FILE_PATH, P as CLAUDE_UPDATE_PATH, S as CLAUDE_PLAN_FEEDBACK_PATH, T as CLAUDE_RENDER_MODES, V as isClaudeProseMode, _ as CLAUDE_CODE_PROVIDER_IDS, a as latestClaudeTasks, b as CLAUDE_GLOBAL_SETTINGS_PATH, c as normalizeTasksEvent, d as CLAUDE_ACTIVITY_EVENT, f as CLAUDE_ALERT_MODES, g as CLAUDE_CODE_PROVIDER, h as CLAUDE_CODE_PRESET_ID, i as latestClaudeSessionBinding, j as CLAUDE_REVIEW_COMMENT_PATH, k as CLAUDE_REPOSITORY_SETUP_PATH, l as redactText, m as CLAUDE_CLIENT_DIAGNOSTICS_PATH, n as currentClaudeActivityCursor, o as normalizeActivity, p as CLAUDE_ASK_PATH, r as latestClaudeContextUsage, s as normalizeContextUsage, t as boundText, u as safeDetail, v as CLAUDE_DOCTOR_PATH, w as CLAUDE_PROSE_MODES, x as CLAUDE_JIRA_PATH, y as CLAUDE_EDITOR_OPEN_PATH, z as TASK_TOOL_NAMES } from "./events-B-FPMzI7.mjs";
-import { a as projectClaudeCommands, i as CLAUDE_COMMANDS_SERVICE, r as dynamicPresenterDefinition, t as CLAUDE_PRESENTER_NAMES } from "./presenters-BV42EKkB.mjs";
-import { a as resolveClaudeExecutable, n as ensureManagedPreset, o as runClaudeDoctor, t as ManagedPresetConflictError } from "./preset-installer-yRGfkGjd.mjs";
+import { A as CLAUDE_REPOSITORY_FEEDBACK_PATH, B as DEFAULT_CLAUDE_RENDER_MODE, C as CLAUDE_PROJECTION_PATH, D as CLAUDE_PROSE_MODES, E as CLAUDE_PROMPT_REFINE_PATH, F as CLAUDE_REWIND_PATH, G as isClaudeRenderMode, H as TASK_TOOL_NAMES, I as CLAUDE_UPDATE_CHECK_PATH, L as CLAUDE_UPDATE_PATH, M as CLAUDE_REPOSITORY_SETUP_PATH, N as CLAUDE_REPOSITORY_STATUS_PATH, O as CLAUDE_RENDER_MODES, P as CLAUDE_REVIEW_COMMENT_PATH, R as CLAUDE_USAGE_PATH, S as CLAUDE_PLAN_FEEDBACK_PATH, T as CLAUDE_PROMPT_NAME_PATH, U as isClaudeAlertMode, W as isClaudeProseMode, _ as CLAUDE_CODE_PROVIDER_IDS, a as latestClaudeTasks, b as CLAUDE_GLOBAL_SETTINGS_PATH, c as normalizeTasksEvent, d as CLAUDE_ACTIVITY_EVENT, f as CLAUDE_ALERT_MODES, g as CLAUDE_CODE_PROVIDER, h as CLAUDE_CODE_PRESET_ID, i as latestClaudeSessionBinding, j as CLAUDE_REPOSITORY_FILE_PATH, k as CLAUDE_REPOSITORY_ACTION_PATH, l as redactText, m as CLAUDE_CLIENT_DIAGNOSTICS_PATH, n as currentClaudeActivityCursor, o as normalizeActivity, p as CLAUDE_ASK_PATH, r as latestClaudeContextUsage, s as normalizeContextUsage, t as boundText, u as safeDetail, v as CLAUDE_DOCTOR_PATH, w as CLAUDE_PROMPTS_PATH, x as CLAUDE_JIRA_PATH, y as CLAUDE_EDITOR_OPEN_PATH, z as DEFAULT_CLAUDE_PROSE_MODE } from "./events-oovRTmX7.mjs";
+import { a as projectClaudeCommands, i as CLAUDE_COMMANDS_SERVICE, r as dynamicPresenterDefinition, t as CLAUDE_PRESENTER_NAMES } from "./presenters-BVWj7u0a.mjs";
+import { a as resolveClaudeExecutable, n as ensureManagedPreset, o as runClaudeDoctor, t as ManagedPresetConflictError } from "./preset-installer-JUktnfwS.mjs";
 import z from "@deepseek-ai/schemastery";
 import { createHash, randomUUID } from "node:crypto";
 import { chmod, mkdir, opendir, readFile, readdir, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
@@ -1840,6 +1840,21 @@ async function withTimeout(operation, timeoutMs, label) {
 		if (timer !== void 0) clearTimeout(timer);
 	}
 }
+async function withAbort(operation, signal) {
+	if (signal === void 0) return operation;
+	if (signal.aborted) throw abortFailure();
+	let abortListener;
+	try {
+		return await Promise.race([operation, new Promise((_resolve, reject) => {
+			abortListener = () => {
+				reject(abortFailure());
+			};
+			signal.addEventListener("abort", abortListener, { once: true });
+		})]);
+	} finally {
+		if (abortListener !== void 0) signal.removeEventListener("abort", abortListener);
+	}
+}
 /** The uuid of one main-chain transcript entry, or undefined for anything a
 *  rewind must not fork at: stream partials, results, and sidechain traffic. */
 function chainEntryUuid(message) {
@@ -1895,6 +1910,15 @@ var ClaudeSupervisor = class {
 	#contextWindows = /* @__PURE__ */ new Map();
 	#disposed = false;
 	#admissionGate = Promise.resolve();
+	/** FIFO user turns live outside the gate while capacity-blocked, so
+	*  best-effort metadata can still enter the serialized path and fail. */
+	#turnAdmissions = [];
+	#metadataAdmissions = /* @__PURE__ */ new Set();
+	#admissionDrainScheduled = false;
+	/** Prevent a capacity change between a failed attempt and parking the head
+	*  from becoming a lost wake-up. */
+	#admissionRevision = 0;
+	#blockedAdmissionRevision;
 	constructor(dependencies) {
 		this.#runtime = dependencies.runtime;
 		this.#approval = dependencies.approval;
@@ -1968,28 +1992,140 @@ var ClaudeSupervisor = class {
 	runTurn(request) {
 		const interruption = this.#interruptions.get(request.agent.id);
 		if (interruption !== void 0) return interruption.then(() => this.runTurn(request));
-		const operation = this.#admissionGate.then(() => this.#runTurnAdmitted(request));
+		return new Promise((resolve, reject) => {
+			let complete;
+			const completion = new Promise((done) => {
+				complete = done;
+			});
+			const admission = {
+				request,
+				resolve,
+				reject,
+				delivered: false,
+				admitting: false,
+				waitedForCapacity: false,
+				cancellation: new AbortController(),
+				completion,
+				complete: () => {
+					complete?.();
+				}
+			};
+			if (request.signal !== void 0) {
+				const abortListener = () => {
+					if (!admission.admitting) this.#finishTurnAdmission(admission, { error: abortFailure() });
+					else if (admission.waitedForCapacity && !admission.delivered) {
+						admission.delivered = true;
+						admission.reject(abortFailure());
+					}
+					this.#admissionRevision += 1;
+					this.#blockedAdmissionRevision = void 0;
+					this.#scheduleTurnAdmissions();
+				};
+				admission.abortListener = abortListener;
+				request.signal.addEventListener("abort", abortListener, { once: true });
+			}
+			this.#turnAdmissions.push(admission);
+			this.#scheduleTurnAdmissions();
+		});
+	}
+	async #drainTurnAdmissions() {
+		while (this.#turnAdmissions.length > 0) {
+			const admission = this.#turnAdmissions[0];
+			if (signalAborted(admission.request.signal)) {
+				this.#finishTurnAdmission(admission, { error: abortFailure() });
+				continue;
+			}
+			const attemptedRevision = this.#admissionRevision;
+			admission.admitting = true;
+			try {
+				const output = await this.#runTurnAdmitted(admission.request, admission.waitedForCapacity, admission.cancellation.signal);
+				this.#finishTurnAdmission(admission, { output });
+			} catch (error) {
+				if (error instanceof ClaudeProcessLimitError && !signalAborted(admission.request.signal) && !admission.cancellation.signal.aborted && !this.#disposed) {
+					admission.admitting = false;
+					admission.waitedForCapacity = true;
+					if (attemptedRevision === this.#admissionRevision) {
+						this.#blockedAdmissionRevision = attemptedRevision;
+						return;
+					}
+					continue;
+				}
+				this.#finishTurnAdmission(admission, { error });
+			}
+		}
+	}
+	#finishTurnAdmission(admission, outcome) {
+		if (this.#turnAdmissions[0] === admission) this.#turnAdmissions.shift();
+		else {
+			const index = this.#turnAdmissions.indexOf(admission);
+			if (index >= 0) this.#turnAdmissions.splice(index, 1);
+		}
+		admission.admitting = false;
+		if (admission.request.signal !== void 0 && admission.abortListener !== void 0) admission.request.signal.removeEventListener("abort", admission.abortListener);
+		if (!admission.delivered) {
+			admission.delivered = true;
+			if ("error" in outcome) admission.reject(outcome.error);
+			else admission.resolve(outcome.output);
+		}
+		admission.complete();
+	}
+	#scheduleTurnAdmissions() {
+		if (this.#admissionDrainScheduled || this.#turnAdmissions.length === 0 || this.#blockedAdmissionRevision === this.#admissionRevision) return;
+		this.#admissionDrainScheduled = true;
+		const operation = this.#admissionGate.then(() => this.#drainTurnAdmissions());
 		this.#admissionGate = operation.then(() => void 0, () => void 0);
-		return operation;
+		const finished = () => {
+			this.#admissionDrainScheduled = false;
+			this.#scheduleTurnAdmissions();
+		};
+		operation.then(finished, finished);
 	}
-	async #runTurnAdmitted(request) {
+	async #runTurnAdmitted(request, abortDuringAdmission, cancellationSignal) {
 		if (this.#disposed) throw new Error("dsh-claude: supervisor is disposed");
+		if (cancellationSignal.aborted) throw abortFailure();
 		if (signalAborted(request.signal)) throw abortFailure();
 		const sessionId = request.agent.id;
 		let entry = this.#entries.get(sessionId);
+		let createdForRequest;
+		const throwIfUnavailable = async () => {
+			const failure = this.#disposed ? /* @__PURE__ */ new Error("dsh-claude: supervisor is disposed") : cancellationSignal.aborted || abortDuringAdmission && signalAborted(request.signal) ? abortFailure() : void 0;
+			if (failure === void 0) return;
+			if (createdForRequest !== void 0) {
+				if (this.#entries.get(sessionId) === createdForRequest) this.#entries.delete(sessionId);
+				await this.#disposeEntry(createdForRequest);
+				createdForRequest = void 0;
+			}
+			throw failure;
+		};
 		if (entry?.state === "disposed" || entry?.state === "disconnected" || entry?.state === "outcome-unknown") {
 			this.#entries.delete(sessionId);
 			await this.#disposeEntry(entry);
+			await throwIfUnavailable();
 			entry = void 0;
 		}
 		if (entry === void 0) {
 			await this.#makeRoom();
-			entry = await this.#createEntry(request.agent, request.model ?? this.#config.defaultModel, request.thinkingMode);
+			await throwIfUnavailable();
+			try {
+				entry = await this.#createEntry(request.agent, request.model ?? this.#config.defaultModel, request.thinkingMode, abortDuringAdmission ? request.signal : void 0, cancellationSignal);
+			} catch (error) {
+				await throwIfUnavailable();
+				throw error;
+			}
+			createdForRequest = entry;
+			await throwIfUnavailable();
 			this.#entries.set(sessionId, entry);
 		}
 		if (entry.ownerAgent !== request.agent) throw new Error(`dsh-claude: live agent identity changed for session ${sessionId}`);
 		if (entry.active !== void 0 || entry.state === "interrupting") throw new ClaudeTurnBusyError(sessionId);
-		await entry.sdkInitialization;
+		try {
+			const initialization = withAbort(entry.sdkInitialization, cancellationSignal);
+			await (abortDuringAdmission ? withAbort(initialization, request.signal) : initialization);
+		} catch (error) {
+			await throwIfUnavailable();
+			throw error;
+		}
+		await throwIfUnavailable();
 		if (entry.idleTimer !== void 0) {
 			clearTimeout(entry.idleTimer);
 			entry.idleTimer = void 0;
@@ -1998,13 +2134,31 @@ var ClaudeSupervisor = class {
 		if (request.thinkingMode !== entry.thinkingMode || model !== entry.model) {
 			this.#entries.delete(sessionId);
 			await this.#disposeEntry(entry);
-			entry = await this.#createEntry(request.agent, model, request.thinkingMode);
+			if (createdForRequest === entry) createdForRequest = void 0;
+			await throwIfUnavailable();
+			try {
+				entry = await this.#createEntry(request.agent, model, request.thinkingMode, abortDuringAdmission ? request.signal : void 0, cancellationSignal);
+			} catch (error) {
+				await throwIfUnavailable();
+				throw error;
+			}
+			createdForRequest = entry;
+			await throwIfUnavailable();
 			this.#entries.set(sessionId, entry);
-			await entry.sdkInitialization;
+			try {
+				const initialization = withAbort(entry.sdkInitialization, cancellationSignal);
+				await (abortDuringAdmission ? withAbort(initialization, request.signal) : initialization);
+			} catch (error) {
+				await throwIfUnavailable();
+				throw error;
+			}
 		} else await this.#syncPermissionMode(entry);
+		await throwIfUnavailable();
 		const promptUuid = randomUUID();
 		const cursor = currentClaudeActivityCursor(request.agent.session.events);
-		cursor.nextOrdinal = (await this.#sidecar.read(sessionId)).activities.reduce((next, activity) => activity.turn === cursor.turn && activity.step === cursor.step ? Math.max(next, activity.ordinal + 1) : next, 0);
+		const projection = await this.#sidecar.read(sessionId);
+		await throwIfUnavailable();
+		cursor.nextOrdinal = projection.activities.reduce((next, activity) => activity.turn === cursor.turn && activity.step === cursor.step ? Math.max(next, activity.ordinal + 1) : next, 0);
 		const active = {
 			agent: request.agent,
 			cursor,
@@ -2052,9 +2206,12 @@ var ClaudeSupervisor = class {
 				title: "Claude Code turn cancelled before submission"
 			});
 			entry.active = void 0;
-			entry.state = "idle";
-			entry.lastUsedAt = Date.now();
-			this.#armIdleTimer(entry);
+			if (!abortDuringAdmission || createdForRequest === void 0) {
+				entry.state = "idle";
+				entry.lastUsedAt = Date.now();
+				this.#armIdleTimer(entry);
+			}
+			await throwIfUnavailable();
 			return active.output;
 		}
 		if (request.signal !== void 0) {
@@ -2068,31 +2225,57 @@ var ClaudeSupervisor = class {
 		return active.output;
 	}
 	#runMetadata(agent, model, operation) {
+		if (this.#turnAdmissions.some((admission) => admission.waitedForCapacity)) return Promise.reject(new ClaudeProcessLimitError(this.#config.maxProcesses));
+		let complete;
+		const admission = {
+			sessionId: agent.id,
+			cancellation: new AbortController(),
+			started: false,
+			completion: new Promise((done) => {
+				complete = done;
+			}),
+			complete: () => {
+				complete?.();
+			}
+		};
+		this.#metadataAdmissions.add(admission);
 		const admitted = this.#admissionGate.then(async () => {
+			admission.started = true;
 			if (this.#disposed) throw new Error("dsh-claude: supervisor is disposed");
-			const entry = await this.#metadataEntry(agent, model);
+			if (admission.cancellation.signal.aborted) throw abortFailure();
+			if (this.#turnAdmissions.some((admission) => admission.waitedForCapacity)) throw new ClaudeProcessLimitError(this.#config.maxProcesses);
+			const entry = await this.#metadataEntry(agent, model, admission.cancellation.signal);
 			try {
-				await entry.sdkInitialization;
-				return await this.#control(entry, operation(entry.query, entry), "Claude metadata request");
+				await withAbort(entry.sdkInitialization, admission.cancellation.signal);
+				return await withAbort(this.#control(entry, operation(entry.query, entry), "Claude metadata request"), admission.cancellation.signal);
 			} finally {
 				entry.lastUsedAt = Date.now();
 				if (entry.active === void 0 && entry.state === "idle") this.#armIdleTimer(entry);
 			}
+		}).finally(() => {
+			this.#finishMetadataAdmission(admission);
 		});
 		this.#admissionGate = admitted.then(() => void 0, () => void 0);
-		return admitted;
+		return withAbort(admitted, admission.cancellation.signal);
 	}
-	async #metadataEntry(agent, model) {
+	async #metadataEntry(agent, model, cancellationSignal) {
+		if (cancellationSignal.aborted) throw abortFailure();
 		const sessionId = agent.id;
 		let entry = this.#entries.get(sessionId);
 		if (entry?.state === "disposed" || entry?.state === "disconnected" || entry?.state === "outcome-unknown") {
 			this.#entries.delete(sessionId);
 			await this.#disposeEntry(entry);
+			if (cancellationSignal.aborted) throw abortFailure();
 			entry = void 0;
 		}
 		if (entry === void 0) {
 			await this.#makeRoom();
-			entry = await this.#createEntry(agent, model);
+			if (cancellationSignal.aborted) throw abortFailure();
+			entry = await this.#createEntry(agent, model, void 0, void 0, cancellationSignal);
+			if (cancellationSignal.aborted) {
+				await this.#disposeEntry(entry);
+				throw abortFailure();
+			}
 			this.#entries.set(sessionId, entry);
 		}
 		if (entry.ownerAgent !== agent) throw new Error(`dsh-claude: live agent identity changed for session ${sessionId}`);
@@ -2101,14 +2284,15 @@ var ClaudeSupervisor = class {
 			clearTimeout(entry.idleTimer);
 			entry.idleTimer = void 0;
 		}
-		await this.#syncPermissionMode(entry);
+		await withAbort(this.#syncPermissionMode(entry), cancellationSignal);
+		if (cancellationSignal.aborted) throw abortFailure();
 		return entry;
 	}
 	/** Run one SDK control request against a live entry, and discard the entry if
 	*  it does not answer.
 	*
-	*  Turn admission and every metadata read share one process-wide gate, so an
-	*  unbounded control request stalls every session until the Host restarts.
+	*  Turn admission attempts and metadata reads share one process-wide gate,
+	*  so an unbounded control request stalls every session until the Host restarts.
 	*  Bounding it is only half the cure: a timeout also proves this query has
 	*  stopped answering, and keeping the entry means the next caller reuses the
 	*  same dead process — timing out again, forever. Discarding it lets the next
@@ -2129,32 +2313,97 @@ var ClaudeSupervisor = class {
 		await this.#control(entry, entry.query.setPermissionMode(mode), "Claude Code permission mode switch");
 		entry.permissionMode = mode;
 	}
+	#finishMetadataAdmission(admission) {
+		this.#metadataAdmissions.delete(admission);
+		admission.complete();
+	}
+	#cancelMetadataAdmissions(predicate) {
+		const cancelled = [...this.#metadataAdmissions].filter(predicate);
+		for (const admission of cancelled) {
+			admission.cancellation.abort();
+			if (!admission.started) this.#finishMetadataAdmission(admission);
+		}
+		return cancelled.map((admission) => admission.completion);
+	}
+	#cancelTurnAdmissions(predicate, error) {
+		const cancelled = this.#turnAdmissions.filter(predicate);
+		for (const admission of cancelled) {
+			admission.cancellation.abort();
+			if (!admission.delivered) {
+				admission.delivered = true;
+				admission.reject(error);
+			}
+			if (!admission.admitting) this.#finishTurnAdmission(admission, { error });
+		}
+		if (cancelled.length > 0) {
+			this.#admissionRevision += 1;
+			this.#blockedAdmissionRevision = void 0;
+			this.#scheduleTurnAdmissions();
+		}
+		return cancelled.map((admission) => admission.completion);
+	}
+	limitsChanged() {
+		if (this.#disposed) return;
+		this.#notifyCapacityChange();
+		this.#scheduleLimitReconciliation();
+	}
 	async disposeSession(sessionId) {
+		const pendingAdmissions = this.#cancelTurnAdmissions((admission) => admission.request.agent.id === sessionId, abortFailure());
+		const pendingMetadata = this.#cancelMetadataAdmissions((admission) => admission.sessionId === sessionId);
 		const entry = this.#entries.get(sessionId);
-		if (entry === void 0) return;
-		this.#entries.delete(sessionId);
-		await this.#disposeEntry(entry);
+		if (entry !== void 0) this.#entries.delete(sessionId);
+		await Promise.allSettled([
+			...pendingAdmissions,
+			...pendingMetadata,
+			...entry === void 0 ? [] : [this.#disposeEntry(entry)]
+		]);
 	}
 	async dispose() {
 		if (this.#disposed) return;
 		this.#disposed = true;
+		const pendingAdmissions = this.#cancelTurnAdmissions(() => true, /* @__PURE__ */ new Error("dsh-claude: supervisor is disposed"));
+		const pendingMetadata = this.#cancelMetadataAdmissions(() => true);
 		const entries = [...this.#entries.values()];
 		this.#entries.clear();
-		await Promise.allSettled(entries.map((entry) => this.#disposeEntry(entry)));
+		this.#notifyCapacityChange();
+		await Promise.allSettled([
+			...pendingAdmissions,
+			...pendingMetadata,
+			...entries.map((entry) => this.#disposeEntry(entry))
+		]);
 	}
 	async #makeRoom() {
-		if (this.#entries.size < this.#config.maxProcesses) return;
-		const idle = [...this.#entries.values()].filter((entry) => entry.active === void 0 && entry.state === "idle").sort((left, right) => left.lastUsedAt - right.lastUsedAt)[0];
-		if (idle === void 0) throw new ClaudeProcessLimitError(this.#config.maxProcesses);
-		this.#entries.delete(idle.sessionId);
-		await this.#disposeEntry(idle);
+		while (this.#entries.size >= this.#config.maxProcesses) {
+			const idle = [...this.#entries.values()].filter((entry) => entry.active === void 0 && entry.state === "idle").sort((left, right) => left.lastUsedAt - right.lastUsedAt)[0];
+			if (idle === void 0) throw new ClaudeProcessLimitError(this.#config.maxProcesses);
+			this.#entries.delete(idle.sessionId);
+			await this.#disposeEntry(idle);
+		}
+	}
+	async #trimExcessIdle() {
+		while (this.#entries.size > this.#config.maxProcesses) {
+			const idle = [...this.#entries.values()].filter((entry) => entry.active === void 0 && entry.state === "idle").sort((left, right) => left.lastUsedAt - right.lastUsedAt)[0];
+			if (idle === void 0) return;
+			this.#entries.delete(idle.sessionId);
+			await this.#disposeEntry(idle);
+		}
+	}
+	#notifyCapacityChange() {
+		this.#admissionRevision += 1;
+		this.#blockedAdmissionRevision = void 0;
+		this.#scheduleTurnAdmissions();
+	}
+	#scheduleLimitReconciliation() {
+		const operation = this.#admissionGate.then(() => this.#trimExcessIdle());
+		this.#admissionGate = operation.then(() => void 0, () => void 0);
 	}
-	async #createEntry(agent, model, thinkingMode) {
+	async #createEntry(agent, model, thinkingMode, signal, cancellationSignal) {
 		const sessionId = agent.id;
 		const cwd = agent.session.header.cwd ?? process.cwd();
 		const input = new AsyncQueue();
 		const lifetime = new AbortController();
 		const projection = await this.#sidecar.importLegacy(sessionId, agent.session.events);
+		if (signalAborted(signal) || signalAborted(cancellationSignal)) throw abortFailure();
 		const binding = projection.binding;
 		const pendingRewind = projection.rewind?.pending;
 		const forkAt = pendingRewind !== void 0 && "resumeAt" in pendingRewind ? pendingRewind.resumeAt : void 0;
@@ -2627,20 +2876,7 @@ var ClaudeSupervisor = class {
 			...result.usage.outputTokens === void 0 ? {} : { outputTokens: result.usage.outputTokens }
 		};
 	}
-	async #completeProgressSegment(active, result, recordUsage = true) {
-		if (recordUsage && (result.usage.inputTokens !== void 0 || result.usage.outputTokens !== void 0 || result.usage.cumulativeCostUsd !== void 0)) {
-			await this.#appendSafely(active, {
-				kind: "usage",
-				phase: "completed",
-				title: "Claude usage",
-				summary: usageSummary(result.usage),
-				usage: this.#timedUsage(active, result.usage)
-			});
-			active.output.push({
-				type: "usage",
-				usage: this.#reportedUsage(active, result)
-			});
-		}
+	async #completeProgressSegment(active, result) {
 		if (!active.sawTextDelta && active.text.length === 0 && result.text !== void 0) {
 			active.text = result.text;
 			active.transcriptText = result.text;
@@ -2660,6 +2896,25 @@ var ClaudeSupervisor = class {
 		this.#closeTranscriptTextSegment(active);
 		active.thinking = "";
 	}
+	/** The turn's accounting, recorded once the turn is actually over.
+	*
+	*  A turn that hands off to background tasks passes through the same result
+	*  handling on its way to `waiting-tasks`, and recording there drew a closing
+	*  total under a turn that was still running. */
+	async #recordTurnUsage(active, result) {
+		if (result.usage.inputTokens === void 0 && result.usage.outputTokens === void 0 && result.usage.cumulativeCostUsd === void 0) return;
+		await this.#appendSafely(active, {
+			kind: "usage",
+			phase: "completed",
+			title: "Claude usage",
+			summary: usageSummary(result.usage),
+			usage: this.#timedUsage(active, result.usage)
+		});
+		active.output.push({
+			type: "usage",
+			usage: this.#reportedUsage(active, result)
+		});
+	}
 	async #completeTurn(entry, active, result) {
 		if (entry.active !== active) return;
 		if (active.aborted) {
@@ -2677,21 +2932,10 @@ var ClaudeSupervisor = class {
 			await this.#recordChainAnchor(entry, active);
 			this.#checkpointProjection(entry);
 			this.#armIdleTimer(entry);
+			this.#notifyCapacityChange();
+			this.#scheduleLimitReconciliation();
 			return;
 		}
-		if (result.usage.inputTokens !== void 0 || result.usage.outputTokens !== void 0 || result.usage.cumulativeCostUsd !== void 0) {
-			await this.#appendSafely(active, {
-				kind: "usage",
-				phase: "completed",
-				title: "Claude usage",
-				summary: usageSummary(result.usage),
-				usage: this.#timedUsage(active, result.usage)
-			});
-			active.output.push({
-				type: "usage",
-				usage: this.#reportedUsage(active, result)
-			});
-		}
 		const unmatchedDenials = (result.permissionDenials ?? []).filter((denial) => !active.deniedToolUseIds.has(denial.toolUseId));
 		if (unmatchedDenials.length > 0) await this.#appendSafely(active, {
 			kind: "permission",
@@ -2700,6 +2944,7 @@ var ClaudeSupervisor = class {
 			summary: unmatchedDenials.map((denial) => denial.toolName).join(", ")
 		});
 		if (!result.success) {
+			await this.#recordTurnUsage(active, result);
 			if (!active.sawTextDelta && active.text.length === 0 && result.text !== void 0) {
 				active.text = result.text;
 				active.transcriptText = result.text;
@@ -2738,9 +2983,10 @@ var ClaudeSupervisor = class {
 					phase: "updated",
 					title: "Claude Code is waiting for background tasks"
 				});
-				await this.#completeProgressSegment(active, result, false);
+				await this.#completeProgressSegment(active, result);
 				return;
 			}
+			await this.#recordTurnUsage(active, result);
 			await this.#appendSafely(active, {
 				kind: "status",
 				phase: "completed",
@@ -2758,9 +3004,11 @@ var ClaudeSupervisor = class {
 		entry.state = "idle";
 		entry.lastUsedAt = Date.now();
 		await this.#recordChainAnchor(entry, active);
-		await this.#learnContextWindow(entry);
 		this.#checkpointProjection(entry);
 		this.#armIdleTimer(entry);
+		this.#notifyCapacityChange();
+		this.#scheduleLimitReconciliation();
+		await this.#learnContextWindow(entry);
 	}
 	/** Tell every reader where this session's delta stream ended.
 	*
@@ -2942,6 +3190,7 @@ var ClaudeSupervisor = class {
 		if (entry.process !== void 0) try {
 			await entry.process.handle.waitForExit(AbortSignal.timeout(5e3));
 		} catch {}
+		this.#notifyCapacityChange();
 	}
 };
 //#endregion
@@ -3995,7 +4244,11 @@ function registerClaudeProjectionRoute(ctx, sidecar, ownsSession, commandsForSes
 			}
 		}));
 		for (const sessionId of sessionIds) writeSnapshot(sessionId).catch(() => void 0);
+		let sweeping = false;
 		const timer = setInterval(() => {
+			writeLine({ type: "ping" });
+			if (sweeping) return;
+			sweeping = true;
 			(async () => {
 				for (const sessionId of sessionIds) {
 					if (closed) return;
@@ -4004,8 +4257,9 @@ function registerClaudeProjectionRoute(ctx, sidecar, ownsSession, commandsForSes
 					if (JSON.stringify(next) === JSON.stringify(metas.get(sessionId))) continue;
 					writeMeta(sessionId, next);
 				}
-				writeLine({ type: "ping" });
-			})().catch(() => void 0);
+			})().catch(() => void 0).finally(() => {
+				sweeping = false;
+			});
 		}, META_REFRESH_MS);
 		timer.unref?.();
 		await new Promise((resolve) => {
@@ -4069,6 +4323,7 @@ const GIT_TIMEOUT_MS$3 = 5e3;
 const GH_TIMEOUT_MS$1 = 8e3;
 const CACHE_TTL_MS = 5e3;
 const MAX_TEXT_CHARS = 1024;
+const MAX_CONFLICT_PATHS = 100;
 function bounded(value) {
 	return value.trim().slice(0, MAX_TEXT_CHARS);
 }
@@ -4106,6 +4361,7 @@ function parseGitStatus(output) {
 	let upstream = false;
 	let ahead;
 	let behind;
+	const conflicts = [];
 	for (const line of output.split(/\r?\n/u)) {
 		if (line.startsWith("# branch.head ")) {
 			const head = bounded(line.slice(14));
@@ -4125,6 +4381,10 @@ function parseGitStatus(output) {
 			}
 			continue;
 		}
+		if (line.startsWith("u ")) {
+			const path = line.split(" ").slice(10).join(" ");
+			if (path.length > 0 && conflicts.length < MAX_CONFLICT_PATHS) conflicts.push(bounded(path));
+		}
 		if (line.length > 0 && !line.startsWith("# ")) dirty = true;
 	}
 	return {
@@ -4133,9 +4393,36 @@ function parseGitStatus(output) {
 		dirty,
 		upstream,
 		...ahead === void 0 ? {} : { ahead },
-		...behind === void 0 ? {} : { behind }
+		...behind === void 0 ? {} : { behind },
+		...conflicts.length === 0 ? {} : { conflicts }
 	};
 }
+/** Ordered so the rebase directories win: a conflicted rebase also writes
+*  MERGE_HEAD-like state, and the two are resumed by different commands. */
+const OPERATION_MARKERS = [
+	["rebase-merge", "rebase"],
+	["rebase-apply", "rebase"],
+	["MERGE_HEAD", "merge"],
+	["CHERRY_PICK_HEAD", "cherry-pick"],
+	["REVERT_HEAD", "revert"]
+];
+/** Reads the in-progress operation out of the worktree's own git dir -- linked
+*  worktrees keep their own, so this must not be handed the common dir. */
+async function detectRepositoryOperation(gitDir) {
+	for (const [marker, operation] of OPERATION_MARKERS) {
+		const path = join(gitDir, marker);
+		try {
+			await stat(path);
+		} catch {
+			continue;
+		}
+		const branch = bounded(operation === "rebase" ? await readFile(join(path, "head-name"), "utf8").catch(() => "") : "").replace(/^refs\/heads\//u, "");
+		return {
+			operation,
+			...branch.length === 0 || branch.includes(" ") ? {} : { branch }
+		};
+	}
+}
 function parseDiffNumstat(value) {
 	let additions = 0;
 	let deletions = 0;
@@ -4342,13 +4629,15 @@ var RepositoryStatusService = class {
 				cwd: safeCwd
 			};
 			const status = parseGitStatus(statusResult.stdout);
+			const operation = await detectRepositoryOperation(gitDir);
+			const branch = operation?.branch ?? status.branch;
 			const remoteResult = await run(this.#runtime, git, [
 				"remote",
 				"get-url",
 				"origin"
 			], cwd, GIT_TIMEOUT_MS$3);
 			const remote = remoteResult.exitCode === 0 ? parseGitHubRemote(remoteResult.stdout) : void 0;
-			const pullRequest = status.branch === void 0 || remote === void 0 ? void 0 : await this.#pullRequest(cwd, remote, status.branch);
+			const pullRequest = branch === void 0 || remote === void 0 ? void 0 : await this.#pullRequest(cwd, remote, branch);
 			const diffBase = pullRequest?.baseBranch === void 0 ? "HEAD" : await this.#mergeBase(cwd, git, pullRequest.baseBranch) ?? "HEAD";
 			const diff = status.dirty || diffBase !== "HEAD" ? await this.#diff(cwd, git, diffBase, signal) : {
 				additions: 0,
@@ -4362,6 +4651,8 @@ var RepositoryStatusService = class {
 				cwd: safeCwd,
 				root,
 				...status,
+				...branch === void 0 ? {} : { branch },
+				...operation === void 0 ? {} : { operation: operation.operation },
 				worktree: normalizedPath(gitDir) !== normalizedPath(commonDir),
 				...remote === void 0 ? {} : { remote },
 				...pullRequest === void 0 ? {} : { pullRequest },
@@ -5237,6 +5528,10 @@ function parseRepositoryActionStatus(output) {
 	}
 	return [...files.values()].sort((left, right) => left.path.localeCompare(right.path));
 }
+function conflictPaths(result) {
+	if (result.exitCode !== 0 || result.lossy) return [];
+	return result.stdout.split(/\r?\n/u).filter((line) => line.length > 0).slice(0, 100);
+}
 function fallbackCommitMessage(files) {
 	if (files.length === 1) return `Update ${files[0]?.path ?? "repository files"}`;
 	return `Update ${files.length} repository files`;
@@ -5301,6 +5596,7 @@ var RepositoryActionService = class {
 		return operation;
 	}
 	async #execute(cwd, request) {
+		if (request.action === "resolve-continue" || request.action === "resolve-abort") return this.#resolve(cwd, request.action, request.push === true);
 		const before = await this.#preview(cwd);
 		if (before.fingerprint !== request.fingerprint) throw new RepositoryActionError("repository-changed", "Repository changes have changed. Refresh the commit panel.");
 		if (request.action === "push") {
@@ -5363,13 +5659,12 @@ var RepositoryActionService = class {
 				`origin/${base}`
 			], before.root, REMOTE_TIMEOUT_MS);
 			if (merged.exitCode !== 0 || merged.lossy) {
-				const conflicted = await this.#run(git, [
+				const conflicts = conflictPaths(await this.#run(git, [
 					"diff",
 					"--name-only",
 					"--diff-filter=U",
 					"--"
-				], before.root, GIT_TIMEOUT_MS$1);
-				const conflicts = conflicted.exitCode === 0 && !conflicted.lossy ? conflicted.stdout.split(/\r?\n/u).filter((line) => line.length > 0).slice(0, 100) : [];
+				], before.root, GIT_TIMEOUT_MS$1));
 				if (conflicts.length === 0) {
 					await this.#run(git, [method, "--abort"], before.root, GIT_TIMEOUT_MS$1).catch(() => void 0);
 					throw new RepositoryActionError("merge-failed", `Git could not ${method} the base branch.`);
@@ -5468,6 +5763,87 @@ var RepositoryActionService = class {
 			pullRequestUrl: url
 		};
 	}
+	/** Finishes or discards the merge, rebase, cherry-pick or revert git is
+	*  waiting on. The operation is read from the git dir rather than taken from
+	*  the caller: `--continue` and `--abort` are only safe against the one that
+	*  is actually in progress. */
+	async #resolve(cwd, action, push) {
+		const git = await this.#git();
+		const [rootValue, gitDirValue] = (await this.#mustRun(git, [
+			"rev-parse",
+			"--path-format=absolute",
+			"--show-toplevel",
+			"--absolute-git-dir"
+		], cwd, GIT_TIMEOUT_MS$1, "not-repository", "The session directory is not a Git repository.")).stdout.split(/\r?\n/u);
+		const root = (rootValue ?? "").trim();
+		const gitDir = (gitDirValue ?? "").trim();
+		if (root.length === 0 || gitDir.length === 0) throw new RepositoryActionError("repository-unavailable", "Repository state is unavailable.");
+		const state = await detectRepositoryOperation(gitDir);
+		if (state === void 0) throw new RepositoryActionError("no-operation", "No merge, rebase, cherry-pick or revert is in progress.");
+		const operation = state.operation;
+		if (action === "resolve-abort") {
+			await this.#mustRun(git, [operation, "--abort"], root, GIT_TIMEOUT_MS$1, "abort-failed", `Git could not abort the ${operation}.`);
+			this.#invalidate(root);
+			return {
+				commit: await this.#head(git, root),
+				pushed: false
+			};
+		}
+		if (conflictPaths(await this.#run(git, [
+			"diff",
+			"--name-only",
+			"--diff-filter=U",
+			"--"
+		], root, GIT_TIMEOUT_MS$1)).length > 0) throw new RepositoryActionError("unresolved-conflicts", "Resolve and stage every conflicted file before continuing.");
+		const continued = await this.#run(git, [
+			"-c",
+			"core.editor=true",
+			operation,
+			"--continue"
+		], root, REMOTE_TIMEOUT_MS);
+		this.#invalidate(root);
+		if (continued.exitCode !== 0 || continued.lossy) {
+			const next = conflictPaths(await this.#run(git, [
+				"diff",
+				"--name-only",
+				"--diff-filter=U",
+				"--"
+			], root, GIT_TIMEOUT_MS$1));
+			if (next.length > 0) return {
+				commit: await this.#head(git, root),
+				pushed: false,
+				conflicts: next
+			};
+			const reason = continued.stderr.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0).at(-1);
+			throw new RepositoryActionError("continue-failed", reason === void 0 || reason.length === 0 ? `Git could not continue the ${operation}.` : reason);
+		}
+		const head = await this.#head(git, root);
+		if (!push) return {
+			commit: head,
+			pushed: false
+		};
+		const branch = await this.#run(git, [
+			"symbolic-ref",
+			"--quiet",
+			"--short",
+			"HEAD"
+		], root, GIT_TIMEOUT_MS$1);
+		if (branch.exitCode !== 0 || branch.lossy) throw new RepositoryActionError("detached-head", "The finished operation left a detached HEAD, so nothing was pushed.", head);
+		try {
+			await this.#push(git, root, branch.stdout.trim(), operation === "rebase");
+		} catch (error) {
+			throw new RepositoryActionError("push-failed", error instanceof Error ? error.message : "Git push failed.", head);
+		}
+		this.#invalidate(root);
+		return {
+			commit: head,
+			pushed: true
+		};
+	}
+	async #head(git, root) {
+		const head = await this.#run(git, ["rev-parse", "HEAD"], root, GIT_TIMEOUT_MS$1);
+		return head.exitCode === 0 && !head.lossy ? head.stdout.trim() : "";
+	}
 	async #preview(cwd) {
 		const git = await this.#git();
 		const root = (await this.#mustRun(git, [
@@ -5753,7 +6129,17 @@ const ACTIONS = /* @__PURE__ */ new Set([
 	"push",
 	"create-pr",
 	"merge-pr",
-	"update-branch"
+	"update-branch",
+	"resolve-continue",
+	"resolve-abort"
+]);
+/** Actions that commit nothing of their own, so the panel sends no message. */
+const MESSAGELESS = /* @__PURE__ */ new Set([
+	"push",
+	"merge-pr",
+	"update-branch",
+	"resolve-continue",
+	"resolve-abort"
 ]);
 function record$9(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
@@ -5792,7 +6178,7 @@ function actionRequest(input) {
 	return {
 		action,
 		fingerprint: string$1(input, "fingerprint"),
-		message: action === "push" || action === "merge-pr" || action === "update-branch" ? optionalString(input, "message") ?? "" : string$1(input, "message"),
+		message: MESSAGELESS.has(action) ? optionalString(input, "message") ?? "" : string$1(input, "message"),
 		includeUnstaged: input.includeUnstaged,
 		...optionalString(input, "prTitle") === void 0 ? {} : { prTitle: optionalString(input, "prTitle") },
 		...optionalString(input, "prBody") === void 0 ? {} : { prBody: optionalString(input, "prBody") },
@@ -5800,6 +6186,9 @@ function actionRequest(input) {
 		...input.draft === void 0 ? {} : typeof input.draft === "boolean" ? { draft: input.draft } : (() => {
 			throw new RepositoryActionError("invalid-request", "The draft field must be a boolean.");
 		})(),
+		...input.push === void 0 ? {} : typeof input.push === "boolean" ? { push: input.push } : (() => {
+			throw new RepositoryActionError("invalid-request", "The push field must be a boolean.");
+		})(),
 		...input.mergeMethod === void 0 ? {} : input.mergeMethod === "merge" || input.mergeMethod === "squash" || input.mergeMethod === "rebase" ? { mergeMethod: input.mergeMethod } : (() => {
 			throw new RepositoryActionError("invalid-request", "The mergeMethod field is invalid.");
 		})()
@@ -6062,6 +6451,358 @@ function registerEditorOpenRoute(ctx, service, cwdForSession) {
 	});
 }
 //#endregion
+//#region src/prompts.ts
+const MAX_PROMPT_FILES = 256;
+const MAX_PROMPT_BYTES = 16384;
+const MAX_DESCRIPTION_CHARS = 120;
+const MAX_REQUEST_BYTES$1 = 32768;
+/**
+* The same shape as the output-style name in `global-settings.ts`, plus
+* `\p{M}` so a macOS-decomposed name survives. Two properties matter and both
+* are load-bearing: no member of the class is a path separator, and the first
+* character can be neither a dot nor a separator — so `join(dir, name + '.md')`
+* cannot address anything outside `dir`. Nothing else validates the path.
+*/
+const PROMPT_NAME = /^[\p{L}\p{N}][\p{L}\p{M}\p{N} ._()\[\]-]{0,127}$/u;
+/** Prompt snippets live beside the rest of the user's Claude Code state. */
+function claudePromptsDir() {
+	return join(homedir(), ".claude", "prompts");
+}
+/** `~/.claude/prompts/x.md` rather than the absolute path it expands to. */
+function displayPath(file) {
+	const home = homedir();
+	return file.startsWith(`${home}/`) ? `~${file.slice(home.length)}` : file;
+}
+/** The menu's second row: the first non-empty line, collapsed and bounded. */
+function summarize(body) {
+	const line = body.split("\n").map((text) => text.trim()).find((text) => text.length > 0) ?? "";
+	return redactText(line.replace(/\s+/gu, " "), MAX_DESCRIPTION_CHARS);
+}
+/**
+* Every `.md` file in the prompts directory, sorted by name.
+*
+* A missing directory is the ordinary state before the user saves anything,
+* and one unreadable file must not empty the whole menu — both answer with
+* what is there rather than throwing.
+*/
+async function readClaudePrompts(directory) {
+	const prompts = [];
+	let entries;
+	try {
+		entries = await opendir(directory);
+	} catch (error) {
+		if (error.code === "ENOENT") return prompts;
+		throw error;
+	}
+	for await (const entry of entries) {
+		if (prompts.length >= MAX_PROMPT_FILES) break;
+		if (!entry.isFile() || extname(entry.name).toLowerCase() !== ".md") continue;
+		const name = entry.name.slice(0, -3);
+		if (!PROMPT_NAME.test(name)) continue;
+		try {
+			const file = join(directory, entry.name);
+			const body = await readFile(file, "utf8");
+			if (body.trim().length === 0 || Buffer.byteLength(body) > MAX_PROMPT_BYTES) continue;
+			prompts.push({
+				name,
+				description: summarize(body),
+				body,
+				location: displayPath(file)
+			});
+		} catch {}
+	}
+	return prompts.sort((left, right) => left.name.localeCompare(right.name));
+}
+var ClaudePromptWriteError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "ClaudePromptWriteError";
+		this.code = code;
+	}
+};
+/**
+* Save one prompt, refusing to clobber an existing file.
+*
+* `wx` is the whole collision policy: a name the user already uses is theirs
+* to resolve, and overwriting a prompt they keep is not something they can
+* undo from inside DSH.
+*/
+async function writeClaudePrompt(directory, name, body) {
+	if (typeof name !== "string" || !PROMPT_NAME.test(name)) throw new ClaudePromptWriteError("invalid-name", "The prompt name is invalid.");
+	if (typeof body !== "string" || body.trim().length === 0 || Buffer.byteLength(body) > MAX_PROMPT_BYTES) throw new ClaudePromptWriteError("invalid-body", "The prompt text is empty or too large.");
+	const text = body.endsWith("\n") ? body : `${body}\n`;
+	const file = join(directory, `${name}.md`);
+	await mkdir(directory, {
+		recursive: true,
+		mode: 448
+	});
+	try {
+		await writeFile(file, text, {
+			encoding: "utf8",
+			mode: 384,
+			flag: "wx"
+		});
+	} catch (error) {
+		if (error.code === "EEXIST") throw new ClaudePromptWriteError("name-taken", "A prompt with that name already exists.");
+		throw error;
+	}
+	return {
+		name,
+		description: summarize(text),
+		body: text,
+		location: displayPath(file)
+	};
+}
+const MAX_NAME_DRAFT_CHARS = 4e3;
+const MAX_NAME_OUTPUT_BYTES = 4096;
+const MAX_SUGGESTED_NAME_CHARS = 48;
+const MAX_REFINE_DRAFT_CHARS = 16e3;
+const MAX_REFINED_BYTES = 32768;
+const ASSIST_TIMEOUT_MS = 4e4;
+/**
+* Ask for a file name and nothing else, with the draft fenced as data.
+*
+* Two things here were measured rather than guessed. The instruction travels
+* in the user turn, not in `--system-prompt`: a saved prompt is itself an
+* instruction and a system prompt does not outrank it, so the model reads the
+* draft as its task and answers it instead of naming it. And the default
+* system prompt is left in place even though it is large, because the CLI
+* sends it as a cache read (~6.5k cached tokens); replacing it with a short
+* one costs a fresh 3.5k-token prefill and measured slower end to end.
+*
+* The naming spec is this specific because a vaguer one ("describe what the
+* template does, at most 40 characters") produced names that were both
+* inconsistent in style and stripped of the detail that tells two similar
+* templates apart.
+*/
+function promptNamePrompt(draft) {
+	return [
+		"Below is a reusable prompt template a user is saving to a file. Name it.",
+		"",
+		`"""\n${draft.trim().slice(0, MAX_NAME_DRAFT_CHARS).replaceAll("\"\"\"", "\" \" \"")}\n"""`,
+		"",
+		"Answer with the file name alone: no quotes, no explanation, no extension, no leading dot, no slashes.",
+		"Write it in English however the template is written, as lower-case words joined by hyphens.",
+		"Name the task the template performs, keeping whatever detail distinguishes it from a",
+		"similar template. At most 6 words."
+	].join("\n");
+}
+/**
+* Rewrite the draft into something an agent can act on, with the draft fenced
+* as data for the same reason the naming prompt fences it.
+*
+* The rule about people and places is not politeness. Asked to rewrite
+* "后端 assign 给我", the model reached into Claude Code's ambient system
+* prompt and substituted the operator's actual email address — inventing a
+* detail the original never carried, and putting a personal address into a
+* message the user had not written it into. Naming the failure explicitly is
+* what stopped it; stripping the ambient context with `--system-prompt` also
+* stopped it but cost a fresh prefill and produced looser rewrites.
+*/
+function promptRefinePrompt(draft) {
+	return [
+		"Below is a prompt a user is about to send to a coding agent. Rewrite it so the agent can act on it without coming back with questions.",
+		"",
+		`"""\n${draft.trim().slice(0, MAX_REFINE_DRAFT_CHARS).replaceAll("\"\"\"", "\" \" \"")}\n"""`,
+		"",
+		"Keep the intent and every concrete detail exactly as given — names, paths, branches, identifiers, numbers.",
+		"Leave every reference to a person or place as the original wrote it (\"me\", \"我\", \"the usual branch\");",
+		"you do not know who or what they resolve to, and guessing puts a wrong name in the user's message.",
+		"Do not invent requirements the original does not imply, do not answer the prompt, do not add a preamble or sign-off.",
+		"Write the rewrite in the same language the original is written in.",
+		"Reply with the rewritten prompt alone."
+	].join("\n");
+}
+/** One turn, no tools, no MCP: neither of these tasks needs them, and both
+*  cost seconds of cold start. Variadic `--tools` stays last. */
+function promptAssistArguments() {
+	return [
+		"-p",
+		"--output-format",
+		"text",
+		"--model",
+		"haiku",
+		"--strict-mcp-config",
+		"--mcp-config",
+		"{\"mcpServers\":{}}",
+		"--tools",
+		""
+	];
+}
+/** The rewrite in a model reply, or undefined when the reply is unusable.
+*
+*  A model told to answer with the text alone still sometimes wraps it in a
+*  markdown fence, so one is peeled off; anything else is the user's to read
+*  and edit, and is passed through untouched. */
+function refinedPrompt(output) {
+	const trimmed = output.trim();
+	const text = (/^```[^\n]*\n([\s\S]*?)\n?```$/u.exec(trimmed)?.[1] ?? trimmed).trim();
+	return text.length === 0 || Buffer.byteLength(text) > MAX_REFINED_BYTES ? void 0 : text;
+}
+/**
+* The usable name in a model reply, or undefined when there is none.
+*
+* A one-line answer is what the prompt asks for and usually what comes back,
+* but "usually" is not a contract: the reply is scrubbed to what a file name
+* may hold and then held to the same {@link PROMPT_NAME} guard the write path
+* uses, so a chatty or malformed answer is dropped rather than offered.
+*/
+function suggestedName(output) {
+	const scrubbed = wordBounded((output.split("\n").map((text) => text.trim()).find((text) => text.length > 0) ?? "").replace(/^["'`]+|["'`]+$/gu, "").replace(/\.md$/iu, "").replace(/[^\p{L}\p{M}\p{N} ._()\[\]-]/gu, " ").replace(/\s+/gu, " ").trim());
+	return PROMPT_NAME.test(scrubbed) ? scrubbed : void 0;
+}
+/** Cut a long name at its last word boundary. A name the user has to repair
+*  ("analyze-frontend-backend-create-jira-tic") is worse than a shorter one. */
+function wordBounded(name) {
+	if (name.length <= MAX_SUGGESTED_NAME_CHARS) return name;
+	const cut = name.slice(0, MAX_SUGGESTED_NAME_CHARS);
+	const boundary = cut.search(/[\s\-_][^\s\-_]*$/u);
+	return (boundary > 0 ? cut.slice(0, boundary) : cut).trim();
+}
+/** Runs Claude Code's cheapest model over the draft: names it, or rewrites it. */
+var PromptAssistService = class {
+	#runtime;
+	#executablePath;
+	constructor(runtime, executablePath) {
+		this.#runtime = runtime;
+		this.#executablePath = executablePath;
+	}
+	/** One bounded, tool-less turn; undefined whenever it cannot be had. */
+	async #ask(prompt, maxOutputBytes, signal) {
+		const executablePath = this.#executablePath();
+		if (executablePath.length === 0) return void 0;
+		const timeout = AbortSignal.timeout(ASSIST_TIMEOUT_MS);
+		try {
+			const handle = this.#runtime.spawn({
+				argv: [executablePath, ...promptAssistArguments()],
+				cwd: homedir(),
+				stdio: {
+					stdin: { data: prompt },
+					stdout: { maxBytes: maxOutputBytes },
+					stderr: { maxBytes: MAX_NAME_OUTPUT_BYTES }
+				},
+				graceMs: 1e3,
+				signal: signal === void 0 ? timeout : AbortSignal.any([signal, timeout]),
+				env: { MAX_THINKING_TOKENS: "0" }
+			});
+			if ((await handle.done).exitCode !== 0) return void 0;
+			return handle.collected.stdout?.readFrom(0).text ?? "";
+		} catch {
+			return;
+		}
+	}
+	/** The suggested file name, or undefined whenever one cannot be had. The
+	*  caller already has a name derived locally, so every failure here is a
+	*  non-event: nothing is reported, and nothing is retried. */
+	async suggest(draft, signal) {
+		if (draft.trim().length === 0) return void 0;
+		const output = await this.#ask(promptNamePrompt(draft), MAX_NAME_OUTPUT_BYTES, signal);
+		return output === void 0 ? void 0 : suggestedName(output);
+	}
+	/** The rewritten draft, or undefined when the rewrite could not be had.
+	*  Unlike naming, this failure is worth reporting: the user asked for it and
+	*  is waiting on it. */
+	async refine(draft, signal) {
+		if (draft.trim().length === 0) return void 0;
+		const output = await this.#ask(promptRefinePrompt(draft), MAX_REFINED_BYTES, signal);
+		return output === void 0 ? void 0 : refinedPrompt(output);
+	}
+};
+/** List the user's prompt snippets, and save the composer draft as a new one. */
+function registerClaudePromptsRoute(ctx, directory = claudePromptsDir()) {
+	registerPluginRoute(ctx, {
+		mode: "unary",
+		kind: "exact",
+		path: CLAUDE_PROMPTS_PATH,
+		methods: ["GET", "POST"],
+		budget: "fast",
+		handler: async (io) => {
+			if (io.method === "GET") return {
+				status: 200,
+				value: { prompts: await readClaudePrompts(directory) }
+			};
+			const payload = await io.body(MAX_REQUEST_BYTES$1);
+			try {
+				return {
+					status: 200,
+					value: {
+						saved: true,
+						prompt: await writeClaudePrompt(directory, payload.name, payload.body)
+					}
+				};
+			} catch (error) {
+				if (error instanceof ClaudePromptWriteError) return {
+					status: error.code === "name-taken" ? 409 : 400,
+					value: {
+						error: error.code,
+						message: error.message
+					}
+				};
+				return {
+					status: 500,
+					value: {
+						error: "prompt-write-failed",
+						message: "The prompt could not be saved."
+					}
+				};
+			}
+		}
+	});
+}
+/** Suggest a file name for a draft. Answers `{}` when no name could be had:
+*  the caller keeps the name it derived locally, so this is never an error. */
+function registerClaudePromptNameRoute(ctx, service) {
+	registerPluginRoute(ctx, {
+		mode: "unary",
+		kind: "exact",
+		path: CLAUDE_PROMPT_NAME_PATH,
+		methods: ["POST"],
+		budget: "git",
+		handler: async (io) => {
+			const payload = await io.body(MAX_REQUEST_BYTES$1);
+			const draft = typeof payload.draft === "string" ? payload.draft : "";
+			const name = await service.suggest(draft, io.signal);
+			return {
+				status: 200,
+				value: name === void 0 ? {} : { name }
+			};
+		}
+	});
+}
+/** Rewrite a draft into something an agent can act on. */
+function registerClaudePromptRefineRoute(ctx, service) {
+	registerPluginRoute(ctx, {
+		mode: "unary",
+		kind: "exact",
+		path: CLAUDE_PROMPT_REFINE_PATH,
+		methods: ["POST"],
+		budget: "git",
+		handler: async (io) => {
+			const payload = await io.body(MAX_REQUEST_BYTES$1);
+			const draft = typeof payload.draft === "string" ? payload.draft : "";
+			if (draft.trim().length === 0) return {
+				status: 400,
+				value: {
+					error: "empty-draft",
+					message: "There is nothing to rewrite."
+				}
+			};
+			const text = await service.refine(draft, io.signal);
+			return text === void 0 ? {
+				status: 503,
+				value: {
+					error: "refine-unavailable",
+					message: "Claude could not rewrite the prompt."
+				}
+			} : {
+				status: 200,
+				value: { text }
+			};
+		}
+	});
+}
+//#endregion
 //#region src/github-url.ts
 /** Only GitHub's own image hosts; the browser loads these directly, so a URL
 *  the API did not vouch for must never become an outbound request. */
@@ -8158,12 +8899,12 @@ const ALERTS = {
 function isBoundedInteger(value, min, max) {
 	return typeof value === "number" && Number.isInteger(value) && value >= min && value <= max;
 }
-function integerSetting(key, min, max, defaultFor) {
+function integerSetting(key, min, max, defaultFor, effect = "new-session") {
 	return {
 		key,
 		kind: "text",
 		document: "plugin",
-		effect: "new-session",
+		effect,
 		maxLength: String(max).length,
 		read(document, defaults = DEFAULT_LIMITS) {
 			const value = document[key];
@@ -8182,7 +8923,7 @@ const DESCRIPTORS = [
 	PROSE,
 	ALERTS,
 	WORKTREE_BRANCH_PREFIX,
-	integerSetting("maxProcesses", 1, MAX_PROCESSES_LIMIT, (limits) => limits.maxProcesses),
+	integerSetting("maxProcesses", 1, MAX_PROCESSES_LIMIT, (limits) => limits.maxProcesses, "immediate"),
 	integerSetting("idleTimeoutMinutes", 1, MAX_IDLE_TIMEOUT_MINUTES, (limits) => Math.max(1, Math.round(limits.idleTimeoutMs / 6e4)))
 ];
 const DESCRIPTOR_BY_KEY = new Map(DESCRIPTORS.map((descriptor) => [descriptor.key, descriptor]));
@@ -8595,7 +9336,10 @@ async function apply(ctx, config) {
 		registerClaudeUpdateRoutes(webCtx, webCtx.subprocess, { ...typeof desktopActions?.requestRestart === "function" ? { requestRestart: desktopActions.requestRestart.bind(desktopActions) } : {} });
 		registerClaudeGlobalSettingsRoute(webCtx, {
 			defaultLimits,
-			onUpdated: applySettingsOverrides
+			onUpdated: async () => {
+				await applySettingsOverrides();
+				supervisor.limitsChanged();
+			}
 		});
 		registerRepositorySetupRoute(webCtx, repositorySetup, () => sweepWorktrees?.());
 		registerRepositoryStatusRoute(webCtx, repositoryStatus);
@@ -8609,6 +9353,10 @@ async function apply(ctx, config) {
 		};
 		registerRepositoryActionRoute(webCtx, repositoryActions, cwdForClaudeSession);
 		registerEditorOpenRoute(webCtx, new EditorOpenService(webCtx.subprocess), cwdForClaudeSession);
+		registerClaudePromptsRoute(webCtx);
+		const promptAssist = new PromptAssistService(webCtx.subprocess, () => supervisorConfig.executablePath);
+		registerClaudePromptNameRoute(webCtx, promptAssist);
+		registerClaudePromptRefineRoute(webCtx, promptAssist);
 		registerPullRequestFeedbackRoute(webCtx, new PullRequestFeedbackService(webCtx.subprocess), cwdForClaudeSession);
 		registerAskRoute(webCtx, new AskService(webCtx.subprocess, supervisorConfig.executablePath), cwdForClaudeSession, (sessionId) => {
 			const snapshot = supervisor.snapshots().find((item) => item.sessionId === sessionId);