@norman-else/dsh-claude 0.1.41 → 0.1.42

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 #createEntry(agent, model, thinkingMode) {
+	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, 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;
@@ -2677,6 +2926,8 @@ 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) {
@@ -2758,9 +3009,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 +3195,7 @@ var ClaudeSupervisor = class {
 		if (entry.process !== void 0) try {
 			await entry.process.handle.waitForExit(AbortSignal.timeout(5e3));
 		} catch {}
+		this.#notifyCapacityChange();
 	}
 };
 //#endregion
@@ -3995,7 +4249,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 +4262,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) => {
@@ -6062,6 +6321,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 +8769,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 +8793,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 +9206,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 +9223,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);